Flutter test failure, unit test expected and actual state object are the same but still fails on test run

Please I'm having error using test_bloc, here's the error.

package:test_api                             expect
package:bloc_test/src/bloc_test.dart 176:9   runBlocTest.<fn>
===== asynchronous gap ===========================
dart:async                                   _asyncThenWrapperHelper
package:bloc_test/src/bloc_test.dart         runBlocTest.<fn>
dart:async                                   runZoned
package:bloc_test/src/bloc_test.dart 157:9   runBlocTest
package:bloc_test/src/bloc_test.dart 127:11  blocTest.<fn>

Expected: [
            UserDetailsGottenState:UserDetailsGottenState(User(wiidnsdnv, jasper@gmail.com))
          ]
  Actual: [UserDetailGottenState:UserDetailGottenState(User(wiidnsdnv, jasper@gmail.com))]
   Which: at location [0] is UserDetailGottenState:<UserDetailGottenState(User(wiidnsdnv, jasper@gmail.com))> instead of UserDetailsGottenState:<UserDetailsGottenState(User(wiidnsdnv, jasper@gmail.com))>

The state expected and the actual state that yield bloc yields are the same, but test still fails, point to note is, i'm using equatable for the states, events and User model classes.

When a UserDetailsGottenEvent(user: userObject) is passed to the bloc i expect a UserDetalsGottenState(user: userObject) to be yielded, which is what occurs. But fails when i run the test class for user_bloc.

My Test code

import 'package:bloc_test/bloc_test.dart';
import 'package:encards/bloc/user_bloc.dart';
import 'package:encards/events/user_event.dart';
import 'package:encards/models/User.dart';
import 'package:encards/states/home_state.dart';
import 'package:encards/states/user_state.dart';
import 'package:flutter_test/flutter_test.dart';

void main() {
  group(
    'UserBloc',
    () {
      UserBloc _userBloc;
      var user = User(
          email: "jasper@gmail.com",
          name: "Jasper",
          role: "super_admin",
          uid: "wiidnsdnv");

      setUp(() {
        _userBloc = UserBloc(null);
      });
      group(
        'LogOut',
        () {
          blocTest(
            'emits [LogoutState]',
            build: () {
              return _userBloc;
            },
            act: (UserBloc bloc) {
              bloc.add(
                LogoutEvent(),
              );
            },
            expect: [LogoutState()],
          );
        },
      );

      group(
        'UserDetailsGotten',
        () {
          blocTest(
            'emits [UserDetailGottenState]',
            build: () {
              return _userBloc;
            },
            act: (UserBloc bloc) {
              bloc.add(
                UserDetailGottenEvent(
                  user: user,
                ),
              );
            },
            expect: [UserDetailsGottenState(user: user)],
          );
        },
      );
    },
  );
}

State class

import 'package:encards/models/User.dart';
import 'package:equatable/equatable.dart';
import 'package:flutter/cupertino.dart';

@immutable
abstract class UserState extends Equatable {}

class LogoutState extends UserState {
  @override
  List<Object> get props => [];

  @override
  bool get stringify => true;
}

class UserDetailGottenState extends UserState {
  final User user;

  UserDetailGottenState({@required this.user});

  @override
  List<Object> get props => [this.user];

  @override
  bool get stringify => true;
}

Here's my bloc class too

import 'package:encards/events/user_event.dart' as event;
import 'package:encards/states/user_state.dart' as state;
import 'package:flutter_bloc/flutter_bloc.dart';

class UserBloc extends Bloc<event.UserEvent, state.UserState> {
  UserBloc(state.UserState initialState) : super(initialState);

  @override
  Stream<state.UserState> mapEventToState(event.UserEvent event_) async* {
    if (event_ is event.UserDetailGottenEvent) {
      yield state.UserDetailGottenState(user: event_.user);
    } else if (event_ is event.LogoutEvent) yield state.LogoutState();
  }
}

Thanks.