How to use anyIterable method of org.mockito.ArgumentMatchers class

Best Mockito code snippet using org.mockito.ArgumentMatchers.anyIterable

Source:GameFilterServiceImplTest.java

...99    void findGamesByFilters_withNullPlatformIds_doesntInvokePlatformRepository() {100        // Arrange101        Set<Long> genreIds = Collections.singleton(1L);102        Set<GameMode> gameModes = Collections.emptySet();103        Mockito.when(genreRepository.findAllById(ArgumentMatchers.anyIterable()))104                .thenReturn(Collections.singletonList(new Genre()));105        Mockito.when(gameRepository.findAll(ArgumentMatchers.any(GameSearchSpecification.class), ArgumentMatchers.any(Pageable.class)))106                .thenReturn(new PageImpl<>(List.of(new Game(), new Game())));107        Mockito.when(gameDetailsMapper.fromGame(ArgumentMatchers.any()))108                .thenReturn(new GameDetailsDto());109        // Act110        gameFilterService.findGamesByFilters(null, genreIds, gameModes, Pageable.unpaged());111        // Assert112        Mockito.verify(platformRepository, Mockito.never())113                .findAllById(ArgumentMatchers.anyIterable());114        Mockito.verify(gameDetailsMapper, Mockito.atMost(2))115                .fromGame(ArgumentMatchers.any());116    }117    @Test118    void findGamesByFilters_withNoPlatformIds_doesntInvokePlatformRepository() {119        // Arrange120        Set<Long> platformIds = Collections.emptySet();121        Set<Long> genreIds = Collections.singleton(1L);122        Set<GameMode> gameModes = Collections.emptySet();123        Mockito.when(genreRepository.findAllById(ArgumentMatchers.anyIterable()))124                .thenReturn(Collections.singletonList(new Genre()));125        Mockito.when(gameRepository.findAll(ArgumentMatchers.any(GameSearchSpecification.class), ArgumentMatchers.any(Pageable.class)))126                .thenReturn(new PageImpl<>(List.of(new Game(), new Game())));127        Mockito.when(gameDetailsMapper.fromGame(ArgumentMatchers.any()))128                .thenReturn(new GameDetailsDto());129        // Act130        gameFilterService.findGamesByFilters(platformIds, genreIds, gameModes, Pageable.unpaged());131        // Assert132        Mockito.verify(platformRepository, Mockito.never())133                .findAllById(ArgumentMatchers.anyIterable());134        Mockito.verify(gameDetailsMapper, Mockito.atMost(2))135                .fromGame(ArgumentMatchers.any());136    }137    @Test138    void findGamesByFilters_withNullGenreIds_doesntInvokeGenreRepository() {139        // Arrange140        Set<Long> platformIds = Collections.singleton(1L);141        Set<GameMode> gameModes = Collections.emptySet();142        Mockito.when(platformRepository.findAllById(ArgumentMatchers.anyIterable()))143                .thenReturn(Collections.singletonList(new Platform()));144        Mockito.when(gameRepository.findAll(ArgumentMatchers.any(GameSearchSpecification.class), ArgumentMatchers.any(Pageable.class)))145                .thenReturn(new PageImpl<>(List.of(new Game(), new Game())));146        Mockito.when(gameDetailsMapper.fromGame(ArgumentMatchers.any()))147                .thenReturn(new GameDetailsDto());148        // Act149        gameFilterService.findGamesByFilters(platformIds, null, gameModes, Pageable.unpaged());150        // Assert151        Mockito.verify(genreRepository, Mockito.never())152                .findAllById(ArgumentMatchers.anyIterable());153        Mockito.verify(gameDetailsMapper, Mockito.atMost(2))154                .fromGame(ArgumentMatchers.any());155    }156    @Test157    void findGamesByFilters_withNoGenreIds_doesntInvokeGenreRepository() {158        // Arrange159        Set<Long> platformIds = Collections.singleton(1L);160        Set<Long> genreIds = Collections.emptySet();161        Set<GameMode> gameModes = Collections.emptySet();162        Mockito.when(platformRepository.findAllById(ArgumentMatchers.anyIterable()))163                .thenReturn(Collections.singletonList(new Platform()));164        Mockito.when(gameRepository.findAll(ArgumentMatchers.any(GameSearchSpecification.class), ArgumentMatchers.any(Pageable.class)))165                .thenReturn(new PageImpl<>(List.of(new Game(), new Game())));166        Mockito.when(gameDetailsMapper.fromGame(ArgumentMatchers.any()))167                .thenReturn(new GameDetailsDto());168        // Act169        gameFilterService.findGamesByFilters(platformIds, genreIds, gameModes, Pageable.unpaged());170        // Assert171        Mockito.verify(genreRepository, Mockito.never())172                .findAllById(ArgumentMatchers.anyIterable());173        Mockito.verify(gameDetailsMapper, Mockito.atMost(2))174                .fromGame(ArgumentMatchers.any());175    }176    @Test177    void findGamesByFilters_withPlatformAndGenreIds_invokesRepositories() {178        // Arrange179        Set<Long> platformIds = Collections.singleton(1L);180        Set<Long> genreIds = Collections.emptySet();181        Set<GameMode> gameModes = Collections.emptySet();182        Mockito.when(gameRepository.findAll(ArgumentMatchers.any(GameSearchSpecification.class), ArgumentMatchers.any(Pageable.class)))183                .thenReturn(new PageImpl<>(List.of(new Game(), new Game())));184        Mockito.when(gameDetailsMapper.fromGame(ArgumentMatchers.any()))185                .thenReturn(new GameDetailsDto());186        // Act187        gameFilterService.findGamesByFilters(platformIds, genreIds, gameModes, Pageable.unpaged());188        // Assert189        Mockito.verify(platformRepository, Mockito.atMostOnce())190                .findAllById(ArgumentMatchers.anyIterable());191        Mockito.verify(genreRepository, Mockito.atMostOnce())192                .findAllById(ArgumentMatchers.anyIterable());193        Mockito.verify(gameDetailsMapper, Mockito.atMost(2))194                .fromGame(ArgumentMatchers.any());195    }196    @Test197    void countGamesByFilters_withNullPlatformIds_doesntInvokePlatformRepository() {198        // Arrange199        Set<Long> genreIds = Collections.singleton(1L);200        Set<GameMode> gameModes = Collections.emptySet();201        Mockito.when(genreRepository.findAllById(ArgumentMatchers.anyIterable()))202                .thenReturn(Collections.singletonList(new Genre()));203        Mockito.when(gameRepository.count(ArgumentMatchers.any(GameSearchSpecification.class)))204                .thenReturn(0L);205        // Act206        gameFilterService.countGamesByFilters(null, genreIds, gameModes);207        // Assert208        Mockito.verify(platformRepository, Mockito.never())209                .findAllById(ArgumentMatchers.anyIterable());210    }211    @Test212    void countGamesByFilters_withNoPlatformIds_doesntInvokePlatformRepository() {213        // Arrange214        Set<Long> platformIds = Collections.emptySet();215        Set<Long> genreIds = Collections.singleton(1L);216        Set<GameMode> gameModes = Collections.emptySet();217        Mockito.when(genreRepository.findAllById(ArgumentMatchers.anyIterable()))218                .thenReturn(Collections.singletonList(new Genre()));219        Mockito.when(gameRepository.count(ArgumentMatchers.any(GameSearchSpecification.class)))220                .thenReturn(0L);221        // Act222        gameFilterService.countGamesByFilters(platformIds, genreIds, gameModes);223        // Assert224        Mockito.verify(platformRepository, Mockito.never())225                .findAllById(ArgumentMatchers.anyIterable());226    }227    @Test228    void countGamesByFilters_withNullGenreIds_doesntInvokeGenreRepository() {229        // Arrange230        Set<Long> platformIds = Collections.singleton(1L);231        Set<GameMode> gameModes = Collections.emptySet();232        Mockito.when(platformRepository.findAllById(ArgumentMatchers.anyIterable()))233                .thenReturn(Collections.singletonList(new Platform()));234        Mockito.when(gameRepository.count(ArgumentMatchers.any(GameSearchSpecification.class)))235                .thenReturn(0L);236        // Act237        gameFilterService.countGamesByFilters(platformIds, null, gameModes);238        // Assert239        Mockito.verify(genreRepository, Mockito.never())240                .findAllById(ArgumentMatchers.anyIterable());241    }242    @Test243    void countGamesByFilters_withNoGenreIds_doesntInvokeGenreRepository() {244        // Arrange245        Set<Long> platformIds = Collections.singleton(1L);246        Set<Long> genreIds = Collections.emptySet();247        Set<GameMode> gameModes = Collections.emptySet();248        Mockito.when(platformRepository.findAllById(ArgumentMatchers.anyIterable()))249                .thenReturn(Collections.singletonList(new Platform()));250        Mockito.when(gameRepository.count(ArgumentMatchers.any(GameSearchSpecification.class)))251                .thenReturn(0L);252        // Act253        gameFilterService.countGamesByFilters(platformIds, genreIds, gameModes);254        // Assert255        Mockito.verify(genreRepository, Mockito.never())256                .findAllById(ArgumentMatchers.anyIterable());257    }258    @Test259    void countGamesByFilters_withPlatformAndGenreIds_invokesRepositories() {260        // Arrange261        Set<Long> platformIds = Collections.singleton(1L);262        Set<Long> genreIds = Collections.emptySet();263        Set<GameMode> gameModes = Collections.emptySet();264        Mockito.when(gameRepository.count(ArgumentMatchers.any(GameSearchSpecification.class)))265                .thenReturn(0L);266        // Act267        gameFilterService.countGamesByFilters(platformIds, genreIds, gameModes);268        // Assert269        Mockito.verify(platformRepository, Mockito.atMostOnce())270                .findAllById(ArgumentMatchers.anyIterable());271        Mockito.verify(genreRepository, Mockito.atMostOnce())272                .findAllById(ArgumentMatchers.anyIterable());273    }274    @Test275    void findGameUserEntriesByFilters_withNullPlatformIds_doesntInvokePlatformRepository() {276        // Arrange277        Set<Long> genreIds = Collections.singleton(1L);278        Set<GameMode> gameModes = Collections.emptySet();279        Set<GameUserEntryStatus> statuses = Collections.emptySet();280        Mockito.when(genreRepository.findAllById(ArgumentMatchers.anyIterable()))281                .thenReturn(Collections.singletonList(new Genre()));282        Mockito.when(gameUserEntryRepository.findAll(ArgumentMatchers.any(GameUserEntrySearchSpecification.class), ArgumentMatchers.any(Pageable.class)))283                .thenReturn(new PageImpl<>(List.of(new GameUserEntry(), new GameUserEntry())));284        Mockito.when(gameUserEntryMapper.fromGameUserEntry(ArgumentMatchers.any()))285                .thenReturn(new GameUserEntryDto());286        // Act287        gameFilterService.findGameUserEntriesByFilters(null, genreIds, gameModes, statuses, Pageable.unpaged());288        // Assert289        Mockito.verify(platformRepository, Mockito.never())290                .findAllById(ArgumentMatchers.anyIterable());291        Mockito.verify(gameUserEntryMapper, Mockito.atMost(2))292                .fromGameUserEntry(ArgumentMatchers.any());293    }294    @Test295    void findGameUserEntriesByFilters_withNoPlatformIds_doesntInvokePlatformRepository() {296        // Arrange297        Set<Long> platformIds = Collections.emptySet();298        Set<Long> genreIds = Collections.singleton(1L);299        Set<GameMode> gameModes = Collections.emptySet();300        Set<GameUserEntryStatus> statuses = Collections.emptySet();301        Mockito.when(genreRepository.findAllById(ArgumentMatchers.anyIterable()))302                .thenReturn(Collections.singletonList(new Genre()));303        Mockito.when(gameUserEntryRepository.findAll(ArgumentMatchers.any(GameUserEntrySearchSpecification.class), ArgumentMatchers.any(Pageable.class)))304                .thenReturn(new PageImpl<>(List.of(new GameUserEntry(), new GameUserEntry())));305        Mockito.when(gameUserEntryMapper.fromGameUserEntry(ArgumentMatchers.any()))306                .thenReturn(new GameUserEntryDto());307        // Act308        gameFilterService.findGameUserEntriesByFilters(platformIds, genreIds, gameModes, statuses, Pageable.unpaged());309        // Assert310        Mockito.verify(platformRepository, Mockito.never())311                .findAllById(ArgumentMatchers.anyIterable());312        Mockito.verify(gameUserEntryMapper, Mockito.atMost(2))313                .fromGameUserEntry(ArgumentMatchers.any());314    }315    @Test316    void findGameUserEntriesByFilters_withNullGenreIds_doesntInvokeGenreRepository() {317        // Arrange318        Set<Long> platformIds = Collections.singleton(1L);319        Set<GameMode> gameModes = Collections.emptySet();320        Set<GameUserEntryStatus> statuses = Collections.emptySet();321        Mockito.when(platformRepository.findAllById(ArgumentMatchers.anyIterable()))322                .thenReturn(Collections.singletonList(new Platform()));323        Mockito.when(gameUserEntryRepository.findAll(ArgumentMatchers.any(GameUserEntrySearchSpecification.class), ArgumentMatchers.any(Pageable.class)))324                .thenReturn(new PageImpl<>(List.of(new GameUserEntry(), new GameUserEntry())));325        Mockito.when(gameUserEntryMapper.fromGameUserEntry(ArgumentMatchers.any()))326                .thenReturn(new GameUserEntryDto());327        // Act328        gameFilterService.findGameUserEntriesByFilters(platformIds, null, gameModes, statuses, Pageable.unpaged());329        // Assert330        Mockito.verify(genreRepository, Mockito.never())331                .findAllById(ArgumentMatchers.anyIterable());332        Mockito.verify(gameUserEntryMapper, Mockito.atMost(2))333                .fromGameUserEntry(ArgumentMatchers.any());334    }335    @Test336    void findGameUserEntriesByFilters_withNoGenreIds_doesntInvokeGenreRepository() {337        // Arrange338        Set<Long> platformIds = Collections.singleton(1L);339        Set<Long> genreIds = Collections.emptySet();340        Set<GameMode> gameModes = Collections.emptySet();341        Set<GameUserEntryStatus> statuses = Collections.emptySet();342        Mockito.when(platformRepository.findAllById(ArgumentMatchers.anyIterable()))343                .thenReturn(Collections.singletonList(new Platform()));344        Mockito.when(gameUserEntryRepository.findAll(ArgumentMatchers.any(GameUserEntrySearchSpecification.class), ArgumentMatchers.any(Pageable.class)))345                .thenReturn(new PageImpl<>(List.of(new GameUserEntry(), new GameUserEntry())));346        Mockito.when(gameUserEntryMapper.fromGameUserEntry(ArgumentMatchers.any()))347                .thenReturn(new GameUserEntryDto());348        // Act349        gameFilterService.findGameUserEntriesByFilters(platformIds, genreIds, gameModes, statuses, Pageable.unpaged());350        // Assert351        Mockito.verify(genreRepository, Mockito.never())352                .findAllById(ArgumentMatchers.anyIterable());353        Mockito.verify(gameUserEntryMapper, Mockito.atMost(2))354                .fromGameUserEntry(ArgumentMatchers.any());355    }356    @Test357    void findGameUserEntriesByFilters_withPlatformAndGenreIds_invokesRepositories() {358        // Arrange359        Set<Long> platformIds = Collections.singleton(1L);360        Set<Long> genreIds = Collections.emptySet();361        Set<GameMode> gameModes = Collections.emptySet();362        Set<GameUserEntryStatus> statuses = Collections.emptySet();363        Mockito.when(gameUserEntryRepository.findAll(ArgumentMatchers.any(GameUserEntrySearchSpecification.class), ArgumentMatchers.any(Pageable.class)))364                .thenReturn(new PageImpl<>(List.of(new GameUserEntry(), new GameUserEntry())));365        Mockito.when(gameUserEntryMapper.fromGameUserEntry(ArgumentMatchers.any()))366                .thenReturn(new GameUserEntryDto());367        // Act368        gameFilterService.findGameUserEntriesByFilters(platformIds, genreIds, gameModes, statuses, Pageable.unpaged());369        // Assert370        Mockito.verify(platformRepository, Mockito.atMostOnce())371                .findAllById(ArgumentMatchers.anyIterable());372        Mockito.verify(genreRepository, Mockito.atMostOnce())373                .findAllById(ArgumentMatchers.anyIterable());374        Mockito.verify(gameUserEntryMapper, Mockito.atMost(2))375                .fromGameUserEntry(ArgumentMatchers.any());376    }377    @Test378    void countGameUserEntriesByFilters_withNullPlatformIds_doesntInvokePlatformRepository() {379        // Arrange380        Set<Long> genreIds = Collections.singleton(1L);381        Set<GameMode> gameModes = Collections.emptySet();382        Set<GameUserEntryStatus> statuses = Collections.emptySet();383        Mockito.when(genreRepository.findAllById(ArgumentMatchers.anyIterable()))384                .thenReturn(Collections.singletonList(new Genre()));385        Mockito.when(gameUserEntryRepository.count(ArgumentMatchers.any(GameUserEntrySearchSpecification.class)))386                .thenReturn(0L);387        // Act388        gameFilterService.countGameUserEntriesByFilters(null, genreIds, gameModes, statuses);389        // Assert390        Mockito.verify(platformRepository, Mockito.never())391                .findAllById(ArgumentMatchers.anyIterable());392    }393    @Test394    void countGameUserEntriesByFilters_withNoPlatformIds_doesntInvokePlatformRepository() {395        // Arrange396        Set<Long> platformIds = Collections.emptySet();397        Set<Long> genreIds = Collections.singleton(1L);398        Set<GameMode> gameModes = Collections.emptySet();399        Set<GameUserEntryStatus> statuses = Collections.emptySet();400        Mockito.when(genreRepository.findAllById(ArgumentMatchers.anyIterable()))401                .thenReturn(Collections.singletonList(new Genre()));402        Mockito.when(gameUserEntryRepository.count(ArgumentMatchers.any(GameUserEntrySearchSpecification.class)))403                .thenReturn(0L);404        // Act405        gameFilterService.countGameUserEntriesByFilters(platformIds, genreIds, gameModes, statuses);406        // Assert407        Mockito.verify(platformRepository, Mockito.never())408                .findAllById(ArgumentMatchers.anyIterable());409    }410    @Test411    void countGameUserEntriesByFilters_withNullGenreIds_doesntInvokeGenreRepository() {412        // Arrange413        Set<Long> platformIds = Collections.singleton(1L);414        Set<GameMode> gameModes = Collections.emptySet();415        Set<GameUserEntryStatus> statuses = Collections.emptySet();416        Mockito.when(platformRepository.findAllById(ArgumentMatchers.anyIterable()))417                .thenReturn(Collections.singletonList(new Platform()));418        Mockito.when(gameUserEntryRepository.count(ArgumentMatchers.any(GameUserEntrySearchSpecification.class)))419                .thenReturn(0L);420        // Act421        gameFilterService.countGameUserEntriesByFilters(platformIds, null, gameModes, statuses);422        // Assert423        Mockito.verify(genreRepository, Mockito.never())424                .findAllById(ArgumentMatchers.anyIterable());425    }426    @Test427    void countGameUserEntriesByFilters_withNoGenreIds_doesntInvokeGenreRepository() {428        // Arrange429        Set<Long> platformIds = Collections.singleton(1L);430        Set<Long> genreIds = Collections.emptySet();431        Set<GameMode> gameModes = Collections.emptySet();432        Set<GameUserEntryStatus> statuses = Collections.emptySet();433        Mockito.when(platformRepository.findAllById(ArgumentMatchers.anyIterable()))434                .thenReturn(Collections.singletonList(new Platform()));435        Mockito.when(gameUserEntryRepository.count(ArgumentMatchers.any(GameUserEntrySearchSpecification.class)))436                .thenReturn(0L);437        // Act438        gameFilterService.countGameUserEntriesByFilters(platformIds, genreIds, gameModes, statuses);439        // Assert440        Mockito.verify(genreRepository, Mockito.never())441                .findAllById(ArgumentMatchers.anyIterable());442    }443    @Test444    void countGameUserEntriesByFilters_withPlatformAndGenreIds_invokesRepositories() {445        // Arrange446        Set<Long> platformIds = Collections.singleton(1L);447        Set<Long> genreIds = Collections.emptySet();448        Set<GameMode> gameModes = Collections.emptySet();449        Set<GameUserEntryStatus> statuses = Collections.emptySet();450        Mockito.when(gameUserEntryRepository.count(ArgumentMatchers.any(GameUserEntrySearchSpecification.class)))451                .thenReturn(0L);452        // Act453        gameFilterService.countGameUserEntriesByFilters(platformIds, genreIds, gameModes, statuses);454        // Assert455        Mockito.verify(platformRepository, Mockito.atMostOnce())456                .findAllById(ArgumentMatchers.anyIterable());457        Mockito.verify(genreRepository, Mockito.atMostOnce())458                .findAllById(ArgumentMatchers.anyIterable());459    }460}...

Source:MatchersMixin.java

...77    default int anyInt() {78        return ArgumentMatchers.anyInt();79    }80    /**81     * Delegate call to public static <T> java.lang.Iterable<T> org.mockito.ArgumentMatchers.anyIterable()82     * {@link org.mockito.ArgumentMatchers#anyIterable()}83     */84    default <T> Iterable<T> anyIterable() {85        return ArgumentMatchers.anyIterable();86    }87    /**88     * Delegate call to public static <T> java.util.List<T> org.mockito.ArgumentMatchers.anyList()89     * {@link org.mockito.ArgumentMatchers#anyList()}90     */91    default <T> List<T> anyList() {92        return ArgumentMatchers.anyList();93    }94    /**95     * Delegate call to public static long org.mockito.ArgumentMatchers.anyLong()96     * {@link org.mockito.ArgumentMatchers#anyLong()}97     */98    default long anyLong() {99        return ArgumentMatchers.anyLong();...

Source:UsageOfAnyMatchersInspectionAnyXTest.java

...10    protected InspectionProfileEntry getInspection() {11        return new UsageOfAnyMatchersInspection();12    }13    public void testArgumentMatchersAnyIterableOfReplacedWithAnyIterable() {14        doQuickFixTest("Replace with ArgumentMatchers.anyIterable()", "UseAnyIterableInsteadOfAnyIterableOfTest.java",15            "import org.mockito.Mockito;\n" +16                "import org.mockito.ArgumentMatchers;\n" +17                "\n" +18                "public class UseAnyIterableInsteadOfAnyIterableOfTest {\n" +19                "   public void testMethod() {\n" +20                "       MockObject mock = Mockito.mock(MockObject.class);\n" +21                "       Mockito.doReturn(10).when(mock).method(ArgumentMatchers.anyIterable<caret>Of(String.class));\n" +22                "   }\n" +23                "   private static final class MockObject {\n" +24                "       public int method(Iterable<String> s) {\n" +25                "           return 0;\n" +26                "       }\n" +27                "   }\n" +28                "}",29            "import org.mockito.Mockito;\n" +30                "import org.mockito.ArgumentMatchers;\n" +31                "\n" +32                "public class UseAnyIterableInsteadOfAnyIterableOfTest {\n" +33                "   public void testMethod() {\n" +34                "       MockObject mock = Mockito.mock(MockObject.class);\n" +35                "       Mockito.doReturn(10).when(mock).method(ArgumentMatchers.anyIterable());\n" +36                "   }\n" +37                "   private static final class MockObject {\n" +38                "       public int method(Iterable<String> s) {\n" +39                "           return 0;\n" +40                "       }\n" +41                "   }\n" +42                "}");43    }44    public void testArgumentMatchersAnyMapOfReplacedWithAnyMap() {45        doQuickFixTest("Replace with ArgumentMatchers.anyMap()", "UseAnyMapInsteadOfAnyMapOfTest.java",46            "import org.mockito.Mockito;\n" +47                "import org.mockito.ArgumentMatchers;\n" +48                "import java.util.Map;\n" +49                "\n" +50                "public class UseAnyMapInsteadOfAnyMapOfTest {\n" +51                "   public void testMethod() {\n" +52                "       MockObject mock = Mockito.mock(MockObject.class);\n" +53                "       Mockito.doReturn(10).when(mock).method(ArgumentMatchers.anyMap<caret>Of(String.class, String.class));\n" +54                "   }\n" +55                "   private static final class MockObject {\n" +56                "       public int method(Map<String, String> s) {\n" +57                "           return 0;\n" +58                "       }\n" +59                "   }\n" +60                "}",61            "import org.mockito.Mockito;\n" +62                "import org.mockito.ArgumentMatchers;\n" +63                "import java.util.Map;\n" +64                "\n" +65                "public class UseAnyMapInsteadOfAnyMapOfTest {\n" +66                "   public void testMethod() {\n" +67                "       MockObject mock = Mockito.mock(MockObject.class);\n" +68                "       Mockito.doReturn(10).when(mock).method(ArgumentMatchers.anyMap());\n" +69                "   }\n" +70                "   private static final class MockObject {\n" +71                "       public int method(Map<String, String> s) {\n" +72                "           return 0;\n" +73                "       }\n" +74                "   }\n" +75                "}");76    }77    public void testArgumentMatchersAnyIterableOfReplacedWithAnyIterableForStaticImport() {78        doQuickFixTest("Replace with ArgumentMatchers.anyIterable()", "UseAnyIterableInsteadOfAnyIterableOfTest.java",79            "import org.mockito.Mockito;\n" +80                "\n" +81                "import static org.mockito.ArgumentMatchers.anyIterableOf;\n" +82                "\n" +83                "public class UseAnyIterableInsteadOfAnyIterableOfTest {\n" +84                "   public void testMethod() {\n" +85                "       MockObject mock = Mockito.mock(MockObject.class);\n" +86                "       Mockito.doReturn(10).when(mock).method(anyIterable<caret>Of(String.class));\n" +87                "   }\n" +88                "   private static final class MockObject {\n" +89                "       public int method(Iterable<String> s) {\n" +90                "           return 0;\n" +91                "       }\n" +92                "   }\n" +93                "}",94            "import org.mockito.Mockito;\n" +95                "\n" +96                "import static org.mockito.ArgumentMatchers.anyIterable;\n" +97                "import static org.mockito.ArgumentMatchers.anyIterableOf;\n" +98                "\n" +99                "public class UseAnyIterableInsteadOfAnyIterableOfTest {\n" +100                "   public void testMethod() {\n" +101                "       MockObject mock = Mockito.mock(MockObject.class);\n" +102                "       Mockito.doReturn(10).when(mock).method(anyIterable());\n" +103                "   }\n" +104                "   private static final class MockObject {\n" +105                "       public int method(Iterable<String> s) {\n" +106                "           return 0;\n" +107                "       }\n" +108                "   }\n" +109                "}");110    }111    public void testArgumentMatchersAnyMapOfReplacedWithAnyMapForStaticImport() {112        doQuickFixTest("Replace with ArgumentMatchers.anyMap()", "UseAnyMapInsteadOfAnyMapOfTest.java",113            "import org.mockito.Mockito;\n" +114                "import java.util.Map;\n" +115                "\n" +116                "import static org.mockito.ArgumentMatchers.anyMapOf;\n" +117                "\n" +118                "public class UseAnyMapInsteadOfAnyMapOfTest {\n" +119                "   public void testMethod() {\n" +120                "       MockObject mock = Mockito.mock(MockObject.class);\n" +121                "       Mockito.doReturn(10).when(mock).method(anyMap<caret>Of(String.class, String.class));\n" +122                "   }\n" +123                "   private static final class MockObject {\n" +124                "       public int method(Map<String, String> s) {\n" +125                "           return 0;\n" +126                "       }\n" +127                "   }\n" +128                "}",129            "import org.mockito.Mockito;\n" +130                "import java.util.Map;\n" +131                "\n" +132                "import static org.mockito.ArgumentMatchers.anyMap;\n" +133                "import static org.mockito.ArgumentMatchers.anyMapOf;\n" +134                "\n" +135                "public class UseAnyMapInsteadOfAnyMapOfTest {\n" +136                "   public void testMethod() {\n" +137                "       MockObject mock = Mockito.mock(MockObject.class);\n" +138                "       Mockito.doReturn(10).when(mock).method(anyMap());\n" +139                "   }\n" +140                "   private static final class MockObject {\n" +141                "       public int method(Map<String, String> s) {\n" +142                "           return 0;\n" +143                "       }\n" +144                "   }\n" +145                "}");146    }147    public void testMatchersAnyIterableOfReplacedWithAnyIterable() {148        doQuickFixTest("Replace with ArgumentMatchers.anyIterable()", "UseAnyIterableInsteadOfAnyIterableOfTest.java",149            "import org.mockito.Mockito;\n" +150                "import org.mockito.Matchers;\n" +151                "\n" +152                "public class UseAnyIterableInsteadOfAnyIterableOfTest {\n" +153                "   public void testMethod() {\n" +154                "       MockObject mock = Mockito.mock(MockObject.class);\n" +155                "       Mockito.doReturn(10).when(mock).method(Matchers.anyIterable<caret>Of(String.class));\n" +156                "   }\n" +157                "   private static final class MockObject {\n" +158                "       public int method(Iterable<String> s) {\n" +159                "           return 0;\n" +160                "       }\n" +161                "   }\n" +162                "}",163            "import org.mockito.ArgumentMatchers;\n" +164                "import org.mockito.Mockito;\n" +165                "import org.mockito.Matchers;\n" +166                "\n" +167                "public class UseAnyIterableInsteadOfAnyIterableOfTest {\n" +168                "   public void testMethod() {\n" +169                "       MockObject mock = Mockito.mock(MockObject.class);\n" +170                "       Mockito.doReturn(10).when(mock).method(ArgumentMatchers.anyIterable());\n" +171                "   }\n" +172                "   private static final class MockObject {\n" +173                "       public int method(Iterable<String> s) {\n" +174                "           return 0;\n" +175                "       }\n" +176                "   }\n" +177                "}");178    }179    public void testMatchersAnyMapOfReplacedWithAnyMap() {180        doQuickFixTest("Replace with ArgumentMatchers.anyMap()", "UseAnyMapInsteadOfAnyMapOfTest.java",181            "import org.mockito.Mockito;\n" +182                "import org.mockito.Matchers;\n" +183                "import java.util.Map;\n" +184                "\n" +...

Source:LibraryShellTest.java

...16import ru.shishmakov.repository.GenreRepository;17import java.util.Optional;18import static java.util.Collections.emptySet;19import static org.mockito.ArgumentMatchers.any;20import static org.mockito.ArgumentMatchers.anyIterable;21import static org.mockito.ArgumentMatchers.anySet;22import static org.mockito.ArgumentMatchers.anyString;23import static org.mockito.Mockito.doReturn;24import static org.mockito.Mockito.mock;25import static org.mockito.Mockito.verify;26@RunWith(SpringRunner.class)27@SpringBootTest28public class LibraryShellTest {29    @Rule30    public final SystemOutRule systemOutRule = new SystemOutRule().muteForSuccessfulTests();31    @Autowired32    private LibraryShell libraryShell;33    @SpyBean34    private LibraryService libraryService;35    @MockBean36    private Shell shell;37    @MockBean38    private BookRepository bookRepository;39    @MockBean40    private AuthorRepository authorRepository;41    @MockBean42    private GenreRepository genreRepository;43    @Test44    public void getAllBooksShouldRetrieveBookValues() {45        libraryShell.getAllBooks();46        verify(libraryService).getAllBooks();47        verify(bookRepository).findAll();48    }49    @Test50    public void getAllAuthorsShouldRetrieveAuthorValues() {51        libraryShell.getAllAuthors();52        verify(libraryService).getAllAuthors();53        verify(authorRepository).findAll();54    }55    @Test56    public void getAllGenresShouldRetrieveGenreValues() {57        libraryShell.getAllGenres();58        verify(libraryService).getAllGenres();59        verify(genreRepository).findAll();60    }61    @Test62    public void getAllCommentsShouldRetrieveCommentValues() {63        libraryShell.getAllComments();64        verify(libraryService).getAllComments();65        verify(bookRepository).findAllWithFetchComments();66    }67    @Test68    public void getBookAuthorsShouldRetrieveBookByIdAndTheirAuthors() {69        libraryShell.getBookAuthors(new ObjectId());70        verify(libraryService).getBookAuthors(any(ObjectId.class));71        verify(bookRepository).findByIdWithFetchAuthors(any(ObjectId.class));72    }73    @Test74    public void getBookGenresShouldRetrieveBookByIdAndTheirGenres() {75        libraryShell.getBookGenres(new ObjectId());76        verify(libraryService).getBookGenres(any(ObjectId.class));77        verify(bookRepository).findByIdWithFetchGenres(any(ObjectId.class));78    }79    @Test80    public void getBookGenresShouldRetrieveBookByIdAndTheirComments() {81        libraryShell.getBookComments(new ObjectId());82        verify(libraryService).getBookComments(any(ObjectId.class));83        verify(bookRepository).findByIdWithFetchComments(any(ObjectId.class));84    }85    @Test86    public void createBookShouldAddNewBook() {87        libraryShell.createBook("book title", "book isbn", emptySet(), emptySet());88        verify(libraryService).createBook(anyString(), anyString(), anySet(), anySet());89        verify(authorRepository).findAllById(anySet());90        verify(genreRepository).findAllById(anySet());91        verify(bookRepository).save(any(Book.class));92        verify(authorRepository).saveAll(anyIterable());93        verify(genreRepository).saveAll(anyIterable());94    }95    @Test96    public void createBookCommentShouldAddNewBookComment() {97        doReturn(Optional.of(mock(Book.class))).when(bookRepository).findById(any(ObjectId.class));98        libraryShell.createBookComment(new ObjectId(), "book comment");99        verify(libraryService).createBookComment(any(ObjectId.class), anyString());100        verify(bookRepository).findById(any(ObjectId.class));101        verify(bookRepository).save(any(Book.class));102    }103    @Test104    public void deleteBookShouldRemoveBook() {105        doReturn(Optional.of(mock(Book.class))).when(bookRepository).findByIdWithFetchGenresAuthors(any(ObjectId.class));106        libraryShell.deleteBook(new ObjectId());107        verify(libraryService).deleteBook(any(ObjectId.class));108        verify(bookRepository).findByIdWithFetchGenresAuthors(any(ObjectId.class));109        verify(bookRepository).delete(any(Book.class));110        verify(authorRepository).saveAll(anyIterable());111        verify(genreRepository).saveAll(anyIterable());112    }113    @Test114    public void deleteBookCommentShouldDeleteBookComment() {115        doReturn(Optional.of(mock(Book.class))).when(bookRepository).findById(any(ObjectId.class));116        libraryShell.deleteBookComment(new ObjectId(), new ObjectId());117        verify(libraryService).deleteComment(any(ObjectId.class), any(ObjectId.class));118        verify(bookRepository).findById(any(ObjectId.class));119        verify(bookRepository).save(any(Book.class));120    }121}...

Source:MetricComponentSpringTest.java

...30import org.mockito.Mockito;31import org.springframework.context.annotation.Bean;32import org.springframework.context.annotation.Configuration;33import org.springframework.test.context.ContextConfiguration;34import static org.mockito.ArgumentMatchers.anyIterable;35import static org.mockito.ArgumentMatchers.eq;36import static org.mockito.Mockito.times;37import static org.mockito.Mockito.when;38@CamelSpringTest39@ContextConfiguration(40                      classes = { MetricComponentSpringTest.TestConfig.class })41@MockEndpoints42public class MetricComponentSpringTest {43    @EndpointInject("mock:out")44    private MockEndpoint endpoint;45    @Produce("direct:in")46    private ProducerTemplate producer;47    @Configuration48    public static class TestConfig extends SingleRouteCamelConfiguration {49        @Bean50        @Override51        public RouteBuilder route() {52            return new RouteBuilder() {53                @Override54                public void configure() {55                    from("direct:in")56                            .to("micrometer:counter:A?increment=512")57                            .to("mock:out");58                }59            };60        }61        @Bean(name = MicrometerConstants.METRICS_REGISTRY_NAME)62        public MeterRegistry getMetricRegistry() {63            return Mockito.mock(MeterRegistry.class);64        }65    }66    @Test67    public void testMetricsRegistryFromCamelRegistry() throws Exception {68        MeterRegistry mockRegistry = endpoint.getCamelContext().getRegistry()69                .lookupByNameAndType(MicrometerConstants.METRICS_REGISTRY_NAME, MeterRegistry.class);70        Counter mockCounter = Mockito.mock(Counter.class);71        InOrder inOrder = Mockito.inOrder(mockRegistry, mockCounter);72        when(mockRegistry.counter(eq("A"), anyIterable())).thenReturn(mockCounter);73        endpoint.expectedMessageCount(1);74        producer.sendBody(new Object());75        endpoint.assertIsSatisfied();76        inOrder.verify(mockRegistry, times(1)).counter(eq("A"), anyIterable());77        inOrder.verify(mockCounter, times(1)).increment(512D);78        inOrder.verifyNoMoreInteractions();79    }80}...

Source:BaseCommitterTest.java

...14import java.math.BigDecimal;15import java.util.ArrayList;16import java.util.List;17import java.util.Optional;18import static org.mockito.ArgumentMatchers.anyIterable;19import static org.mockito.ArgumentMatchers.nullable;20public class BaseCommitterTest {21    @Rule22    public ExpectedException expectedException = ExpectedException.none();23    @Mock24    private JournalEntryRepository journalEntryRepository;25    @Mock26    private AccountRepository accountRepository;27    @InjectMocks28    private BaseCommitter baseCommitter;29    @Before30    public void before() {31        MockitoAnnotations.initMocks(this);32    }33    @Test34    public void testCommit_unBalanced() {35        expectedException.expect(InvalidBusinessRuleException.class);36        expectedException.expectMessage("Unbalanced journal entries");37        List<JournalEntry> journalEntries = new ArrayList<>();38        JournalEntry journalEntry = new JournalEntry();39        journalEntry.setAmount(BigDecimal.valueOf(10));40        journalEntries.add(journalEntry);41        journalEntries.add(journalEntry);42        Mockito.when(journalEntryRepository.saveAll(anyIterable())).thenReturn(journalEntries);43        Iterable<JournalEntry> commit = baseCommitter.commit(journalEntries, 0 , 0L);44    }45    @Test46    public void testCommit_balanced() {47        Account account = new Account();48        account.setBalance(BigDecimal.ZERO);49        account.setId("12345");50        List<JournalEntry> journalEntries = new ArrayList<>();51        JournalEntry journalEntry = new JournalEntry();52        journalEntry.setAmount(BigDecimal.valueOf(10));53        journalEntry.setAccountId("12345");54        journalEntries.add(journalEntry);55        JournalEntry balancingJournalEntry = new JournalEntry();56        balancingJournalEntry.setAmount(BigDecimal.valueOf(-10));57        balancingJournalEntry.setAccountId("23456");58        journalEntries.add(balancingJournalEntry);59        Mockito.when(journalEntryRepository.saveAll(anyIterable())).thenReturn(journalEntries);60        Mockito.when(accountRepository.findById(nullable(String.class))).thenReturn(Optional.of(account));61        Mockito.when(accountRepository.save(nullable(Account.class))).thenReturn(account);62        Iterable<JournalEntry> commit = baseCommitter.commit(journalEntries, 0, 0L);63        Assert.assertNotNull(commit);64        Assert.assertEquals(2, Iterables.size(commit));65    }66    @Test67    public void testCommit_null() {68        Iterable<JournalEntry> commit = baseCommitter.commit(null, 0, 0L);69        Assert.assertNotNull(commit);70        Assert.assertEquals(0, Iterables.size(commit));71    }72}...

Source:DisbursementServiceTest.java

...13import org.mockito.Mock;14import org.mockito.junit.MockitoJUnitRunner;15import java.io.File;16import java.util.List;17import static org.mockito.ArgumentMatchers.anyIterable;18import static org.mockito.ArgumentMatchers.anySet;19import static org.mockito.ArgumentMatchers.anyString;20import static org.mockito.Mockito.times;21import static org.mockito.Mockito.verify;22import static org.mockito.Mockito.when;23@RunWith(MockitoJUnitRunner.class)24public class DisbursementServiceTest {25    private static final ObjectMapper MAPPER = new ObjectMapper();26    @Mock27    private PaymentRepository paymentRepository;28    @Mock29    private DisbursementRepository disbursementRepository;30    @Mock31    private UserRepository userRepository;32    @InjectMocks33    private DisbursementServiceImpl disbursementService;34    private List<Payment> newStatusPaymentList;35    @Before36    public void setUp() throws Exception {37        newStatusPaymentList = MAPPER.readValue(new File("src/test/resources/newStatusPaymentList.json"), new TypeReference<>() {38        });39        int userId = 1;40        int counter = 1;41        for (Payment payment : newStatusPaymentList) {42            for (int j = 0; j < 3; j++) {43                payment.setUser(User.builder().id(userId).build());44            }45            if (counter == 3) {46                userId++;47                counter = 0;48            }49            counter++;50        }51    }52    @Test53    public void processAllDisbursements_Happy_Path_Test() {54        when(paymentRepository.findByStatusEquals(anyString())).thenReturn(newStatusPaymentList);55        disbursementService.processAllDisbursements();56        verify(paymentRepository, times(1)).findByStatusEquals(anyString());57        verify(paymentRepository, times(1)).saveAll(anyIterable());58        verify(disbursementRepository, times(1)).saveAll(anyIterable());59        verify(userRepository, times(1)).findByIdIn(anySet());60    }61}...

Source:CompanyServiceTest.java

...12import java.util.List;13import java.util.Optional;14import static org.assertj.core.api.Assertions.assertThat;15import static org.mockito.ArgumentMatchers.any;16import static org.mockito.ArgumentMatchers.anyIterable;17import static org.mockito.Mockito.atLeast;18import static org.mockito.Mockito.times;19import static org.mockito.Mockito.verify;20import static org.mockito.Mockito.when;21@ExtendWith(MockitoExtension.class)22class CompanyServiceTest {23    @Mock24    private CompanyRepository companyRepository;25    @InjectMocks26    private CompanyService companyService;27    private List<CompanyDBO> companies;28    @BeforeEach29    void setup() {30        companies = List.of(CompanyDBO.builder()31                .cik(1000045)32                .symbol("aap").build());33    }34    @Test35    void whenSaveCompaniesCIKRequest_thenSaveCompaniesInfoToDB() {36        when(companyRepository.saveAll(anyIterable())).thenReturn(companies);37        List<CompanyDBO> result = (List<CompanyDBO>) companyService.saveAllSymbolsWithCIK();38        assertThat(result.get(0)).isEqualTo(companies.get(0));39        verify(companyRepository, times(1)).saveAll(anyIterable());40    }41    @Test42    void whenPopulateCompaniesWithNameRequest_thenSaveNamesForCompaniesInCaseExists() {43        when(companyRepository.findBySymbol(any())).thenReturn(Optional.ofNullable(companies.get(0)));44        when(companyRepository.saveAll(anyIterable())).thenReturn(companies);45        assertThat(companies.size()).isEqualTo(companyService.populateCompanyWithNames().size());46        verify(companyRepository, atLeast(1)).findBySymbol(any());47    }48}...

anyIterable

Using AI Code Generation

1package com.automationrhapsody.mockito;2import java.util.Arrays;3import java.util.List;4import org.junit.Test;5import org.junit.runner.RunWith;6import org.mockito.ArgumentMatchers;7import org.mockito.InjectMocks;8import org.mockito.Mock;9import org.mockito.junit.MockitoJUnitRunner;10import static org.mockito.Mockito.times;11import static org.mockito.Mockito.verify;12@RunWith(MockitoJUnitRunner.class)13public class MockitoArgumentMatchersTest {14    private List<String> mockedList;15    private MockitoArgumentMatchers mockitoArgumentMatchers;16    public void testAnyIterable() {17        mockitoArgumentMatchers.anyIterable();18        verify(mockedList, times(1))19            .addAll(ArgumentMatchers.anyIterable());20    }21    public void testIterableContaining() {22        mockitoArgumentMatchers.iterableContaining();23        verify(mockedList, times(1))24            .addAll(ArgumentMatchers.iterableContaining("one", "two"));25    }26    public void testIterableContainingInAnyOrder() {27        mockitoArgumentMatchers.iterableContainingInAnyOrder();28        verify(mockedList, times(1))29            .addAll(ArgumentMatchers.iterableContainingInAnyOrder("two", "one"));30    }31    public void testIterableWithSize() {32        mockitoArgumentMatchers.iterableWithSize();33        verify(mockedList, times(1))34            .addAll(ArgumentMatchers.iterableWithSize(2));35    }36    public void testIterableWithSizeLessThan() {37        mockitoArgumentMatchers.iterableWithSizeLessThan();38        verify(mockedList, times(1))39            .addAll(ArgumentMatchers.iterableWithSize(ArgumentMatchers.lessThan(3)));40    }41    public void testIterableWithSizeGreaterThan() {42        mockitoArgumentMatchers.iterableWithSizeGreaterThan();43        verify(mockedList, times(1))44            .addAll(ArgumentMatchers.iterableWithSize(ArgumentMatchers.greaterThan(1)));45    }46}47package com.automationrhapsody.mockito;48import java.util.Arrays;49import java.util.List;50public class MockitoArgumentMatchers {51    private List<String> mockedList;52    public MockitoArgumentMatchers(List<String> mockedList) {53        this.mockedList = mockedList;54    }55    public void anyIterable() {

anyIterable

Using AI Code Generation

1import static org.mockito.ArgumentMatchers.anyIterable;2import static org.mockito.Mockito.mock;3import static org.mockito.Mockito.verify;4import java.util.ArrayList;5import java.util.List;6public class Test {7    public static void main(String[] args) {8        List<String> list = new ArrayList<>();9        list.add("a");10        list.add("b");11        list.add("c");12        List<String> mockedList = mock(List.class);13        mockedList.addAll(list);14        verify(mockedList).addAll(anyIterable());15    }16}17-> at Test.main(Test.java:13)18import static org.mockito.ArgumentMatchers.any;19import static org.mockito.Mockito.mock;20import static org.mockito.Mockito.verify;21import java.util.ArrayList;22import java.util.List;23public class Test {24    public static void main(String[] args) {25        List<String> list = new ArrayList<>();26        list.add("a");27        list.add("b");28        list.add("c");29        List<String> mockedList = mock(List.class);30        mockedList.addAll(list);31        verify(mockedList).addAll(any());32    }33}34-> at Test.main(Test.java:13)

anyIterable

Using AI Code Generation

1import static org.mockito.ArgumentMatchers.anyIterable;2import static org.mockito.Mockito.mock;3import static org.mockito.Mockito.when;4import java.util.ArrayList;5import java.util.List;6public class MockitoAnyIterableMethod {7public static void main(String[] args) {

anyIterable

Using AI Code Generation

1import org.mockito.ArgumentMatchers;2import org.mockito.Mockito;3import java.util.Arrays;4import java.util.List;5public class AnyIterable {6    public static void main(String[] args) {7        List<String> list = Arrays.asList("java", "python", "c++");8        List<String> mockList = Mockito.mock(List.class);9        Mockito.when(mockList.containsAll(ArgumentMatchers.anyIterable())).thenReturn(true);10        System.out.println(mockList.containsAll(list));11    }12}13Recommended Posts: Mockito Argument Matchers - anyInt(), anyString(), anyList()14Mockito Argument Matchers - any(), anyObject(), anyClass()15Mockito Argument Matchers - anyMap()16Mockito Argument Matchers - anyCollection()17Mockito Argument Matchers - anySet()18Mockito Argument Matchers - anyBoolean(), anyByte(), anyChar(), anyDouble(), anyFloat(), anyLong(), anyShort()19Mockito Argument Matchers - anyVararg()20Mockito Argument Matchers - any()21Mockito Argument Matchers - anyObject(), anyClass()22Mockito Argument Matchers - anyList(), anyCollection(), anySet()23Mockito Argument Matchers - anyMap()24Mockito Argument Matchers - anyBoolean(), anyByte(), anyChar(), anyDouble(), anyFloat(), anyLong(), anyShort()25Mockito Argument Matchers - anyVararg()26Mockito Argument Matchers - any()27Mockito Argument Matchers - anyObject(), anyClass()28Mockito Argument Matchers - anyList(), anyCollection(), anySet()29Mockito Argument Matchers - anyMap()30Mockito Argument Matchers - anyBoolean(), anyByte(), anyChar(), anyDouble(), anyFloat(), anyLong(), anyShort()31Mockito Argument Matchers - anyVararg()32Mockito Argument Matchers - any()33Mockito Argument Matchers - anyObject(), anyClass()34Mockito Argument Matchers - anyList(), anyCollection(), anySet()35Mockito Argument Matchers - anyMap()36Mockito Argument Matchers - anyBoolean(), anyByte(), anyChar(), anyDouble(), anyFloat(), anyLong(), anyShort()37Mockito Argument Matchers - anyVararg()38Mockito Argument Matchers - any()39Mockito Argument Matchers - anyObject(), anyClass()40Mockito Argument Matchers - anyList(), any

anyIterable

Using AI Code Generation

1import static org.mockito.ArgumentMatchers.anyIterable;2import static org.mockito.Mockito.mock;3import static org.mockito.Mockito.verify;4import java.util.Arrays;5import java.util.List;6import org.junit.Test;7public class MockitoAnyIterableTest {8    public void testAnyIterable() {9        List<String> mockList = mock(List.class);10        mockList.addAll(anyIterable());11        verify(mockList).addAll(anyIterable());12    }13}14Mockito Argument Matchers any()15Mockito Argument Matchers anyString()16Mockito Argument Matchers anyList()17Mockito Argument Matchers anyMap()18Mockito Argument Matchers anySet()19Mockito Argument Matchers anyCollection()20Mockito Argument Matchers anyInt()21Mockito Argument Matchers anyDouble()22Mockito Argument Matchers anyFloat()23Mockito Argument Matchers anyLong()24Mockito Argument Matchers anyByte()25Mockito Argument Matchers anyChar()26Mockito Argument Matchers anyShort()27Mockito Argument Matchers anyBoolean()28Mockito Argument Matchers anyVararg()

anyIterable

Using AI Code Generation

1import java.util.*;2import org.junit.*;3import org.mockito.*;4import static org.mockito.ArgumentMatchers.*;5import static org.mockito.Mockito.*;6public class anyIterableTest {7    public void test() {8        List<String> list = mock(List.class);9        list.addAll(anyIterable());10        verify(list).addAll(anyIterable());11    }12}13list.addAll(14    anyIterable()15);16-> at anyIterableTest.test(anyIterableTest.java:13)17list.addAll(18);19-> at anyIterableTest.test(anyIterableTest.java:13)20import java.util.*;21import org.junit.*;22import org.mockito.*;23import static org.mockito.ArgumentMatchers.*;24import static org.mockito.Mockito.*;25public class anyIterableTest {26    public void test() {27        List<String> list = mock(List.class);28        list.addAll(anyIterable());29        verify(list).addAll(Arrays.asList(1, 2, 3));30    }31}32list.addAll(33    anyIterable()34);35-> at anyIterableTest.test(anyIterableTest.java:13)36list.addAll(37);38-> at anyIterableTest.test(anyIterableTest.java:13)39list.addAll(40    anyIterable()41);42-> at anyIterableTest.test(anyIterableTest.java:13)43list.addAll(44);45-> at anyIterableTest.test(anyIterableTest.java:13)

anyIterable

Using AI Code Generation

1import static org.mockito.ArgumentMatchers.anyIterable;2import static org.mockito.Mockito.when;3import java.util.Arrays;4import java.util.List;5import org.junit.Test;6import org.junit.runner.RunWith;7import org.mockito.InjectMocks;8import org.mockito.Mock;9import org.mockito.junit.MockitoJUnitRunner;10@RunWith(MockitoJUnitRunner.class)11public class MockitoArgumentMatchersAnyIterableTest {12    private List<String> mockList;13    private MockitoArgumentMatchersAnyIterableTest anyIterableTest;14    public void testAnyIterable() {15        when(mockList.contains(anyIterable())).thenReturn(true);16        boolean result = anyIterableTest.anyIterable(Arrays.asList("one", "two"));17        System.out.println(result);18    }19    public boolean anyIterable(List<String> list) {20        return mockList.contains(list);21    }22}

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.