Best Mockito code snippet using org.mockito.Mockito.when
Source:OfficalTest_Part_2.java
...17import static org.mockito.Mockito.mock;18import static org.mockito.Mockito.reset;19import static org.mockito.Mockito.spy;20import static org.mockito.Mockito.verify;21import static org.mockito.Mockito.when;22import static org.mockito.Mockito.withSettings;23public class OfficalTest_Part_2 {24 /*25 * Stubbing with callbacks26 * å¯ä»¥ä½¿ç¨Answeræ¥è¿è¡ä¿®æ¹ç¸åºç,æ¯å¦å¨ä¸é¢çä¾åä¸,æ们修æ¹ç¸åºçè¿åå¼,27 * è°ç¨ç¸åºçaddæ¹æ³æ¶ï¼å°±ä¼è¿åæ们èªå®ä¹çç»æ28 * æ好 thenReturn() or thenThrow()çæ¹æ³ï¼æ¥è¿è¡ç¸åºçæµè¯ã29 */30 /**31 * {@see Mockito32 * https://static.javadoc.io/org.mockito/mockito-core/2.7.22/org/mockito/Mockito.html#1133 * }34 */35 @Test36 public void step_11() {37 final LinkedList mockedLinkList = mock(LinkedList.class);38 when(mockedLinkList.remove(anyInt())).thenAnswer(new Answer<String>() {39 @Override40 public String answer(InvocationOnMock invocation) throws Throwable {41 Object[] arguments = invocation.getArguments();42 Object mock = invocation.getMock();43 return "called with arguments: " + Arrays.toString(arguments);44 }45 });46 System.out.println(mockedLinkList.remove(999));47 }48 /*49 * doReturn()|doThrow()| doAnswer()|doNothing()|doCallRealMethod() family of methods50 *51 */52 /**53 * {@see Mockito54 * https://static.javadoc.io/org.mockito/mockito-core/2.7.22/org/mockito/Mockito.html#1255 * }56 */57 @Test58 public void step_12() {59 final LinkedList mockedLinkList = mock(LinkedList.class);60 when(mockedLinkList.get(0)).thenReturn(false);61 doAnswer(new Answer<Boolean>() {62 @Override63 public Boolean answer(InvocationOnMock invocation) throws Throwable {64 Object[] arguments = invocation.getArguments();65 Object mock = invocation.getMock();66 return mock == mockedLinkList;67 }68 }).when(mockedLinkList).get(anyInt());69 System.out.println(mockedLinkList.get(0));70 }71 /*72 * å½ä½¿ç¨spyçæ¶åï¼ä¼çæ£è°ç¨ç¸åºçæ¹æ³(é¤é使ç¨å
¶ä»æ段修æ¹ç¸åºçè¿åå¼ï¼ æ¯å¦doXxx())73 * 注æï¼åºå½å°½å¯è½ä»ç»ä½¿ç¨ï¼å¹¶ä¸å°½éå°å°ä½¿ç¨spyï¼æ¯å¦å¨å¤çéçç代ç çæ¶å74 * å¨ä¸ä¸ªçæ£ç对象ä¸ä½¿ç¨Spyï¼å¯ä»¥ç解为âpartial mockingâï¼ä½æ¯å¨1.8ä¹åï¼Mockito并ä¸æ¯çæ£75 * partial mockï¼åå å¨äºï¼æ们认为partial mockæ¯ä»£ç çä¸é¨åãå¨æäºæ¹é¢ï¼æ们åç°äºä½¿ç¨é¨åmocks76 * çåçä¹å¤(ä¾å¦ï¼ç¬¬ä¸æ¹æ¥å£ï¼éç代ç ç临æ¶éæï¼å
¨é¨çæç« ï¼åè以ä¸å
容77 * {@see partial-mocking78 * https://monkeyisland.pl/2009/01/13/subclass-and-override-vs-partial-mocking-vs-refactoring/})79 * æä¸ç¹éè¦ç¹å«æ³¨æçæ¯ï¼å¨ä½¿ç¨ when(Object)æ¹æ³è°ç¨spy对象çæ¶åï¼å»ºè®®ä½¿ç¨ä»¥ä¸çæ¹æ³æ¿ä»£doReturn|Answer|Throw()80 * ä¾å¦81 * //Impossible: real method is called so spy.get(0) throws IndexOutOfBoundsException (the list is yet empty)82 * when(spy.get(0)).thenReturn("ArrayList");83 * ç±äºspy并没æåå§åï¼å æ¤å°ä¼æåºç¸åºçå¼å¸¸84 * //You have to use doReturn() for stubbing85 * doReturn("ArrayList").when(spy).get(0);86 *87 */88 /**89 * {@see Mockito90 * https://static.javadoc.io/org.mockito/mockito-core/2.7.22/org/mockito/Mockito.html#1391 * }92 */93 @Test94 public void step_13() {95 List list = new LinkedList();96 List<String> spy = spy(list);97 //Impossible: real method is called so spy.get(0) throws IndexOutOfBoundsException (the list is yet empty)98 when(spy.get(0)).thenReturn("ArrayList");99 //You have to use doReturn() for stubbing100 doReturn("ArrayList").when(spy).get(0);101 //optionally, you can stub out some methods:102 when(spy.size()).thenReturn(100);103 //using the spy calls *real* methods104 spy.add("one");105 spy.add("two");106 //prints "one" - the first element of a list107 System.out.println(spy.get(0));108 //size() method was stubbed - 100 is printed109 System.out.println(spy.size());110 //optionally, you can verify111 verify(spy).add("one");112 verify(spy).add("two");113 }114 /*115 * Changing default return values of unstubbed invocations (Since 1.7)116 * æ们å¯ä»¥ç»ç¸åºçè¿åå¼ï¼æå®ä¸ä¸ªé»è®¤çè§åã117 * è¿æ¯æ³å½é«çº§çåè½ï¼å¹¶ä¸å¯¹äºæ§ç³»ç»ï¼æ¥è¯´æ¯é常æ帮å©ç118 * é»è®¤æ
åµä¸ï¼ä½ æ ¹æ¬ä¸éè¦è°ç¨å®119 * æ´å¤çå
容ï¼å¯ä»¥åèé»è®¤çå®ç°ã120 * {@see RETURNS_SMART_NULLS121 * https://static.javadoc.io/org.mockito/mockito-core/2.7.22/org/mockito/Mockito.html#RETURNS_SMART_NULLS122 * }123 */124 /**125 * {@see Mockito126 * https://static.javadoc.io/org.mockito/mockito-core/2.7.22/org/mockito/Mockito.html#14127 * }128 */129 @Test130 public void step_14() {131 List mock = mock(ArrayList.class, Mockito.RETURNS_SMART_NULLS);132 List mockTwo = mock(List.class, new Answer() {133 @Override134 public Object answer(InvocationOnMock invocation) throws Throwable {135 return false;136 }137 });138 System.out.println( mockTwo.add("haha"));139 }140 /*141 * Capturing arguments for further assertions (Since 1.8.0)142 * è¿ä¸ªåè½ï¼å¯ä»¥å¸®å©ä½ æ£éªç¸åºçåæ°çæ£ç¡®æ§143 * è¦åï¼å¿
须记ä½çæ¯ä½¿ç¨ArgumentCaptor åè½åºè¯¥æ¯æ£éªèä¸æ¯ç¨æ¥æ¿ä»£é»è®¤å¼ã144 * å¦æ使ç¨ArgumentCaptor å°åå°ä»£ç çå¯è¯»æ§ï¼å 为æè·æ¯å¨assertä¹å¤å建ï¼145 * ï¼ä¾å¦å¨aka verify æè
âthenâï¼146 * å®åæ¶åå°äºå®ä½ç¼ºé·ï¼å 为å¦æstubbedæ¹æ³æ²¡æ被è°ç¨ï¼é£ä¹å°ä¸ä¼æåæ°è¢«æè·147 * ArgumentCaptor æ´éç¨äºä»¥ä¸æ
å½¢ï¼148 * 1ãèªå®ä¹argument matcherä¸å¤ªå¯è½è¢«éç¨149 * 2ãä½ åªéè¦éªè¯å½æ°åæ°çåªå°±å¯ä»¥å®ææ ¡éª150 * {@see ArgumentMatcher151 * https://static.javadoc.io/org.mockito/mockito-core/2.7.22/org/mockito/ArgumentMatcher.html152 * }153 */154 /**155 * {@see Mockito156 * https://static.javadoc.io/org.mockito/mockito-core/2.7.22/org/mockito/Mockito.html#15157 * }158 */159 @Test160 public void step_15() {161 ArrayList mock = mock(ArrayList.class);162 mock.add("John");163 ArgumentCaptor<List> argument = ArgumentCaptor.forClass(ArrayList.class);164 verify(mock).add(argument.capture());165 Assert.assertEquals("John", argument.getValue());166 }167 /*168 * Real partial mocks (Since 1.8.0)169 * å¨é¨åæ
åµä¸partial mocksæ¯é常æç¨ç170 * spy()ä¸spy(Object)æ¹æ³å¹¶æ²¡æ产çæ£å¸¸çpartial mocksï¼å
·ä½ä¿¡æ¯è¯·é
读171 * {@see172 * https://static.javadoc.io/org.mockito/mockito-core/2.7.22/org/mockito/Mockito.html#13173 * }174 * éè¦æ³¨æçæ¯ï¼175 * æ好å¨æµè¯ç¬¬ä¸æ¹æ¥å£ï¼ä»¥åéç代ç çæ¶å使ç¨spy176 * ä¸è¦å¨æ°è®¾è®¡ç代ç ãå¯ä»¥æµè¯ç代ç ï¼ä»¥åè¯å¥½è®¾è®¡ç代ç ä¸ä½¿ç¨spy177 *178 */179 /**180 * {@see Mockito181 * https://static.javadoc.io/org.mockito/mockito-core/2.7.22/org/mockito/Mockito.html#16182 * }183 */184 @Test185 public void step_16() {186 //you can create partial mock with spy() method:187 List list = spy(new LinkedList());188 //you can enable partial mock capabilities selectively on mocks:189 ArrayList mock = mock(ArrayList.class);190 //Be sure the real implementation is 'safe'.191 //If real implementation throws exceptions or depends on specific state of the object then you're in trouble.192 when(mock.add("haha")).thenCallRealMethod();193 }194 /*195 * Resetting mocks (Since 1.8.0)196 * "Please keep us small & focused on single behavior".197 * æ¯æ们åºå½éµå¾ªçè§åï¼å æ¤æ们é常并ä¸éè¦ä½¿ç¨resetï¼é¤éå¨ä¸ä¸ªåé¿çãè¶
éçæµè¯ä¸ä½¿ç¨ã198 * å®æ¹æ·»å restæ¹æ³çå¯ä¸åå å°±æ¯å¯ä»¥ä½¿ç¨å®¹å¨æ³¨å
¥ç模æå¨ã199 * {@see FAQ200 * https://github.com/mockito/mockito/wiki/FAQ201 * }202 * åè¯ä½ èªå·±ï¼203 * å¦ææ¯ä½¿ç¨resetæ¹æ³ï¼é£ä¹ä½ å¯è½åå¾å¤ªå¤äº204 */205 /**206 * {@see Mockito207 * https://static.javadoc.io/org.mockito/mockito-core/2.7.22/org/mockito/Mockito.html#17208 * }209 */210 @Test211 public void step_17() {212 List mock = mock(List.class);213 when(mock.size()).thenReturn(10);214 mock.add(1);215 reset(mock);216 //at this point the mock forgot any interactions & stubbing217 }218 /*219 * Troubleshooting & validating framework usage220 * {@see FAQ221 * https://github.com/mockito/mockito/wiki/FAQ222 * }223 * æè
å¯ä»¥åè224 * http://groups.google.com/group/mockito225 */226 /**227 * {@see Mockito228 * https://static.javadoc.io/org.mockito/mockito-core/2.7.22/org/mockito/Mockito.html#18229 * }230 */231 @Test232 public void step_18() {233 }234 /*235 * Aliases for behavior driven development (Since 1.8.0)236 * Behavior Driven Development (åºäºè¡ä¸ºé©±å¨çå¼å)å¨æ§è¡æµè¯æ¶ï¼å¯ä»¥ä½¿ç¨237 * //given //when //thençæ¹æ³ä½ä¸ºä½ æµè¯æ¹æ³çä¸é¨åã238 * {@see Behavior Driven Development (BDD)239 * http://en.wikipedia.org/wiki/Behavior_Driven_Development240 * }241 * é®é¢æ¯å½åstubbing apiä¸whenåçè§èä½ç¨ï¼æ²¡æå¾å¥½å°éæ//given//when//then注éã242 * è¿æ¯å 为å®å±äºgivenæµè¯å
容çstubbingï¼å¹¶ä¸å±äºwhenæµè¯å
容çsutbbing243 * å æ¤ï¼å æ¤ï¼BDDMockitoç±»å¼å
¥ä¸ä¸ªå«åï¼244 * 以便使ç¨BDDMockito.givenï¼Objectï¼æ¹æ³è¿è¡stubæ¹æ³è°ç¨ã245 * ç°å¨å®ççå¾å¥½å°ä¸BDDæ ·å¼æµè¯çç»å®ç»ä»¶éæï¼246 */247 /**248 * {@see Mockito249 * https://static.javadoc.io/org.mockito/mockito-core/2.7.22/org/mockito/Mockito.html#19250 * }251 */252 @Test253 public void step_19() {254 ArrayList mock = mock(ArrayList.class);255 BDDMockito.given(mock.add("Test")).willReturn(false);256 System.out.println("mock.add(\"Test\") = " + mock.add("Test"));...
Source:OfficalTest_Part_4.java
...127//128// // more complex Java 8 example - where you can specify complex verification behaviour functionally129// verify(target, times(1)).receiveComplexObject(argThat(obj -> obj.getSubObject().get(0).equals("expected")));130//131// // this can also be used when defining the behaviour of a mock under different inputs132// // in this case if the input list was fewer than 3 items the mock returns null133// when(mock.someMethod(argThat(list -> list.size()<3))).willReturn(null);134 }135 /*136 *137 */138 /**139 * {@see Mockito140 * https://static.javadoc.io/org.mockito/mockito-core/2.7.22/org/mockito/Mockito.html#37141 * }142 */143 @Test144 public void step_37() {145// // answer by returning 12 every time146// doAnswer(invocation -> 12).when(mock).doSomething();147//148// // answer by using one of the parameters - converting into the right149// // type as your go - in this case, returning the length of the second string parameter150// // as the answer. This gets long-winded quickly, with casting of parameters.151// doAnswer(invocation -> ((String)invocation.getArgument(1)).length())152// .when(mock).doSomething(anyString(), anyString(), anyString());153//154// // Example interface to be mocked has a function like:155// void execute(String operand, Callback callback);156//157// // the example callback has a function and the class under test158// // will depend on the callback being invoked159// void receive(String item);160//161// // Java 8 - style 1162// doAnswer(AdditionalAnswers.answerVoid((operand, callback) -> callback.receive("dummy"))163// .when(mock).execute(anyString(), any(Callback.class));164//165// // Java 8 - style 2 - assuming static import of AdditionalAnswers166// doAnswer(answerVoid((String operand, Callback callback) -> callback.receive("dummy"))167// .when(mock).execute(anyString(), any(Callback.class));168//169// // Java 8 - style 3 - where mocking function to is a static member of test class170// private static void dummyCallbackImpl(String operation, Callback callback) {171// callback.receive("dummy");172// }173//174// doAnswer(answerVoid(TestClass::dummyCallbackImpl)175// .when(mock).execute(anyString(), any(Callback.class));176//177// // Java 7178// doAnswer(answerVoid(new VoidAnswer2() {179// public void answer(String operation, Callback callback) {180// callback.receive("dummy");181// }})).when(mock).execute(anyString(), any(Callback.class));182//183// // returning a value is possible with the answer() function184// // and the non-void version of the functional interfaces185// // so if the mock interface had a method like186// boolean isSameString(String input1, String input2);187//188// // this could be mocked189// // Java 8190// doAnswer(AdditionalAnswers.answer((input1, input2) -> input1.equals(input2))))191// .when(mock).execute(anyString(), anyString());192//193// // Java 7194// doAnswer(answer(new Answer2() {195// public String answer(String input1, String input2) {196// return input1 + input2;197// }})).when(mock).execute(anyString(), anyString());198 }199 /*200 * Meta data and generic type retention (Since 2.1.0)201 * Mockitoç°å¨ä¿çmockedæ¹æ³ä»¥åç±»åä¸ç注éä¿¡æ¯ï¼å°±åä½ä¸ºæ³åå±æ§æ°æ®ä¸æ ·ã202 * 以åï¼æ¨¡æç±»å没æä¿ç对类åç注éï¼é¤éå®ä»¬è¢«æ¾å¼å°ç»§æ¿ï¼å¹¶ä¸ä»æªå¨æ¹æ³ä¸ä¿ç注éã203 * å æ¤ï¼ç°å¨çæ¡ä»¶å¦ä¸ï¼204 * å½æ¶ç¨Java8æ¶ï¼Mockitoç°å¨ä¹ä¼ä¿çç±»å注解ï¼è¿æ¯é»è®¤è¡ä¸ºï¼å¦æ使ç¨å¦ä¸ä¸ªMockMakerå¯è½ä¸ä¼ä¿çã205 */206 /**207 * {@see Mockito208 * https://static.javadoc.io/org.mockito/mockito-core/2.7.22/org/mockito/Mockito.html#38209 * }210 */211 @Test...
Source:TestQuorumJournalManagerUnit.java
...73 futureReturns(GetJournalStateResponseProto.newBuilder()74 .setLastPromisedEpoch(0)75 .setHttpPort(-1)76 .build())77 .when(logger).getJournalState();78 79 futureReturns(80 NewEpochResponseProto.newBuilder().build()81 ).when(logger).newEpoch(Mockito.anyLong());82 83 futureReturns(null).when(logger).format(Mockito.<NamespaceInfo>any());84 }85 86 qjm.recoverUnfinalizedSegments();87 }88 89 private AsyncLogger mockLogger() {90 return Mockito.mock(AsyncLogger.class);91 }92 93 static <V> Stubber futureReturns(V value) {94 ListenableFuture<V> ret = Futures.immediateFuture(value);95 return Mockito.doReturn(ret);96 }97 98 static Stubber futureThrows(Throwable t) {99 ListenableFuture<?> ret = Futures.immediateFailedFuture(t);100 return Mockito.doReturn(ret);101 }102 @Test103 public void testAllLoggersStartOk() throws Exception {104 futureReturns(null).when(spyLoggers.get(0)).startLogSegment(Mockito.anyLong(),105 Mockito.eq(NameNodeLayoutVersion.CURRENT_LAYOUT_VERSION));106 futureReturns(null).when(spyLoggers.get(1)).startLogSegment(Mockito.anyLong(),107 Mockito.eq(NameNodeLayoutVersion.CURRENT_LAYOUT_VERSION));108 futureReturns(null).when(spyLoggers.get(2)).startLogSegment(Mockito.anyLong(),109 Mockito.eq(NameNodeLayoutVersion.CURRENT_LAYOUT_VERSION));110 qjm.startLogSegment(1, NameNodeLayoutVersion.CURRENT_LAYOUT_VERSION);111 }112 @Test113 public void testQuorumOfLoggersStartOk() throws Exception {114 futureReturns(null).when(spyLoggers.get(0)).startLogSegment(Mockito.anyLong(),115 Mockito.eq(NameNodeLayoutVersion.CURRENT_LAYOUT_VERSION));116 futureReturns(null).when(spyLoggers.get(1)).startLogSegment(Mockito.anyLong(),117 Mockito.eq(NameNodeLayoutVersion.CURRENT_LAYOUT_VERSION));118 futureThrows(new IOException("logger failed"))119 .when(spyLoggers.get(2)).startLogSegment(Mockito.anyLong(),120 Mockito.eq(NameNodeLayoutVersion.CURRENT_LAYOUT_VERSION));121 qjm.startLogSegment(1, NameNodeLayoutVersion.CURRENT_LAYOUT_VERSION);122 }123 @Test124 public void testQuorumOfLoggersFail() throws Exception {125 futureReturns(null).when(spyLoggers.get(0)).startLogSegment(Mockito.anyLong(),126 Mockito.eq(NameNodeLayoutVersion.CURRENT_LAYOUT_VERSION));127 futureThrows(new IOException("logger failed"))128 .when(spyLoggers.get(1)).startLogSegment(Mockito.anyLong(),129 Mockito.eq(NameNodeLayoutVersion.CURRENT_LAYOUT_VERSION));130 futureThrows(new IOException("logger failed"))131 .when(spyLoggers.get(2)).startLogSegment(Mockito.anyLong(),132 Mockito.eq(NameNodeLayoutVersion.CURRENT_LAYOUT_VERSION));133 try {134 qjm.startLogSegment(1, NameNodeLayoutVersion.CURRENT_LAYOUT_VERSION);135 fail("Did not throw when quorum failed");136 } catch (QuorumException qe) {137 GenericTestUtils.assertExceptionContains("logger failed", qe);138 }139 }140 141 @Test142 public void testQuorumOutputStreamReport() throws Exception {143 futureReturns(null).when(spyLoggers.get(0)).startLogSegment(Mockito.anyLong(),144 Mockito.eq(NameNodeLayoutVersion.CURRENT_LAYOUT_VERSION));145 futureReturns(null).when(spyLoggers.get(1)).startLogSegment(Mockito.anyLong(),146 Mockito.eq(NameNodeLayoutVersion.CURRENT_LAYOUT_VERSION));147 futureReturns(null).when(spyLoggers.get(2)).startLogSegment(Mockito.anyLong(),148 Mockito.eq(NameNodeLayoutVersion.CURRENT_LAYOUT_VERSION));149 QuorumOutputStream os = (QuorumOutputStream) qjm.startLogSegment(1,150 NameNodeLayoutVersion.CURRENT_LAYOUT_VERSION);151 String report = os.generateReport();152 Assert.assertFalse("Report should be plain text", report.contains("<"));153 }154 @Test155 public void testWriteEdits() throws Exception {156 EditLogOutputStream stm = createLogSegment();157 writeOp(stm, 1);158 writeOp(stm, 2);159 160 stm.setReadyToFlush();161 writeOp(stm, 3);162 163 // The flush should log txn 1-2164 futureReturns(null).when(spyLoggers.get(0)).sendEdits(165 anyLong(), eq(1L), eq(2), Mockito.<byte[]>any());166 futureReturns(null).when(spyLoggers.get(1)).sendEdits(167 anyLong(), eq(1L), eq(2), Mockito.<byte[]>any());168 futureReturns(null).when(spyLoggers.get(2)).sendEdits(169 anyLong(), eq(1L), eq(2), Mockito.<byte[]>any());170 stm.flush();171 // Another flush should now log txn #3172 stm.setReadyToFlush();173 futureReturns(null).when(spyLoggers.get(0)).sendEdits(174 anyLong(), eq(3L), eq(1), Mockito.<byte[]>any());175 futureReturns(null).when(spyLoggers.get(1)).sendEdits(176 anyLong(), eq(3L), eq(1), Mockito.<byte[]>any());177 futureReturns(null).when(spyLoggers.get(2)).sendEdits(178 anyLong(), eq(3L), eq(1), Mockito.<byte[]>any());179 stm.flush();180 }181 182 @Test183 public void testWriteEditsOneSlow() throws Exception {184 EditLogOutputStream stm = createLogSegment();185 writeOp(stm, 1);186 stm.setReadyToFlush();187 188 // Make the first two logs respond immediately189 futureReturns(null).when(spyLoggers.get(0)).sendEdits(190 anyLong(), eq(1L), eq(1), Mockito.<byte[]>any());191 futureReturns(null).when(spyLoggers.get(1)).sendEdits(192 anyLong(), eq(1L), eq(1), Mockito.<byte[]>any());193 194 // And the third log not respond195 SettableFuture<Void> slowLog = SettableFuture.create();196 Mockito.doReturn(slowLog).when(spyLoggers.get(2)).sendEdits(197 anyLong(), eq(1L), eq(1), Mockito.<byte[]>any());198 stm.flush();199 200 Mockito.verify(spyLoggers.get(0)).setCommittedTxId(1L);201 }202 private EditLogOutputStream createLogSegment() throws IOException {203 futureReturns(null).when(spyLoggers.get(0)).startLogSegment(Mockito.anyLong(),204 Mockito.eq(NameNodeLayoutVersion.CURRENT_LAYOUT_VERSION));205 futureReturns(null).when(spyLoggers.get(1)).startLogSegment(Mockito.anyLong(),206 Mockito.eq(NameNodeLayoutVersion.CURRENT_LAYOUT_VERSION));207 futureReturns(null).when(spyLoggers.get(2)).startLogSegment(Mockito.anyLong(),208 Mockito.eq(NameNodeLayoutVersion.CURRENT_LAYOUT_VERSION));209 EditLogOutputStream stm = qjm.startLogSegment(1,210 NameNodeLayoutVersion.CURRENT_LAYOUT_VERSION);211 return stm;212 }213}...
Source:TestCachingKeyProvider.java
...26 @Test27 public void testCurrentKey() throws Exception {28 KeyProvider.KeyVersion mockKey = Mockito.mock(KeyProvider.KeyVersion.class);29 KeyProvider mockProv = Mockito.mock(KeyProvider.class);30 Mockito.when(mockProv.getCurrentKey(Mockito.eq("k1"))).thenReturn(mockKey);31 Mockito.when(mockProv.getCurrentKey(Mockito.eq("k2"))).thenReturn(null);32 Mockito.when(mockProv.getConf()).thenReturn(new Configuration());33 KeyProvider cache = new CachingKeyProvider(mockProv, 100, 100);34 // asserting caching35 Assert.assertEquals(mockKey, cache.getCurrentKey("k1"));36 Mockito.verify(mockProv, Mockito.times(1)).getCurrentKey(Mockito.eq("k1"));37 Assert.assertEquals(mockKey, cache.getCurrentKey("k1"));38 Mockito.verify(mockProv, Mockito.times(1)).getCurrentKey(Mockito.eq("k1"));39 Thread.sleep(1200);40 Assert.assertEquals(mockKey, cache.getCurrentKey("k1"));41 Mockito.verify(mockProv, Mockito.times(2)).getCurrentKey(Mockito.eq("k1"));42 // asserting no caching when key is not known43 cache = new CachingKeyProvider(mockProv, 100, 100);44 Assert.assertEquals(null, cache.getCurrentKey("k2"));45 Mockito.verify(mockProv, Mockito.times(1)).getCurrentKey(Mockito.eq("k2"));46 Assert.assertEquals(null, cache.getCurrentKey("k2"));47 Mockito.verify(mockProv, Mockito.times(2)).getCurrentKey(Mockito.eq("k2"));48 }49 @Test50 public void testKeyVersion() throws Exception {51 KeyProvider.KeyVersion mockKey = Mockito.mock(KeyProvider.KeyVersion.class);52 KeyProvider mockProv = Mockito.mock(KeyProvider.class);53 Mockito.when(mockProv.getKeyVersion(Mockito.eq("k1@0")))54 .thenReturn(mockKey);55 Mockito.when(mockProv.getKeyVersion(Mockito.eq("k2@0"))).thenReturn(null);56 Mockito.when(mockProv.getConf()).thenReturn(new Configuration());57 KeyProvider cache = new CachingKeyProvider(mockProv, 100, 100);58 // asserting caching59 Assert.assertEquals(mockKey, cache.getKeyVersion("k1@0"));60 Mockito.verify(mockProv, Mockito.times(1))61 .getKeyVersion(Mockito.eq("k1@0"));62 Assert.assertEquals(mockKey, cache.getKeyVersion("k1@0"));63 Mockito.verify(mockProv, Mockito.times(1))64 .getKeyVersion(Mockito.eq("k1@0"));65 Thread.sleep(200);66 Assert.assertEquals(mockKey, cache.getKeyVersion("k1@0"));67 Mockito.verify(mockProv, Mockito.times(2))68 .getKeyVersion(Mockito.eq("k1@0"));69 // asserting no caching when key is not known70 cache = new CachingKeyProvider(mockProv, 100, 100);71 Assert.assertEquals(null, cache.getKeyVersion("k2@0"));72 Mockito.verify(mockProv, Mockito.times(1))73 .getKeyVersion(Mockito.eq("k2@0"));74 Assert.assertEquals(null, cache.getKeyVersion("k2@0"));75 Mockito.verify(mockProv, Mockito.times(2))76 .getKeyVersion(Mockito.eq("k2@0"));77 }78 @Test79 public void testMetadata() throws Exception {80 KeyProvider.Metadata mockMeta = Mockito.mock(KeyProvider.Metadata.class);81 KeyProvider mockProv = Mockito.mock(KeyProvider.class);82 Mockito.when(mockProv.getMetadata(Mockito.eq("k1"))).thenReturn(mockMeta);83 Mockito.when(mockProv.getMetadata(Mockito.eq("k2"))).thenReturn(null);84 Mockito.when(mockProv.getConf()).thenReturn(new Configuration());85 KeyProvider cache = new CachingKeyProvider(mockProv, 100, 100);86 // asserting caching87 Assert.assertEquals(mockMeta, cache.getMetadata("k1"));88 Mockito.verify(mockProv, Mockito.times(1)).getMetadata(Mockito.eq("k1"));89 Assert.assertEquals(mockMeta, cache.getMetadata("k1"));90 Mockito.verify(mockProv, Mockito.times(1)).getMetadata(Mockito.eq("k1"));91 Thread.sleep(200);92 Assert.assertEquals(mockMeta, cache.getMetadata("k1"));93 Mockito.verify(mockProv, Mockito.times(2)).getMetadata(Mockito.eq("k1"));94 // asserting no caching when key is not known95 cache = new CachingKeyProvider(mockProv, 100, 100);96 Assert.assertEquals(null, cache.getMetadata("k2"));97 Mockito.verify(mockProv, Mockito.times(1)).getMetadata(Mockito.eq("k2"));98 Assert.assertEquals(null, cache.getMetadata("k2"));99 Mockito.verify(mockProv, Mockito.times(2)).getMetadata(Mockito.eq("k2"));100 }101 @Test102 public void testRollNewVersion() throws Exception {103 KeyProvider.KeyVersion mockKey = Mockito.mock(KeyProvider.KeyVersion.class);104 KeyProvider mockProv = Mockito.mock(KeyProvider.class);105 Mockito.when(mockProv.getCurrentKey(Mockito.eq("k1"))).thenReturn(mockKey);106 Mockito.when(mockProv.getConf()).thenReturn(new Configuration());107 KeyProvider cache = new CachingKeyProvider(mockProv, 100, 100);108 Assert.assertEquals(mockKey, cache.getCurrentKey("k1"));109 Mockito.verify(mockProv, Mockito.times(1)).getCurrentKey(Mockito.eq("k1"));110 cache.rollNewVersion("k1");111 // asserting the cache is purged112 Assert.assertEquals(mockKey, cache.getCurrentKey("k1"));113 Mockito.verify(mockProv, Mockito.times(2)).getCurrentKey(Mockito.eq("k1"));114 cache.rollNewVersion("k1", new byte[0]);115 Assert.assertEquals(mockKey, cache.getCurrentKey("k1"));116 Mockito.verify(mockProv, Mockito.times(3)).getCurrentKey(Mockito.eq("k1"));117 }118 @Test119 public void testDeleteKey() throws Exception {120 KeyProvider.KeyVersion mockKey = Mockito.mock(KeyProvider.KeyVersion.class);121 KeyProvider mockProv = Mockito.mock(KeyProvider.class);122 Mockito.when(mockProv.getCurrentKey(Mockito.eq("k1"))).thenReturn(mockKey);123 Mockito.when(mockProv.getKeyVersion(Mockito.eq("k1@0")))124 .thenReturn(mockKey);125 Mockito.when(mockProv.getMetadata(Mockito.eq("k1"))).thenReturn(126 new KMSClientProvider.KMSMetadata("c", 0, "l", null, new Date(), 1));127 Mockito.when(mockProv.getConf()).thenReturn(new Configuration());128 KeyProvider cache = new CachingKeyProvider(mockProv, 100, 100);129 Assert.assertEquals(mockKey, cache.getCurrentKey("k1"));130 Mockito.verify(mockProv, Mockito.times(1)).getCurrentKey(Mockito.eq("k1"));131 Assert.assertEquals(mockKey, cache.getKeyVersion("k1@0"));132 Mockito.verify(mockProv, Mockito.times(1))133 .getKeyVersion(Mockito.eq("k1@0"));134 cache.deleteKey("k1");135 // asserting the cache is purged136 Assert.assertEquals(mockKey, cache.getCurrentKey("k1"));137 Mockito.verify(mockProv, Mockito.times(2)).getCurrentKey(Mockito.eq("k1"));138 Assert.assertEquals(mockKey, cache.getKeyVersion("k1@0"));139 Mockito.verify(mockProv, Mockito.times(2))140 .getKeyVersion(Mockito.eq("k1@0"));141 }...
Source:RedisClusterLockTest.java
...25 .lockPrefix("lock_")26 .sleepTime(100)27 .build();28 RedisClusterConnection clusterConnection = new JedisClusterConnection(jedisCluster);29 Mockito.when(jedisConnectionFactory.getClusterConnection()).thenReturn(clusterConnection);30 jedisCluster = (JedisCluster)clusterConnection.getNativeConnection();31 }32 @Test33 public void tryLock() throws Exception {34 String key = "test";35 String request = UUID.randomUUID().toString();36 Mockito.when(jedisCluster.set(Mockito.anyString(), Mockito.anyString(), Mockito.anyString(),37 Mockito.anyString(), Mockito.anyLong())).thenReturn("OK");38 boolean locktest = redisLock.tryLock(key, request);39 System.out.println("locktest=" + locktest);40 Assert.assertTrue(locktest);41 //check42 Mockito.verify(jedisCluster).set(Mockito.anyString(), Mockito.anyString(), Mockito.anyString(),43 Mockito.anyString(), Mockito.anyLong());44 }45 @Test46 public void tryLockFalse() throws Exception {47 String key = "test";48 String request = UUID.randomUUID().toString();49 Mockito.when(jedisCluster.set(Mockito.anyString(), Mockito.anyString(), Mockito.anyString(),50 Mockito.anyString(), Mockito.anyLong())).thenReturn(null);51 boolean lock = redisLock.tryLock(key, request);52 Assert.assertFalse(lock);53 Mockito.verify(jedisCluster).set(Mockito.anyString(), Mockito.anyString(), Mockito.anyString(),54 Mockito.anyString(), Mockito.anyLong());55 }56 @Test57 public void tryLock2() throws Exception {58 Mockito.when(jedisCluster.set(Mockito.anyString(), Mockito.anyString(), Mockito.anyString(),59 Mockito.anyString(), Mockito.anyLong())).thenReturn("OK");60 boolean lock = redisLock.tryLock("test", UUID.randomUUID().toString(), 10 * 1000);61 Assert.assertTrue(lock);62 Mockito.verify(jedisCluster).set(Mockito.anyString(), Mockito.anyString(), Mockito.anyString(),63 Mockito.anyString(), Mockito.anyLong());64 }65 @Test66 public void tryLock2False() throws Exception {67 Mockito.when(jedisCluster.set(Mockito.anyString(), Mockito.anyString(), Mockito.anyString(),68 Mockito.anyString(), Mockito.anyLong())).thenReturn(null);69 boolean lock = redisLock.tryLock("test", UUID.randomUUID().toString(), 10 * 1000);70 Assert.assertFalse(lock);71 Mockito.verify(jedisCluster).set(Mockito.anyString(), Mockito.anyString(), Mockito.anyString(),72 Mockito.anyString(), Mockito.anyLong());73 }74 @Test75 public void lock() throws Exception {76 Mockito.when(jedisCluster.set(Mockito.anyString(), Mockito.anyString(), Mockito.anyString(),77 Mockito.anyString(), Mockito.anyLong())).thenReturn("OK");78 long start = System.currentTimeMillis();79 redisLock.lock("test", UUID.randomUUID().toString());80 long end = System.currentTimeMillis();81 System.out.println("lock success expire=" + (end - start));82 Mockito.verify(jedisCluster).set(Mockito.anyString(), Mockito.anyString(), Mockito.anyString(),83 Mockito.anyString(), Mockito.anyLong());84 }85 @Test86 public void lock2() throws Exception {87 Mockito.when(jedisCluster.set(Mockito.anyString(), Mockito.anyString(), Mockito.anyString(),88 Mockito.anyString(), Mockito.anyLong())).thenReturn("OK");89 long start = System.currentTimeMillis();90 boolean lock = redisLock.lock("test", UUID.randomUUID().toString(), 100);91 long end = System.currentTimeMillis();92 System.out.println("lock success expire=" + (end - start) + " lock = " + lock);93 Assert.assertTrue(lock);94 Mockito.verify(jedisCluster).set(Mockito.anyString(), Mockito.anyString(), Mockito.anyString(),95 Mockito.anyString(), Mockito.anyLong());96 }97 @Test98 public void lock2False() throws Exception {99 Mockito.when(jedisCluster.set(Mockito.anyString(), Mockito.anyString(), Mockito.anyString(),100 Mockito.anyString(), Mockito.anyLong())).thenReturn(null);101 long start = System.currentTimeMillis();102 boolean lock = redisLock.lock("test", UUID.randomUUID().toString(), 100);103 long end = System.currentTimeMillis();104 System.out.println("lock success expire=" + (end - start) + " lock = " + lock);105 Assert.assertFalse(lock);106 //check was called 2 times107 Mockito.verify(jedisCluster,Mockito.times(2)).set(Mockito.anyString(), Mockito.anyString(), Mockito.anyString(),108 Mockito.anyString(), Mockito.anyLong());109 }110 @Test111 public void unlock() throws Exception {112 Mockito.when(jedisCluster.eval(Mockito.anyString(), Mockito.anyList(), Mockito.anyList())).thenReturn(1L) ;113 boolean locktest = redisLock.unlock("test", "ec8ebca0-14ba0-4b23-99a8-b35fbba3629e");114 Assert.assertTrue(locktest);115 Mockito.verify(jedisCluster).eval(Mockito.anyString(), Mockito.anyList(), Mockito.anyList());116 }117 @Test118 public void unlockFalse() throws Exception {119 Mockito.when(jedisCluster.eval(Mockito.anyString(), Mockito.anyList(), Mockito.anyList())).thenReturn(0L) ;120 boolean locktest = redisLock.unlock("test", "ec8ebca0-14ba0-4b23-99a8-b35fbba3629e");121 Assert.assertFalse(locktest);122 Mockito.verify(jedisCluster).eval(Mockito.anyString(), Mockito.anyList(), Mockito.anyList());123 }124}...
Source:RabbitMQConsumerTest.java
...32import static org.junit.jupiter.api.Assertions.assertTrue;33import static org.mockito.ArgumentMatchers.any;34import static org.mockito.ArgumentMatchers.anyBoolean;35import static org.mockito.ArgumentMatchers.anyString;36import static org.mockito.Mockito.when;37public class RabbitMQConsumerTest {38 private ExtendedCamelContext ecc = Mockito.mock(ExtendedCamelContext.class);39 private ExchangeFactory ef = Mockito.mock(ExchangeFactory.class);40 private RabbitMQEndpoint endpoint = Mockito.mock(RabbitMQEndpoint.class);41 private Connection conn = Mockito.mock(Connection.class);42 private Processor processor = Mockito.mock(Processor.class);43 private Channel channel = Mockito.mock(Channel.class);44 private ExecutorServiceManager esm = Mockito.mock(ExecutorServiceManager.class);45 @Test46 public void testStoppingConsumerShutdownExecutor() throws Exception {47 ThreadPoolExecutor e = (ThreadPoolExecutor) Executors.newFixedThreadPool(3);48 Mockito.when(endpoint.createExecutor()).thenReturn(e);49 Mockito.when(endpoint.getConcurrentConsumers()).thenReturn(1);50 Mockito.when(endpoint.connect(any(ExecutorService.class))).thenReturn(conn);51 Mockito.when(endpoint.getCamelContext()).thenReturn(ecc);52 Mockito.when(ecc.adapt(ExtendedCamelContext.class)).thenReturn(ecc);53 Mockito.when(ecc.getExchangeFactory()).thenReturn(ef);54 Mockito.when(ef.newExchangeFactory(any())).thenReturn(ef);55 Mockito.when(ecc.getExecutorServiceManager()).thenReturn(esm);56 Mockito.when(esm.shutdownNow(e)).then(i -> e.shutdownNow());57 Mockito.when(conn.createChannel()).thenReturn(channel);58 RabbitMQConsumer consumer = new RabbitMQConsumer(endpoint, processor);59 consumer.doStart();60 assertFalse(e.isShutdown());61 consumer.doStop();62 assertTrue(e.isShutdown());63 }64 @Test65 public void testStoppingConsumerShutdownConnection() throws Exception {66 ExecutorService es = Executors.newFixedThreadPool(3);67 Mockito.when(endpoint.createExecutor()).thenReturn(es);68 Mockito.when(endpoint.getConcurrentConsumers()).thenReturn(1);69 Mockito.when(endpoint.connect(any(ExecutorService.class))).thenReturn(conn);70 Mockito.when(conn.createChannel()).thenReturn(channel);71 Mockito.when(endpoint.getCamelContext()).thenReturn(ecc);72 Mockito.when(ecc.adapt(ExtendedCamelContext.class)).thenReturn(ecc);73 Mockito.when(ecc.getExchangeFactory()).thenReturn(ef);74 Mockito.when(ef.newExchangeFactory(any())).thenReturn(ef);75 Mockito.when(ecc.getExecutorServiceManager()).thenReturn(esm);76 Mockito.when(esm.shutdownNow(es)).then(i -> es.shutdownNow());77 RabbitMQConsumer consumer = new RabbitMQConsumer(endpoint, processor);78 consumer.doStart();79 consumer.doStop();80 Mockito.verify(conn).close(30 * 1000);81 }82 @Test83 public void testStoppingConsumerShutdownConnectionWhenServerHasClosedChannel() throws Exception {84 AlreadyClosedException alreadyClosedException = Mockito.mock(AlreadyClosedException.class);85 ExecutorService es = Executors.newFixedThreadPool(3);86 Mockito.when(endpoint.createExecutor()).thenReturn(es);87 Mockito.when(endpoint.getConcurrentConsumers()).thenReturn(1);88 Mockito.when(endpoint.connect(any(ExecutorService.class))).thenReturn(conn);89 Mockito.when(conn.createChannel()).thenReturn(channel);90 Mockito.when(channel.basicConsume(anyString(), anyBoolean(), any(Consumer.class))).thenReturn("TAG");91 Mockito.when(channel.isOpen()).thenReturn(false);92 Mockito.when(endpoint.getCamelContext()).thenReturn(ecc);93 Mockito.when(ecc.adapt(ExtendedCamelContext.class)).thenReturn(ecc);94 Mockito.when(ecc.getExchangeFactory()).thenReturn(ef);95 Mockito.when(ef.newExchangeFactory(any())).thenReturn(ef);96 Mockito.when(ecc.getExecutorServiceManager()).thenReturn(esm);97 Mockito.when(esm.shutdownNow(es)).then(i -> es.shutdownNow());98 Mockito.doThrow(alreadyClosedException).when(channel).basicCancel("TAG");99 Mockito.doThrow(alreadyClosedException).when(channel).close();100 RabbitMQConsumer consumer = new RabbitMQConsumer(endpoint, processor);101 consumer.doStart();102 consumer.doStop();103 Mockito.verify(conn).close(30 * 1000);104 }105}...
Source:RedisSingleTest.java
...35 .lockPrefix("lock_")36 .sleepTime(100)37 .build();38 RedisConnection redisConnection = new JedisConnection(jedis) ;39 Mockito.when(jedisConnectionFactory.getConnection()).thenReturn(redisConnection);40 jedis = (Jedis)redisConnection.getNativeConnection();41 }42 @Test43 public void unlock() throws Exception {44 Mockito.when(jedis.eval(Mockito.anyString(), Mockito.anyList(), Mockito.anyList())).thenReturn(1L) ;45 boolean locktest = redisLock.unlock("test", "ec8ebca0-14ba0-4b23-99a8-b35fbba3629e");46 Assert.assertTrue(locktest);47 Mockito.verify(jedis).eval(Mockito.anyString(), Mockito.anyList(), Mockito.anyList());48 }49 @Test50 public void tryLock() throws Exception {51 String key = "test";52 String request = UUID.randomUUID().toString();53 Mockito.when(jedis.set(Mockito.anyString(), Mockito.anyString(),54 Mockito.anyString(), Mockito.anyString(), Mockito.anyInt()))55 .thenReturn("OK");56 boolean locktest = redisLock.tryLock(key, request);57 System.out.println("locktest=" + locktest);58 Assert.assertTrue(locktest);59 //check60 Mockito.verify(jedis).set(Mockito.anyString(), Mockito.anyString(), Mockito.anyString(),61 Mockito.anyString(), Mockito.anyInt());62 }63 @Test64 public void lock() throws Exception {65 Mockito.when(jedis.set(Mockito.anyString(), Mockito.anyString(), Mockito.anyString(),66 Mockito.anyString(), Mockito.anyInt())).thenReturn("OK");67 long start = System.currentTimeMillis();68 redisLock.lock("test", UUID.randomUUID().toString());69 long end = System.currentTimeMillis();70 System.out.println("lock success expire=" + (end - start));71 Mockito.verify(jedis).set(Mockito.anyString(), Mockito.anyString(), Mockito.anyString(),72 Mockito.anyString(), Mockito.anyInt());73 }74 @Test75 public void lock2() throws Exception {76 Mockito.when(jedis.set(Mockito.anyString(), Mockito.anyString(), Mockito.anyString(),77 Mockito.anyString(), Mockito.anyInt())).thenReturn("OK");78 long start = System.currentTimeMillis();79 boolean lock = redisLock.lock("test", UUID.randomUUID().toString(), 100);80 long end = System.currentTimeMillis();81 System.out.println("lock success expire=" + (end - start) + " lock = " + lock);82 Assert.assertTrue(lock);83 Mockito.verify(jedis).set(Mockito.anyString(), Mockito.anyString(), Mockito.anyString(),84 Mockito.anyString(), Mockito.anyInt());85 }86 @Test87 public void lock2False() throws Exception {88 Mockito.when(jedis.set(Mockito.anyString(), Mockito.anyString(), Mockito.anyString(),89 Mockito.anyString(), Mockito.anyInt())).thenReturn(null);90 long start = System.currentTimeMillis();91 boolean lock = redisLock.lock("test", UUID.randomUUID().toString(), 100);92 long end = System.currentTimeMillis();93 System.out.println("lock success expire=" + (end - start) + " lock = " + lock);94 Assert.assertFalse(lock);95 //check was called 2 times96 Mockito.verify(jedis,Mockito.times(2)).set(Mockito.anyString(), Mockito.anyString(), Mockito.anyString(),97 Mockito.anyString(), Mockito.anyInt());98 }99 @Test100 public void tryLock2() throws Exception {101 Mockito.when(jedis.set(Mockito.anyString(), Mockito.anyString(), Mockito.anyString(),102 Mockito.anyString(), Mockito.anyInt())).thenReturn("OK");103 boolean lock = redisLock.tryLock("test", UUID.randomUUID().toString(), 10 * 1000);104 Assert.assertTrue(lock);105 Mockito.verify(jedis).set(Mockito.anyString(), Mockito.anyString(), Mockito.anyString(),106 Mockito.anyString(), Mockito.anyInt());107 }108 @Test109 public void tryLock2False() throws Exception {110 Mockito.when(jedis.set(Mockito.anyString(), Mockito.anyString(), Mockito.anyString(),111 Mockito.anyString(), Mockito.anyInt())).thenReturn(null);112 boolean lock = redisLock.tryLock("test", UUID.randomUUID().toString(), 10 * 1000);113 Assert.assertFalse(lock);114 Mockito.verify(jedis).set(Mockito.anyString(), Mockito.anyString(), Mockito.anyString(),115 Mockito.anyString(), Mockito.anyInt());116 }117}...
Source:ProjectPersistenceTest.java
...21 @Before22 public void setUp(){23 this.mockedSessionFactory = Mockito.mock(SessionFactory.class);24 this.mockedSession = Mockito.mock(Session.class);25 Mockito.when(mockedSessionFactory.openSession()).thenReturn(mockedSession);26 this.persistence = new ProjectPersistence(mockedSessionFactory);27 }28 29 @Test30 public void testList(){31 List<Project> mockedResult = new ArrayList<Project>();32 Criteria mockedCriteria = Mockito.mock(Criteria.class);33 Mockito.when(mockedSession.createCriteria(Project.class)).thenReturn(mockedCriteria);34 Mockito.when(mockedCriteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY)).thenReturn(mockedCriteria);35 Mockito.when(mockedCriteria.list()).thenReturn(mockedResult);36 List<Project> result = this.persistence.list();37 Assert.assertNotNull(result);38 Assert.assertEquals(mockedResult, result);39 Mockito.verify(mockedSession,Mockito.times(1)).createCriteria(Project.class);40 Mockito.verify(mockedCriteria,Mockito.times(1)).setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);41 Mockito.verify(mockedCriteria,Mockito.times(1)).list();42 Mockito.verify(mockedSession,Mockito.times(1)).close();43 }44 45 @Test46 public void testGet() throws ObjectNotFoundException{47 Project mockedResult = ProjectMO.build();48 Criteria mockedCriteria = Mockito.mock(Criteria.class);49 Mockito.when(mockedSession.createCriteria(Project.class)).thenReturn(mockedCriteria);50 Mockito.when(mockedCriteria.add(Mockito.any(Criterion.class))).thenReturn(mockedCriteria);51 Mockito.when(mockedCriteria.uniqueResult()).thenReturn(mockedResult);52 Project result = this.persistence.findById(ProjectMO.ID);53 Assert.assertNotNull(result);54 Assert.assertEquals(mockedResult, result);55 Mockito.verify(mockedSession,Mockito.times(1)).createCriteria(Project.class);56 Mockito.verify(mockedCriteria,Mockito.times(1)).add(Mockito.any(Criterion.class));57 Mockito.verify(mockedCriteria,Mockito.times(1)).uniqueResult();58 Mockito.verify(mockedSession,Mockito.times(1)).close();59 }60 61 @Test(expected = ObjectNotFoundException.class)62 public void testGetNull() throws ObjectNotFoundException{63 Criteria mockedCriteria = Mockito.mock(Criteria.class);64 Mockito.when(mockedSession.createCriteria(Project.class)).thenReturn(mockedCriteria);65 Mockito.when(mockedCriteria.add(Mockito.any(Criterion.class))).thenReturn(mockedCriteria);66 Mockito.when(mockedCriteria.uniqueResult()).thenReturn(null);67 Project result = this.persistence.findById(ProjectMO.ID);68 Assert.assertNull(result);69 Mockito.verify(mockedSession,Mockito.times(1)).createCriteria(Project.class);70 Mockito.verify(mockedCriteria,Mockito.times(1)).add(Mockito.any(Criterion.class));71 Mockito.verify(mockedCriteria,Mockito.times(1)).uniqueResult();72 Mockito.verify(mockedSession,Mockito.times(1)).close();73 }74 75 @Test76 public void testSave(){77 Project mockedProject = ProjectMO.build();78 this.persistence.create(mockedProject);79 Mockito.verify(mockedSession, Mockito.times(1)).save(mockedProject);80 Mockito.verify(mockedSession, Mockito.times(1)).flush();...
when
Using AI Code Generation
1package org.mockito;2public class Mockito {3 public static <T> T mock(Class<T> classToMock) {4 return null;5 }6 public static <T> T any(Class<T> classToMock) {7 return null;8 }9}10package org.mockito;11public class Mockito {12 public static <T> T mock(Class<T> classToMock) {13 return null;14 }15 public static <T> T any(Class<T> classToMock) {16 return null;17 }18}19package org.mockito;20public class Mockito {21 public static <T> T mock(Class<T> classToMock) {22 return null;23 }24 public static <T> T any(Class<T> classToMock) {25 return null;26 }27}28package org.mockito;29public class Mockito {30 public static <T> T mock(Class<T> classToMock) {31 return null;32 }33 public static <T> T any(Class<T> classToMock) {34 return null;35 }36}37package org.mockito;38public class Mockito {39 public static <T> T mock(Class<T> classToMock) {40 return null;41 }42 public static <T> T any(Class<T> classToMock) {43 return null;44 }45}46package org.mockito;47public class Mockito {48 public static <T> T mock(Class<T> classToMock) {49 return null;50 }51 public static <T> T any(Class<T> classToMock) {52 return null;53 }54}55package org.mockito;56public class Mockito {57 public static <T> T mock(Class<T> classToMock) {58 return null;59 }60 public static <T> T any(Class<T> classToMock) {61 return null;62 }
when
Using AI Code Generation
1public class Mockito {2 public static <T> T mock(Class<T> classToMock) {3 return null;4 }5}6public class Mockito {7 public static <T> T mock(Class<T> classToMock) {8 return null;9 }10}11public class Mockito {12 public static <T> T mock(Class<T> classToMock) {13 return null;14 }15}16public class Mockito {17 public static <T> T mock(Class<T> classToMock) {18 return null;19 }20}21public class Mockito {22 public static <T> T mock(Class<T> classToMock) {23 return null;24 }25}26public class Mockito {27 public static <T> T mock(Class<T> classToMock) {28 return null;29 }30}31public class Mockito {32 public static <T> T mock(Class<T> classToMock) {33 return null;34 }35}36public class Mockito {37 public static <T> T mock(Class<T> classToMock) {38 return null;39 }40}41public class Mockito {42 public static <T> T mock(Class<T> classToMock) {43 return null;44 }45}46public class Mockito {47 public static <T> T mock(Class<T> classToMock) {48 return null;49 }50}51public class Mockito {52 public static <T> T mock(Class<T> class
when
Using AI Code Generation
1public class 1 {2 public static void main(String[] args) {3 org.mockito.Mockito.when(1).thenReturn(1);4 }5}6public class 2 {7 public static void main(String[] args) {8 org.mockito.Mockito.when(2).thenReturn(2);9 }10}11public class 3 {12 public static void main(String[] args) {13 org.mockito.Mockito.when(3).thenReturn(3);14 }15}16public class 4 {17 public static void main(String[] args) {18 org.mockito.Mockito.when(4).thenReturn(4);19 }20}21public class 5 {22 public static void main(String[] args) {23 org.mockito.Mockito.when(5).thenReturn(5);24 }25}26public class 6 {27 public static void main(String[] args) {28 org.mockito.Mockito.when(6).thenReturn(6);29 }30}31public class 7 {32 public static void main(String[] args) {33 org.mockito.Mockito.when(7).thenReturn(7);34 }35}36public class 8 {37 public static void main(String[] args) {38 org.mockito.Mockito.when(8).thenReturn(8);39 }40}41public class 9 {42 public static void main(String[] args) {43 org.mockito.Mockito.when(9).thenReturn(9);44 }45}46public class 10 {47 public static void main(String[] args) {48 org.mockito.Mockito.when(10).thenReturn(10);49 }50}
when
Using AI Code Generation
1public class 1 {2 public static void main(String[] args) {3 List mockList = mock(List.class);4 mockList.add("one");5 mockList.clear();6 verify(mockList).add("one");7 verify(mockList).clear();8 }9}10public class 2 {11 public static void main(String[] args) {12 LinkedList mockLinkedList = mock(LinkedList.class);13 when(mockLinkedList.get(0)).thenReturn("first");14 when(mockLinkedList.get(1)).thenThrow(new RuntimeException());15 System.out.println(mockLinkedList.get(0));16 System.out.println(mockLinkedList.get(1));17 System.out.println(mockLinkedList.get(999));18 verify(mockLinkedList).get(0);19 }20}21public class 3 {22 public static void main(String[] args) {23 LinkedList mockLinkedList = mock(LinkedList.class);24 when(mockLinkedList.get(anyInt())).thenReturn("element");25 when(mockLinkedList.contains(argThat(isValid()))).thenReturn(true);26 System.out.println(mockLinkedList.get(999));27 verify(mockLinkedList).get(anyInt());28 verify(mockLinkedList).contains(argThat(someString -> someString.length() > 5));29 }30}
when
Using AI Code Generation
1public class 1 {2 public static void main(String[] args) {3 org.mockito.Mockito.when("test");4 }5}6public class 2 {7 public static void main(String[] args) {8 org.mockito.Mockito.when("test");9 }10}11public class 3 {12 public static void main(String[] args) {13 org.mockito.Mockito.when("test");14 }15}16public class 4 {17 public static void main(String[] args) {18 org.mockito.Mockito.when("test");19 }20}21public class 5 {22 public static void main(String[] args) {23 org.mockito.Mockito.when("test");24 }25}26public class 6 {27 public static void main(String[] args) {28 org.mockito.Mockito.when("test");29 }30}31public class 7 {32 public static void main(String[] args) {33 org.mockito.Mockito.when("test");34 }35}36public class 8 {37 public static void main(String[] args) {38 org.mockito.Mockito.when("test");39 }40}41public class 9 {42 public static void main(String[] args) {43 org.mockito.Mockito.when("test");44 }45}46public class 10 {47 public static void main(String[] args) {48 org.mockito.Mockito.when("test");49 }50}51public class 11 {52 public static void main(String[] args) {53 org.mockito.Mockito.when("test");54 }55}
when
Using AI Code Generation
1import org.mockito.Mockito;2class Test {3 public void test() {4 Mockito.mock(java.util.List.class);5 }6}7import static org.mockito.Mockito.mock;8class Test {9 public void test() {10 mock(java.util.List.class);11 }12}13import static org.mockito.Mockito.*;14class Test {15 public void test() {16 mock(java.util.List.class);17 }18}19import org.mockito.Mockito.mock;20class Test {21 public void test() {22 mock(java.util.List.class);23 }24}25import org.mockito.Mockito.*;26class Test {27 public void test() {28 mock(java.util.List.class);29 }30}31import org.mockito.Mockito.*;32import static org.mockito.Mockito.mock;33class Test {34 public void test() {35 mock(java.util.List.class);36 }37}38import org.mockito.Mockito.*;39import static org.mockito.Mockito.mock;40class Test {41 public void test() {42 mock(java.util.List.class);43 }44}45import static org.mockito.Mockito.*;46import static org.mockito.Mockito.mock;47class Test {48 public void test() {49 mock(java.util.List.class);50 }51}52import static org.mockito.Mockito.*;53import static org.mockito.Mockito.mock;54class Test {55 public void test() {56 mock(java.util.List.class);57 }58}59import static org.mockito.Mockito.*;60import static org.mockito.Mockito.mock;61class Test {62 public void test() {63 mock(java.util.List.class);64 }65}66import static org.mockito.Mockito.*;67import static org.mockito.Mockito.mock;68class Test {69 public void test() {70 mock(java.util.List.class);71 }72}73import static org.mockito.Mockito.*;74import static org.mockito.Mockito.mock;75class Test {76 public void test() {77 mock(java.util.List
when
Using AI Code Generation
1when(mockedObject.method(anyInt())).thenReturn(1);2when(mockedObject.method(anyInt())).thenReturn(2);3when(mockedObject.method(anyInt())).thenReturn(3);4when(mockedObject.method(anyInt())).thenReturn(4);5when(mockedObject.method(anyInt())).thenReturn(5);6when(mockedObject.method(anyInt())).thenReturn(6);7when(mockedObject.method(anyInt())).thenReturn(7);8when(mockedObject.method(anyInt())).thenReturn(8);9when(mockedObject.method(anyInt())).thenReturn(9);10when(mockedObject.method(anyInt())).thenReturn(10);11when(mockedObject.method(anyInt())).thenReturn(11);12when(mockedObject.method(anyInt())).thenReturn(12);13when(mockedObject.method(anyInt())).thenReturn(13);
when
Using AI Code Generation
1public class 1 {2 public static void main(String[] args) {3 Mockito.when("mockito").thenReturn("mockito");4 }5}6public class 2 {7 public static void main(String[] args) {8 Mockito.when("mockito").thenReturn("mockito");9 }10}11public class 3 {12 public static void main(String[] args) {13 Mockito.when("mockito").thenReturn("mockito");14 }15}16public class 4 {17 public static void main(String[] args) {18 Mockito.when("mockito").thenReturn("mockito");19 }20}21public class 5 {22 public static void main(String[] args) {23 Mockito.when("mockito").thenReturn("mockito");24 }25}26public class 6 {27 public static void main(String[] args) {28 Mockito.when("mockito").thenReturn("mockito");29 }30}31public class 7 {32 public static void main(String[] args) {33 Mockito.when("mockito").thenReturn("mockito");34 }35}36public class 8 {37 public static void main(String[] args) {38 Mockito.when("
when
Using AI Code Generation
1public class 1 {2 public static Object returnObject() {3 return null;4 }5}6public class 2 {7 public static String returnString() {8 return null;9 }10}11public class 3 {12 public static Integer returnInteger() {13 return null;14 }15}16public class 4 {17 public static Long returnLong() {18 return null;19 }20}21public class 5 {22 public static Double returnDouble() {23 return null;24 }25}26public class 6 {27 public static Float returnFloat() {28 return null;29 }30}31public class 7 {32 public static Short returnShort() {33 return null;34 }35}36public class 8 {37 public static Byte returnByte() {38 return null;39 }40}41public class 9 {42 public static Boolean returnBoolean() {43 return null;44 }45}46public class 10 {47 public static Char returnChar() {48 return null;
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.
You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.
Get 100 minutes of automation test minutes FREE!!