anchor.diff:          ];
           expectLater(bloc, emitsInOrder(expected));
           // act
  -        bloc.add(RecentlyAddedLoadNewServer(tautulliId: tTautulliId2));
  +        bloc.add(RecentlyAddedFilter(
  +          tautulliId: tTautulliId2,
  +          mediaType: tMediaType2,
  +        ));
         },
       );
     });
  
positive.code:   final tTautulliId = 'jkl';
    final tTautulliId2 = 'mno';
    final tCount = 10;
  
    final List<RecentItem> tRecentList = [];
  
  
negative.code:   );
  
    group('RecentlyAddedFetched', () {
      group('media type is all', () {
        test(
          'should get data from GetRecentlyAdded use case',
          () async {
            // arrange
            setUpSuccess();
            // act
            bloc.add(RecentlyAddedFetched(
              tautulliId: tTautulliId,
              mediaType: tMediaType,
            ));
            await untilCalled(mockGetRecentlyAdded(
              tautulliId: anyNamed('tautulliId'),
              count: anyNamed('count'),
              start: anyNamed('start'),
              mediaType: anyNamed('mediaType'),
              sectionId: anyNamed('sectionId'),
            ));
            // assert
            verify(
              mockGetRecentlyAdded(
                tautulliId: tTautulliId,
                count: 50,
              ),
            );
          },
        );
  
        test(
          'should get data from the GetImageUrl use case',
          () async {
            // arrange
            setUpSuccess();
            // act
            bloc.add(RecentlyAddedFetched(
              tautulliId: tTautulliId,
              mediaType: tMediaType2,
            ));
            await untilCalled(
              mockGetImageUrl(
                tautulliId: anyNamed('tautulliId'),
                img: anyNamed('img'),
                ratingKey: anyNamed('ratingKey'),
                fallback: anyNamed('fallback'),
              ),
            );
            // assert
            verify(
              mockGetImageUrl(
                tautulliId: anyNamed('tautulliId'),
                img: anyNamed('img'),
                ratingKey: anyNamed('ratingKey'),
                fallback: anyNamed('fallback'),
              ),
            );
          },
        );
  
        test(
          'should emit [RecentlyAddedFailure] with a proper message when getting data fails',
          () async {
            // arrange
            final failure = ServerFailure();
            when(
              mockGetRecentlyAdded(
                tautulliId: anyNamed('tautulliId'),
                count: anyNamed('count'),
                start: anyNamed('start'),
                mediaType: anyNamed('mediaType'),
                sectionId: anyNamed('sectionId'),
              ),
            ).thenAnswer((_) async => Left(failure));
            // assert later
            final expected = [
              RecentlyAddedFailure(
                failure: failure,
                message: SERVER_FAILURE_MESSAGE,
                suggestion: CHECK_SERVER_SETTINGS_SUGGESTION,
              ),
            ];
            expectLater(bloc, emitsInOrder(expected));
            // act
            bloc.add(RecentlyAddedFetched(
              tautulliId: tTautulliId,
              mediaType: tMediaType2,
            ));
          },
        );
      });
  
      group('media type is movie, show, artist, other_video', () {
        test(
          'should get data from GetRecentlyAdded use case',
          () async {
            // arrange
            setUpSuccess();
            // act
            bloc.add(RecentlyAddedFetched(
              tautulliId: tTautulliId,
              mediaType: tMediaType2,
            ));
            await untilCalled(mockGetRecentlyAdded(
              tautulliId: anyNamed('tautulliId'),
              count: anyNamed('count'),
              start: anyNamed('start'),
              mediaType: anyNamed('mediaType'),
              sectionId: anyNamed('sectionId'),
            ));
            // assert
            verify(
              mockGetRecentlyAdded(
                tautulliId: tTautulliId,
                count: tCount,
                mediaType: tMediaType2,
              ),
            );
          },
        );
  
        test(
          'should get data from the GetImageUrl use case',
          () async {
            // arrange
            setUpSuccess();
            // act
            bloc.add(RecentlyAddedFetched(
              tautulliId: tTautulliId,
              mediaType: tMediaType2,
            ));
            await untilCalled(
              mockGetImageUrl(
                tautulliId: anyNamed('tautulliId'),
                img: anyNamed('img'),
                ratingKey: anyNamed('ratingKey'),
                fallback: anyNamed('fallback'),
              ),
            );
            // assert
            verify(
              mockGetImageUrl(
                tautulliId: anyNamed('tautulliId'),
                img: anyNamed('img'),
                ratingKey: anyNamed('ratingKey'),
                fallback: anyNamed('fallback'),
              ),
            );
          },
        );
  
        test(
          'should emit [RecentlyAddedSuccess] with hasReachedMax as false when data is fetched successfully',
          () async {
            // arrange
            setUpSuccess();
            // assert later
            final expected = [
              RecentlyAddedSuccess(
                list: tRecentList,
                hasReachedMax: false,
              ),
            ];
            expectLater(bloc, emitsInOrder(expected));
            // act
            bloc.add(RecentlyAddedFetched(
              tautulliId: tTautulliId,
              mediaType: tMediaType2,
            ));
          },
        );
  
        test(
          'should emit [RecentlyAddedFailure] with a proper message when getting data fails',
          () async {
            // arrange
            final failure = ServerFailure();
            when(
              mockGetRecentlyAdded(
                tautulliId: anyNamed('tautulliId'),
                count: anyNamed('count'),
                start: anyNamed('start'),
                mediaType: anyNamed('mediaType'),
                sectionId: anyNamed('sectionId'),
              ),
            ).thenAnswer((_) async => Left(failure));
            // assert later
            final expected = [
              RecentlyAddedFailure(
                failure: failure,
                message: SERVER_FAILURE_MESSAGE,
                suggestion: CHECK_SERVER_SETTINGS_SUGGESTION,
              ),
            ];
            expectLater(bloc, emitsInOrder(expected));
            // act
            bloc.add(RecentlyAddedFetched(
              tautulliId: tTautulliId,
              mediaType: tMediaType2,
            ));
          },
        );
  
        test(
          'when state is [RecentlyAddedSuccess] should emit [RecentlyAddedSuccess] with hasReachedMax as false when data is fetched successfully',
          () async {
            // arrange
            setUpSuccess();
            bloc.emit(
              RecentlyAddedSuccess(
                list: tRecentList,
                hasReachedMax: false,
              ),
            );
            // assert later
            final expected = [
              RecentlyAddedSuccess(
                list: tRecentList + tRecentList,
                hasReachedMax: false,
              ),
            ];
            expectLater(bloc, emitsInOrder(expected));
            // act
            bloc.add(RecentlyAddedFetched(
              tautulliId: tTautulliId,
              mediaType: tMediaType2,
            ));
          },
        );
  
        test(
          'when state is [RecentlyAddedSuccess] should emit [RecentlyAddedSuccess] with hasReachedMax as true when data is fetched successfully and empty',
          () async {
            // arrange
            setUpEmptySuccess();
            bloc.emit(
              RecentlyAddedSuccess(
                list: tRecentList,
                hasReachedMax: false,
              ),
            );
            // assert later
            final expected = [
              RecentlyAddedSuccess(
                list: tRecentList,
                hasReachedMax: true,
              ),
            ];
            expectLater(bloc, emitsInOrder(expected));
            // act
            bloc.add(RecentlyAddedFetched(
              tautulliId: tTautulliId,
              mediaType: tMediaType2,
            ));
          },
        );
      });
    });
  
    group('RecentlyAddedFilter', () {
      test(
        'should emit [RecentlyAddedInitial] before executing as normal',
        () async {
  