re-organize testing modules

2019-09-08 15:30:03 +03:00
parent 4e7b8cf19d
commit 35116b0e69
104 changed files with 2325 additions and 191 deletions
@@ -0,0 +1,220 @@
+package com.baeldung.easymock;
+
+import static org.easymock.EasyMock.and;
+import static org.easymock.EasyMock.anyString;
+import static org.easymock.EasyMock.contains;
+import static org.easymock.EasyMock.endsWith;
+import static org.easymock.EasyMock.eq;
+import static org.easymock.EasyMock.expect;
+import static org.easymock.EasyMock.geq;
+import static org.easymock.EasyMock.gt;
+import static org.easymock.EasyMock.isA;
+import static org.easymock.EasyMock.isNull;
+import static org.easymock.EasyMock.lt;
+import static org.easymock.EasyMock.matches;
+import static org.easymock.EasyMock.mock;
+import static org.easymock.EasyMock.not;
+import static org.easymock.EasyMock.notNull;
+import static org.easymock.EasyMock.replay;
+import static org.easymock.EasyMock.same;
+import static org.easymock.EasyMock.startsWith;
+import static org.easymock.EasyMock.verify;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Collections;
+import java.util.List;
+
+import org.easymock.EasyMock;
+import org.easymock.IArgumentMatcher;
+import org.junit.Test;
+
+public class ArgumentMatchersUnitTest {
+
+    private IUserService userService = mock(IUserService.class);
+
+    //====================== equals
+    @Test
+    public void givenUserService_whenAddNewUser_thenOK() {        
+        expect(userService.addUser(eq(new User()))).andReturn(true);
+        replay(userService);
+
+        boolean result = userService.addUser(new User());
+        verify(userService);
+        assertTrue(result);
+    }      
+    
+    //================ same
+    @Test
+    public void givenUserService_whenAddSpecificUser_thenOK() {
+        User user = new User();
+        
+        expect(userService.addUser(same(user))).andReturn(true);
+        replay(userService);
+
+        boolean result = userService.addUser(user);
+        verify(userService);
+        assertTrue(result);
+    } 
+    
+    //============= anyX
+    @Test
+    public void givenUserService_whenSearchForUserByEmail_thenFound() {        
+        expect(userService.findByEmail(anyString())).andReturn(Collections.emptyList());
+        replay(userService);
+
+        List<User> result = userService.findByEmail("test@example.com");
+        verify(userService);
+        assertEquals(0,result.size());
+    }    
+    
+    //================= isA
+    @Test
+    public void givenUserService_whenAddUser_thenOK() {        
+        expect(userService.addUser(isA(User.class))).andReturn(true);
+        replay(userService);
+
+        boolean result = userService.addUser(new User());
+        verify(userService);
+        assertTrue(result);
+    }    
+        
+    //=================== null, not null
+    @Test
+    public void givenUserService_whenAddNull_thenFail() {        
+        expect(userService.addUser(isNull())).andReturn(false);
+        replay(userService);
+
+        boolean result = userService.addUser(null);
+        verify(userService);
+        assertFalse(result);
+    }      
+    
+    @Test
+    public void givenUserService_whenAddNotNull_thenOK() {        
+        expect(userService.addUser(notNull())).andReturn(true);
+        replay(userService);
+
+        boolean result = userService.addUser(new User());
+        verify(userService);
+        assertTrue(result);
+    }  
+    
+    // number less,great
+    @Test
+    public void givenUserService_whenSearchForUserByAgeLessThan_thenFound() {        
+        expect(userService.findByAge(lt(100.0))).andReturn(Collections.emptyList());
+        replay(userService);
+
+        List<User> result = userService.findByAge(20);        
+        verify(userService);
+        assertEquals(0,result.size());
+    }    
+    
+    @Test
+    public void givenUserService_whenSearchForUserByAgeGreaterThan_thenFound() {        
+        expect(userService.findByAge(geq(10.0))).andReturn(Collections.emptyList());
+        replay(userService);
+
+        List<User> result = userService.findByAge(20);        
+        verify(userService);
+        assertEquals(0,result.size());
+    }    
+    
+    //=============== string 
+    //=============== start
+    @Test
+    public void givenUserService_whenSearchForUserByEmailStartsWith_thenFound() {        
+        expect(userService.findByEmail(startsWith("test"))).andReturn(Collections.emptyList());
+        replay(userService);
+
+        List<User> result = userService.findByEmail("test@example.com");
+        verify(userService);
+        assertEquals(0,result.size());
+    }
+    
+    //==================end
+    @Test
+    public void givenUserService_whenSearchForUserByEmailEndsWith_thenFound() {        
+        expect(userService.findByEmail(endsWith(".com"))).andReturn(Collections.emptyList());
+        replay(userService);
+
+        List<User> result = userService.findByEmail("test@example.com");
+        verify(userService);
+        assertEquals(0,result.size());
+    }
+    
+    //=================contain
+    @Test
+    public void givenUserService_whenSearchForUserByEmailContains_thenFound() {        
+        expect(userService.findByEmail(contains("@"))).andReturn(Collections.emptyList());
+        replay(userService);
+
+        List<User> result = userService.findByEmail("test@example.com");
+        verify(userService);
+        assertEquals(0,result.size());
+    }
+    
+    //==================matches
+    @Test
+    public void givenUserService_whenSearchForUserByEmailMatches_thenFound() {        
+        expect(userService.findByEmail(matches(".+\\@.+\\..+"))).andReturn(Collections.emptyList());
+        replay(userService);
+
+        List<User> result = userService.findByEmail("test@example.com");
+        verify(userService);
+        assertEquals(0,result.size());
+    }
+    
+    //================== combine and, or, not
+    @Test
+    public void givenUserService_whenSearchForUserByAgeRange_thenFound() {        
+        expect(userService.findByAge(and(gt(10.0),lt(100.0)))).andReturn(Collections.emptyList());
+        replay(userService);
+
+        List<User> result = userService.findByAge(20);        
+        verify(userService);
+        assertEquals(0,result.size());
+    }        
+    
+    @Test
+    public void givenUserService_whenSearchForUserByEmailNotEndsWith_thenFound() {        
+        expect(userService.findByEmail(not(endsWith(".com")))).andReturn(Collections.emptyList());
+        replay(userService);
+
+        List<User> result = userService.findByEmail("test@example.org");
+        verify(userService);
+        assertEquals(0,result.size());
+    }    
+    
+    //================ custom matcher
+    
+    @Test
+    public void givenUserService_whenSearchForUserByEmailCharCount_thenFound() {        
+        expect(userService.findByEmail(minCharCount(5))).andReturn(Collections.emptyList());
+        replay(userService);
+
+        List<User> result = userService.findByEmail("test@example.com");
+        verify(userService);
+        assertEquals(0,result.size());
+    }
+    
+    public static String minCharCount(int value){
+        EasyMock.reportMatcher(new IArgumentMatcher() {
+            @Override
+            public boolean matches(Object argument) {
+                return argument instanceof String 
+                  && ((String) argument).length() >= value;
+            }
+     
+            @Override
+            public void appendTo(StringBuffer buffer) {
+                buffer.append("charCount(\"" + value + "\")");
+            }
+        });    
+        return null;
+    }
+}
+
+
@@ -0,0 +1,57 @@
+package com.baeldung.easymock;
+
+import org.easymock.EasyMockRunner;
+import org.easymock.Mock;
+import org.easymock.TestSubject;
+import org.junit.*;
+import org.junit.runner.RunWith;
+
+import java.util.NoSuchElementException;
+
+import static org.easymock.EasyMock.*;
+
+@RunWith(EasyMockRunner.class)
+public class BaeldungReaderAnnotatedUnitTest {
+
+    @Mock ArticleReader mockArticleReader;
+
+    @Mock IArticleWriter mockArticleWriter;
+
+    @TestSubject BaeldungReader baeldungReader = new BaeldungReader();
+
+    @Test
+    public void givenBaeldungReader_whenReadNext_thenNextArticleRead() {
+        expect(mockArticleReader.next()).andReturn(null);
+        replay(mockArticleReader);
+        baeldungReader.readNext();
+        verify(mockArticleReader);
+    }
+
+    @Mock BaeldungReader mockBaeldungReader;
+
+    @Test
+    public void givenBaeldungReader_whenWrite_thenWriterCalled() {
+        expect(mockArticleWriter.write("title", "content")).andReturn(null);
+        replay(mockArticleWriter);
+        baeldungReader.write("title", "content");
+        verify(mockArticleWriter);
+    }
+
+    @Test
+    public void givenArticlesInReader_whenReadTillEnd_thenThrowException() {
+        expect(mockArticleReader.next())
+          .andReturn(null)
+          .times(2)
+          .andThrow(new NoSuchElementException());
+        replay(mockArticleReader);
+        try {
+            for (int i = 0; i < 3; i++) {
+                baeldungReader.readNext();
+            }
+        } catch (Exception ignored) {
+        }
+        verify(mockArticleReader);
+    }
+
+}
+
@@ -0,0 +1,57 @@
+package com.baeldung.easymock;
+
+import org.easymock.EasyMockRule;
+import org.easymock.Mock;
+import org.easymock.TestSubject;
+import org.junit.*;
+
+import java.util.NoSuchElementException;
+
+import static org.easymock.EasyMock.*;
+
+public class BaeldungReaderAnnotatedWithRuleUnitTest {
+
+    @Rule public EasyMockRule mockRule = new EasyMockRule(this);
+
+    @Mock ArticleReader mockArticleReader;
+
+    @Mock IArticleWriter mockArticleWriter;
+
+    @TestSubject BaeldungReader baeldungReader = new BaeldungReader();
+
+    @Test
+    public void givenBaeldungReader_whenReadNext_thenNextArticleRead() {
+        expect(mockArticleReader.next()).andReturn(null);
+        replay(mockArticleReader);
+        baeldungReader.readNext();
+        verify(mockArticleReader);
+    }
+
+    @Mock BaeldungReader mockBaeldungReader;
+
+    @Test
+    public void givenBaeldungReader_whenWrite_thenWriterCalled() {
+        expect(mockArticleWriter.write("title", "content")).andReturn(null);
+        replay(mockArticleWriter);
+        baeldungReader.write("title", "content");
+        verify(mockArticleWriter);
+    }
+
+    @Test
+    public void givenArticlesInReader_whenReadTillEnd_thenThrowException() {
+        expect(mockArticleReader.next())
+          .andReturn(null)
+          .times(2)
+          .andThrow(new NoSuchElementException());
+        replay(mockArticleReader);
+        try {
+            for (int i = 0; i < 3; i++) {
+                baeldungReader.readNext();
+            }
+        } catch (Exception ignored) {
+        }
+        verify(mockArticleReader);
+    }
+
+}
+
@@ -0,0 +1,27 @@
+package com.baeldung.easymock;
+
+import org.easymock.*;
+import org.junit.*;
+
+import static org.easymock.EasyMock.*;
+
+public class BaeldungReaderMockDelegationUnitTest {
+
+    EasyMockSupport easyMockSupport = new EasyMockSupport();
+
+    @Test
+    public void givenBaeldungReader_whenReadAndWriteSequencially_thenWorks() {
+        ArticleReader mockArticleReader = easyMockSupport.createMock(ArticleReader.class);
+        IArticleWriter mockArticleWriter = easyMockSupport.createMock(IArticleWriter.class);
+        BaeldungReader baeldungReader = new BaeldungReader(mockArticleReader, mockArticleWriter);
+
+        expect(mockArticleReader.next()).andReturn(null);
+        expect(mockArticleWriter.write("title", "content")).andReturn("");
+        easyMockSupport.replayAll();
+
+        baeldungReader.readNext();
+        baeldungReader.write("title", "content");
+        easyMockSupport.verifyAll();
+    }
+
+}
@@ -0,0 +1,42 @@
+package com.baeldung.easymock;
+
+import org.easymock.*;
+import org.junit.*;
+import org.junit.runner.RunWith;
+
+import java.util.NoSuchElementException;
+
+import static org.easymock.EasyMock.*;
+import static org.junit.Assert.assertEquals;
+
+@RunWith(EasyMockRunner.class)
+public class BaeldungReaderMockSupportUnitTest extends EasyMockSupport {
+
+    @TestSubject BaeldungReader baeldungReader = new BaeldungReader();
+    @Mock ArticleReader mockArticleReader;
+    @Mock IArticleWriter mockArticleWriter;
+
+    @Test
+    public void givenBaeldungReader_whenReadAndWriteSequencially_thenWorks() {
+        expect(mockArticleReader.next())
+          .andReturn(null)
+          .times(2)
+          .andThrow(new NoSuchElementException());
+        expect(mockArticleWriter.write("title", "content")).andReturn("BAEL-201801");
+        replayAll();
+
+        Exception expectedException = null;
+        try {
+            for (int i = 0; i < 3; i++) {
+                baeldungReader.readNext();
+            }
+        } catch (Exception exception) {
+            expectedException = exception;
+        }
+        String articleId = baeldungReader.write("title", "content");
+        verifyAll();
+        assertEquals(NoSuchElementException.class, expectedException.getClass());
+        assertEquals("BAEL-201801", articleId);
+    }
+
+}
@@ -0,0 +1,105 @@
+package com.baeldung.easymock;
+
+import org.junit.*;
+
+import java.util.NoSuchElementException;
+
+import static org.easymock.EasyMock.*;
+import static org.junit.Assert.assertEquals;
+
+public class BaeldungReaderUnitTest {
+
+    private BaeldungReader baeldungReader;
+
+    private ArticleReader mockArticleReader;
+
+    private IArticleWriter mockArticleWriter;
+
+    @Test
+    public void givenBaeldungReader_whenReadNext_thenNextArticleRead() {
+        mockArticleReader = mock(ArticleReader.class);
+        baeldungReader = new BaeldungReader(mockArticleReader);
+
+        expect(mockArticleReader.next()).andReturn(null);
+        replay(mockArticleReader);
+
+        BaeldungArticle article = baeldungReader.readNext();
+        verify(mockArticleReader);
+        assertEquals(null, article);
+    }
+
+    @Test
+    public void givenBaeldungReader_whenReadNextAndSkimTopics_thenAllAllowed() {
+        mockArticleReader = strictMock(ArticleReader.class);
+        baeldungReader = new BaeldungReader(mockArticleReader);
+
+        expect(mockArticleReader.next()).andReturn(null);
+        expect(mockArticleReader.ofTopic("easymock")).andReturn(null);
+        replay(mockArticleReader);
+
+        baeldungReader.readNext();
+        baeldungReader.readTopic("easymock");
+        verify(mockArticleReader);
+    }
+
+    @Test
+    public void givenBaeldungReader_whenReadNextAndOthers_thenAllowed() {
+        mockArticleReader = niceMock(ArticleReader.class);
+        baeldungReader = new BaeldungReader(mockArticleReader);
+
+        expect(mockArticleReader.next()).andReturn(null);
+        replay(mockArticleReader);
+
+        baeldungReader.readNext();
+        baeldungReader.readTopic("easymock");
+        verify(mockArticleReader);
+    }
+
+    @Test
+    public void givenBaeldungReader_whenWriteMaliciousContent_thenArgumentIllegal() {
+        mockArticleWriter = mock(IArticleWriter.class);
+        baeldungReader = new BaeldungReader(mockArticleWriter);
+        expect(mockArticleWriter.write("easymock", "<body onload=alert('baeldung')>")).andThrow(new IllegalArgumentException());
+        replay(mockArticleWriter);
+
+        Exception expectedException = null;
+        try {
+            baeldungReader.write("easymock", "<body onload=alert('baeldung')>");
+        } catch (Exception exception) {
+            expectedException = exception;
+        }
+
+        verify(mockArticleWriter);
+        assertEquals(IllegalArgumentException.class, expectedException.getClass());
+    }
+
+    @Test
+    public void givenBaeldungReader_whenWrite_thenWriterCalled() {
+        mockArticleWriter = mock(IArticleWriter.class);
+        baeldungReader = new BaeldungReader(mockArticleWriter);
+        expect(mockArticleWriter.write("title", "content")).andReturn(null);
+        replay(mockArticleWriter);
+        String articleId = baeldungReader.write("title", "content");
+        verify(mockArticleWriter);
+        assertEquals(null, articleId);
+    }
+
+    @Test
+    public void givenArticlesInReader_whenReadTillEnd_thenThrowException() {
+        ArticleReader mockArticleReader = mock(ArticleReader.class);
+        baeldungReader = new BaeldungReader(mockArticleReader);
+        expect(mockArticleReader.next())
+          .andReturn(null)
+          .times(2)
+          .andThrow(new NoSuchElementException());
+        replay(mockArticleReader);
+        try {
+            for (int i = 0; i < 3; i++) {
+                baeldungReader.readNext();
+            }
+        } catch (Exception ignored) {
+        }
+        verify(mockArticleReader);
+    }
+
+}
@@ -0,0 +1,62 @@
+package com.baeldung.introductionjukito;
+
+import org.jukito.All;
+import org.jukito.JukitoModule;
+import org.jukito.JukitoRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import static org.junit.Assert.*;
+
+@RunWith(JukitoRunner.class)
+public class CalculatorUnitTest {
+
+    public static class Module extends JukitoModule {
+
+        @Override
+        protected void configureTest() {
+            bindMany(Calculator.class, SimpleCalculator.class, 
+              ScientificCalculator.class);
+            bindManyInstances(AdditionTest.class, new AdditionTest(1, 1, 2), 
+              new AdditionTest(10, 10, 20), 
+              new AdditionTest(18, 24, 42));
+            bindManyNamedInstances(Integer.class, "even", 2, 4, 6);
+            bindManyNamedInstances(Integer.class, "odd", 1, 3, 5);
+        }
+    }
+
+    public static class AdditionTest {
+
+        int a;
+        int b;
+        int expected;
+
+        public AdditionTest(int a, int b, int expected) {
+            this.a = a;
+            this.b = b;
+            this.expected = expected;
+        }
+    }
+
+    @Test
+    public void givenTwoNumbers_WhenAdd_ThenSumBoth(@All Calculator calc) {
+        double result = calc.add(1, 1);
+        assertEquals(2, result, .1);
+    }
+
+    @Test
+    public void givenTwoNumbers_WhenAdd_ThenSumBoth(@All Calculator calc, 
+      @All AdditionTest addTest) {
+        double result = calc.add(addTest.a, addTest.b);
+        assertEquals(addTest.expected, result, .1);
+    }
+
+    @Test
+    public void givenEvenNumbers_whenPrint_thenOutput(@All("even") Integer i) {
+        System.out.println("even " + i);
+    }
+
+    @Test
+    public void givenOddNumbers_whenPrint_thenOutput(@All("odd") Integer i) {
+        System.out.println("odd " + i);
+    }
+}
@@ -0,0 +1,121 @@
+package com.baeldung.javafaker;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Locale;
+import java.util.Random;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import com.github.javafaker.Faker;
+import com.github.javafaker.service.FakeValuesService;
+import com.github.javafaker.service.LocaleDoesNotExistException;
+import com.github.javafaker.service.RandomService;
+
+public class JavaFakerUnitTest {
+
+    private Faker faker;
+
+    @Before
+    public void setUp() throws Exception {
+        faker = new Faker();
+    }
+
+    @Test
+    public void givenJavaFaker_whenAddressObjectCalled_checkValidAddressInfoGiven() throws Exception {
+
+        Faker faker = new Faker();
+
+        String streetName = faker.address()
+            .streetName();
+        String number = faker.address()
+            .buildingNumber();
+        String city = faker.address()
+            .city();
+        String country = faker.address()
+            .country();
+
+        System.out.println(String.format("%s\n%s\n%s\n%s", number, streetName, city, country));
+
+    }
+
+    @Test
+    public void givenJavaFakersWithSameSeed_whenNameCalled_CheckSameName() throws Exception {
+
+        Faker faker1 = new Faker(new Random(24));
+        Faker faker2 = new Faker(new Random(24));
+
+        assertEquals(faker1.name()
+            .firstName(),
+            faker2.name()
+                .firstName());
+    }
+
+    @Test
+    public void givenJavaFakersWithDifferentLocals_checkZipCodesMatchRegex() throws Exception {
+
+        Faker ukFaker = new Faker(new Locale("en-GB"));
+        Faker usFaker = new Faker(new Locale("en-US"));
+
+        System.out.println(String.format("American zipcode: %s", usFaker.address()
+            .zipCode()));
+        System.out.println(String.format("British postcode: %s", ukFaker.address()
+            .zipCode()));
+
+        Pattern ukPattern = Pattern.compile("([Gg][Ii][Rr] 0[Aa]{2})|((([A-Za-z][0-9]{1,2})|(([A-Za-z][A-Ha-hJ-Yj-y][0-9]{1,2})|(([A-Za-z][0-9][A-Za-z])|([A-Za-z][A-Ha-hJ-Yj-y][0-9]?[A-Za-z]))))\\s?[0-9][A-Za-z]{2})");
+        Matcher ukMatcher = ukPattern.matcher(ukFaker.address()
+            .zipCode());
+
+        assertTrue(ukMatcher.find());
+
+        Matcher usMatcher = Pattern.compile("^\\d{5}(?:[-\\s]\\d{4})?$")
+            .matcher(usFaker.address()
+                .zipCode());
+
+        assertTrue(usMatcher.find());
+
+    }
+
+    @Test
+    public void givenJavaFakerService_testFakersCreated() throws Exception {
+
+        RandomService randomService = new RandomService();
+
+        System.out.println(randomService.nextBoolean());
+        System.out.println(randomService.nextDouble());
+
+        Faker faker = new Faker(new Random(randomService.nextLong()));
+
+        System.out.println(faker.address()
+            .city());
+
+    }
+
+    @Test
+    public void testFakeValuesService() throws Exception {
+
+        FakeValuesService fakeValuesService = new FakeValuesService(new Locale("en-GB"), new RandomService());
+
+        String email = fakeValuesService.bothify("????##@gmail.com");
+        Matcher emailMatcher = Pattern.compile("\\w{4}\\d{2}@gmail.com")
+            .matcher(email);
+        assertTrue(emailMatcher.find());
+
+        String alphaNumericString = fakeValuesService.regexify("[a-z1-9]{10}");
+        Matcher alphaNumericMatcher = Pattern.compile("[a-z1-9]{10}")
+            .matcher(alphaNumericString);
+        assertTrue(alphaNumericMatcher.find());
+
+    }
+
+    @Test(expected = LocaleDoesNotExistException.class)
+    public void givenWrongLocale_whenFakerIsInitialised_testLocaleDoesNotExistExceptionIsThrown() throws Exception {
+
+        Faker wrongLocaleFaker = new Faker(new Locale("en-seaWorld"));
+
+    }
+}
@@ -0,0 +1,44 @@
+package com.baeldung.mocks.jmockit;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import mockit.Deencapsulation;
+import mockit.Mock;
+import mockit.MockUp;
+
+public class AppManagerUnitTest {
+
+    private AppManager appManager;
+
+    @BeforeEach
+    public void setUp() {
+        appManager = new AppManager();
+    }
+
+    @Test
+    public void givenAppManager_whenStaticMethodCalled_thenValidateExpectedResponse() {
+        new MockUp<AppManager>() {
+            @Mock
+            public boolean isResponsePositive(String value) {
+                return false;
+            }
+        };
+
+        Assertions.assertFalse(appManager.managerResponse("Why are you coming late?"));
+    }
+
+    @Test
+    public void givenAppManager_whenPrivateStaticMethod_thenValidateExpectedResponse() {
+        final int response = Deencapsulation.invoke(AppManager.class, "stringToInteger", "110");
+        Assertions.assertEquals(110, response);
+    }
+
+    @Test
+    public void givenAppManager_whenPrivateStaticMethod_thenExpectException() {
+        Assertions.assertThrows(IllegalArgumentException.class, () -> {
+            Deencapsulation.invoke(AppManager.class, "stringToInteger", "11r");
+        });
+    }
+}
@@ -0,0 +1,143 @@
+package org.baeldung.mocks.easymock;
+
+import org.baeldung.mocks.testCase.LoginController;
+import org.baeldung.mocks.testCase.LoginDao;
+import org.baeldung.mocks.testCase.LoginService;
+import org.baeldung.mocks.testCase.UserForm;
+import org.easymock.*;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(EasyMockRunner.class)
+public class LoginControllerIntegrationTest {
+
+    @Mock
+    private LoginDao loginDao;
+
+    @Mock
+    private LoginService loginService;
+
+    @TestSubject
+    private LoginController loginController = new LoginController();
+
+    @Test
+    public void assertThatNoMethodHasBeenCalled() {
+        EasyMock.replay(loginService);
+        loginController.login(null);
+
+        // no method called
+        EasyMock.verify(loginService);
+    }
+
+    @Test
+    public void assertTwoMethodsHaveBeenCalled() {
+        UserForm userForm = new UserForm();
+        userForm.username = "foo";
+        EasyMock.expect(loginService.login(userForm)).andReturn(true);
+        loginService.setCurrentUser("foo");
+        EasyMock.replay(loginService);
+
+        String login = loginController.login(userForm);
+
+        Assert.assertEquals("OK", login);
+        EasyMock.verify(loginService);
+    }
+
+    @Test
+    public void assertOnlyOneMethodHasBeenCalled() {
+        UserForm userForm = new UserForm();
+        userForm.username = "foo";
+        EasyMock.expect(loginService.login(userForm)).andReturn(false);
+        EasyMock.replay(loginService);
+
+        String login = loginController.login(userForm);
+
+        Assert.assertEquals("KO", login);
+        EasyMock.verify(loginService);
+    }
+
+    @Test
+    public void mockExceptionThrowing() {
+        UserForm userForm = new UserForm();
+        EasyMock.expect(loginService.login(userForm)).andThrow(new IllegalArgumentException());
+        EasyMock.replay(loginService);
+
+        String login = loginController.login(userForm);
+
+        Assert.assertEquals("ERROR", login);
+        EasyMock.verify(loginService);
+    }
+
+    @Test
+    public void mockAnObjectToPassAround() {
+        UserForm userForm = EasyMock.mock(UserForm.class);
+        EasyMock.expect(userForm.getUsername()).andReturn("foo");
+        EasyMock.expect(loginService.login(userForm)).andReturn(true);
+        loginService.setCurrentUser("foo");
+        EasyMock.replay(userForm);
+        EasyMock.replay(loginService);
+
+        String login = loginController.login(userForm);
+
+        Assert.assertEquals("OK", login);
+        EasyMock.verify(userForm);
+        EasyMock.verify(loginService);
+    }
+
+    @Test
+    public void argumentMatching() {
+        UserForm userForm = new UserForm();
+        userForm.username = "foo";
+        // default matcher
+        EasyMock.expect(loginService.login(EasyMock.isA(UserForm.class))).andReturn(true);
+        // complex matcher
+        loginService.setCurrentUser(specificArgumentMatching("foo"));
+        EasyMock.replay(loginService);
+
+        String login = loginController.login(userForm);
+
+        Assert.assertEquals("OK", login);
+        EasyMock.verify(loginService);
+    }
+
+    private static String specificArgumentMatching(final String expected) {
+        EasyMock.reportMatcher(new IArgumentMatcher() {
+            @Override
+            public boolean matches(Object argument) {
+                return argument instanceof String && ((String) argument).startsWith(expected);
+            }
+
+            @Override
+            public void appendTo(StringBuffer buffer) {
+                //NOOP
+            }
+        });
+        return null;
+    }
+
+    @Test
+    public void partialMocking() {
+        UserForm userForm = new UserForm();
+        userForm.username = "foo";
+        // use partial mock
+        LoginService loginServicePartial = EasyMock.partialMockBuilder(LoginService.class).
+                addMockedMethod("setCurrentUser").createMock();
+        loginServicePartial.setCurrentUser("foo");
+        // let service's login use implementation so let's mock DAO call
+        EasyMock.expect(loginDao.login(userForm)).andReturn(1);
+
+        loginServicePartial.setLoginDao(loginDao);
+        loginController.loginService = loginServicePartial;
+
+        EasyMock.replay(loginDao);
+        EasyMock.replay(loginServicePartial);
+
+        String login = loginController.login(userForm);
+
+        Assert.assertEquals("OK", login);
+        // verify mocked call
+        EasyMock.verify(loginServicePartial);
+        EasyMock.verify(loginDao);
+    }
+}
@@ -0,0 +1,110 @@
+package org.baeldung.mocks.jmockit;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.baeldung.mocks.jmockit.AdvancedCollaborator.InnerAdvancedCollaborator;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import mockit.Deencapsulation;
+import mockit.Expectations;
+import mockit.Invocation;
+import mockit.Mock;
+import mockit.MockUp;
+import mockit.Mocked;
+import mockit.Tested;
+import mockit.integration.junit4.JMockit;
+
+@RunWith(JMockit.class)
+public class AdvancedCollaboratorIntegrationTest<MultiMock extends List<String> & Comparable<List<String>>> {
+
+    @Tested
+    private AdvancedCollaborator mock;
+    
+    @Mocked
+    private MultiMock multiMock;
+
+    @Test
+    public void testToMockUpPrivateMethod() {
+        new MockUp<AdvancedCollaborator>() {
+            @Mock
+            private String privateMethod() {
+                return "mocked: ";
+            }
+        };
+        String res = mock.methodThatCallsPrivateMethod(1);
+        assertEquals("mocked: 1", res);
+    }
+
+    @Test
+    public void testToMockUpDifficultConstructor() throws Exception {
+        new MockUp<AdvancedCollaborator>() {
+            @Mock
+            public void $init(Invocation invocation, String string) {
+                ((AdvancedCollaborator) invocation.getInvokedInstance()).i = 1;
+            }
+        };
+        AdvancedCollaborator coll = new AdvancedCollaborator(null);
+        assertEquals(1, coll.i);
+    }
+
+    @Test
+    public void testToCallPrivateMethodsDirectly() {
+        Object value = Deencapsulation.invoke(mock, "privateMethod");
+        assertEquals("default:", value);
+    }
+
+    @Test
+    public void testToSetPrivateFieldDirectly() {
+        Deencapsulation.setField(mock, "privateField", 10);
+        assertEquals(10, mock.methodThatReturnsThePrivateField());
+    }
+
+    @Test
+    public void testToGetPrivateFieldDirectly() {
+        int value = Deencapsulation.getField(mock, "privateField");
+        assertEquals(5, value);
+    }
+
+    @Test
+    public void testToCreateNewInstanceDirectly() {
+        AdvancedCollaborator coll = Deencapsulation.newInstance(AdvancedCollaborator.class, "foo");
+        assertEquals(3, coll.i);
+    }
+
+    @Test
+    public void testToCreateNewInnerClassInstanceDirectly() {
+        InnerAdvancedCollaborator innerCollaborator = Deencapsulation.newInnerInstance(InnerAdvancedCollaborator.class, mock);
+        assertNotNull(innerCollaborator);
+    }
+    
+    @Test
+    @SuppressWarnings("unchecked")
+    public void testMultipleInterfacesWholeTest() {
+        new Expectations() {
+            {
+                multiMock.get(5); result = "foo";
+                multiMock.compareTo((List<String>) any); result = 0;
+            }
+        };
+        assertEquals("foo", multiMock.get(5));
+        assertEquals(0, multiMock.compareTo(new ArrayList<>()));
+    }
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public <M extends List<String> & Comparable<List<String>>> void testMultipleInterfacesOneMethod(@Mocked M mock) {
+        new Expectations() {
+            {
+                mock.get(5); result = "foo";
+                mock.compareTo((List<String>) any);
+                result = 0; }
+        };
+        assertEquals("foo", mock.get(5));
+        assertEquals(0, mock.compareTo(new ArrayList<>()));
+    }
+}
@@ -0,0 +1,158 @@
+package org.baeldung.mocks.jmockit;
+
+import mockit.Delegate;
+import mockit.Expectations;
+import mockit.Mocked;
+import mockit.StrictExpectations;
+import mockit.Verifications;
+import mockit.integration.junit4.JMockit;
+import org.hamcrest.BaseMatcher;
+import org.hamcrest.Description;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+@RunWith(JMockit.class)
+@SuppressWarnings("unchecked")
+public class ExpectationsIntegrationTest {
+
+    @Test
+    public void testForAny(@Mocked ExpectationsCollaborator mock) throws Exception {
+        new Expectations() {{
+            mock.methodForAny1(anyString, anyInt, anyBoolean);
+            result = "any";
+        }};
+
+        assertEquals("any", mock.methodForAny1("barfooxyz", 0, Boolean.FALSE));
+        mock.methodForAny2(2L, new ArrayList<>());
+
+        new Verifications() {{
+            mock.methodForAny2(anyLong, (List<String>) any);
+        }};
+    }
+
+    @Test
+    public void testForWith(@Mocked ExpectationsCollaborator mock) throws Exception {
+        new Expectations() {{
+            mock.methodForWith1(withSubstring("foo"), withNotEqual(1));
+            result = "with";
+        }};
+
+        assertEquals("with", mock.methodForWith1("barfooxyz", 2));
+        mock.methodForWith2(Boolean.TRUE, new ArrayList<>());
+
+        new Verifications() {{
+            mock.methodForWith2(withNotNull(), withInstanceOf(List.class));
+        }};
+    }
+
+    @Test
+    public void testWithNulls(@Mocked ExpectationsCollaborator mock) {
+        new Expectations() {{
+            mock.methodForNulls1(anyString, null);
+            result = "null";
+        }};
+
+        assertEquals("null", mock.methodForNulls1("blablabla", new ArrayList<String>()));
+        mock.methodForNulls2("blablabla", null);
+
+        new Verifications() {{
+            mock.methodForNulls2(anyString, (List<String>) withNull());
+        }};
+    }
+
+    @Test
+    public void testWithTimes(@Mocked ExpectationsCollaborator mock) {
+        new Expectations() {{
+            mock.methodForTimes1();
+            times = 2;
+            mock.methodForTimes2();
+        }};
+
+        mock.methodForTimes1();
+        mock.methodForTimes1();
+        mock.methodForTimes2();
+        mock.methodForTimes3();
+        mock.methodForTimes3();
+        mock.methodForTimes3();
+
+        new Verifications() {{
+            mock.methodForTimes3();
+            minTimes = 1;
+            maxTimes = 3;
+        }};
+    }
+
+    @Test
+    public void testCustomArgumentMatching(@Mocked ExpectationsCollaborator mock) {
+        new Expectations() {{
+            mock.methodForArgThat(withArgThat(new BaseMatcher<Object>() {
+                @Override
+                public boolean matches(Object item) {
+                    return item instanceof Model && "info".equals(((Model) item).getInfo());
+                }
+
+                @Override
+                public void describeTo(Description description) {
+                }
+            }));
+        }};
+        mock.methodForArgThat(new Model());
+    }
+
+    @Test
+    public void testResultAndReturns(@Mocked ExpectationsCollaborator mock) {
+        new StrictExpectations() {{
+            mock.methodReturnsString();
+            result = "foo";
+            result = new Exception();
+            result = "bar";
+            mock.methodReturnsInt();
+            result = new int[]{1, 2, 3};
+            mock.methodReturnsString();
+            returns("foo", "bar");
+            mock.methodReturnsInt();
+            result = 1;
+        }};
+
+        assertEquals("Should return foo", "foo", mock.methodReturnsString());
+        try {
+            mock.methodReturnsString();
+        } catch (Exception e) {
+            // NOOP
+        }
+        assertEquals("Should return bar", "bar", mock.methodReturnsString());
+        assertEquals("Should return 1", 1, mock.methodReturnsInt());
+        assertEquals("Should return 2", 2, mock.methodReturnsInt());
+        assertEquals("Should return 3", 3, mock.methodReturnsInt());
+        assertEquals("Should return foo", "foo", mock.methodReturnsString());
+        assertEquals("Should return bar", "bar", mock.methodReturnsString());
+        assertEquals("Should return 1", 1, mock.methodReturnsInt());
+    }
+
+    @Test
+    public void testDelegate(@Mocked ExpectationsCollaborator mock) {
+        new Expectations() {{
+            mock.methodForDelegate(anyInt);
+            result = new Delegate() {
+                public int delegate(int i) throws Exception {
+                    if (i < 3) {
+                        return 5;
+                    } else {
+                        throw new Exception();
+                    }
+                }
+            };
+        }};
+
+        assertEquals("Should return 5", 5, mock.methodForDelegate(1));
+        try {
+            mock.methodForDelegate(3);
+        } catch (Exception e) {
+        }
+    }
+}
@@ -0,0 +1,159 @@
+package org.baeldung.mocks.jmockit;
+
+import mockit.*;
+import mockit.integration.junit4.JMockit;
+import org.baeldung.mocks.testCase.LoginController;
+import org.baeldung.mocks.testCase.LoginDao;
+import org.baeldung.mocks.testCase.LoginService;
+import org.baeldung.mocks.testCase.UserForm;
+import org.hamcrest.BaseMatcher;
+import org.hamcrest.Description;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(JMockit.class)
+public class LoginControllerIntegrationTest {
+
+    @Injectable
+    private LoginDao loginDao;
+
+    @Injectable
+    private LoginService loginService;
+
+    @Tested
+    private LoginController loginController;
+
+    @Test
+    public void assertThatNoMethodHasBeenCalled() {
+        loginController.login(null);
+        // no method called
+        new FullVerifications(loginService) {
+        };
+    }
+
+    @Test
+    public void assertTwoMethodsHaveBeenCalled() {
+        final UserForm userForm = new UserForm();
+        userForm.username = "foo";
+        new Expectations() {{
+            loginService.login(userForm);
+            result = true;
+            loginService.setCurrentUser("foo");
+        }};
+
+        String login = loginController.login(userForm);
+
+        Assert.assertEquals("OK", login);
+        new FullVerifications(loginService) {
+        };
+    }
+
+    @Test
+    public void assertOnlyOneMethodHasBeenCalled() {
+        final UserForm userForm = new UserForm();
+        userForm.username = "foo";
+        new Expectations() {{
+            loginService.login(userForm);
+            result = false;
+            // no expectation for setCurrentUser
+        }};
+
+        String login = loginController.login(userForm);
+
+        Assert.assertEquals("KO", login);
+        new FullVerifications(loginService) {
+        };
+    }
+
+    @Test
+    public void mockExceptionThrowing() {
+        final UserForm userForm = new UserForm();
+        new Expectations() {{
+            loginService.login(userForm);
+            result = new IllegalArgumentException();
+            // no expectation for setCurrentUser
+        }};
+
+        String login = loginController.login(userForm);
+
+        Assert.assertEquals("ERROR", login);
+        new FullVerifications(loginService) {
+        };
+    }
+
+    @Test
+    public void mockAnObjectToPassAround(@Mocked final UserForm userForm) {
+        new Expectations() {{
+            userForm.getUsername();
+            result = "foo";
+            loginService.login(userForm);
+            result = true;
+            loginService.setCurrentUser("foo");
+        }};
+
+        String login = loginController.login(userForm);
+
+        Assert.assertEquals("OK", login);
+        new FullVerifications(loginService) {
+        };
+        new FullVerifications(userForm) {
+        };
+    }
+
+    @Test
+    public void argumentMatching() {
+        final UserForm userForm = new UserForm();
+        userForm.username = "foo";
+        // default matcher
+        new Expectations() {{
+            loginService.login((UserForm) any);
+            result = true;
+            // complex matcher
+            loginService.setCurrentUser(withArgThat(new BaseMatcher<String>() {
+                @Override
+                public boolean matches(Object item) {
+                    return item instanceof String && ((String) item).startsWith("foo");
+                }
+
+                @Override
+                public void describeTo(Description description) {
+                    //NOOP
+                }
+            }));
+        }};
+
+        String login = loginController.login(userForm);
+
+        Assert.assertEquals("OK", login);
+        new FullVerifications(loginService) {
+        };
+    }
+
+    @Test
+    public void partialMocking() {
+        // use partial mock
+        final LoginService partialLoginService = new LoginService();
+        partialLoginService.setLoginDao(loginDao);
+        loginController.loginService = partialLoginService;
+
+        final UserForm userForm = new UserForm();
+        userForm.username = "foo";
+        // let service's login use implementation so let's mock DAO call
+        new Expectations() {{
+            loginDao.login(userForm);
+            result = 1;
+            // no expectation for loginService.login
+            partialLoginService.setCurrentUser("foo");
+        }};
+
+        String login = loginController.login(userForm);
+
+        Assert.assertEquals("OK", login);
+        // verify mocked call
+        new FullVerifications(partialLoginService) {
+        };
+        new FullVerifications(loginDao) {
+        };
+    }
+}
@@ -0,0 +1,32 @@
+package org.baeldung.mocks.jmockit;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import mockit.*;
+import mockit.integration.junit4.JMockit;
+
+@RunWith(JMockit.class)
+public class PerformerIntegrationTest {
+
+    @Injectable
+    private Collaborator collaborator;
+
+    @Tested
+    private Performer performer;
+
+    @Test
+    public void testThePerformMethod(@Mocked Model model) {
+    	new Expectations() {{
+    		model.getInfo();result = "bar";
+    		collaborator.collaborate("bar"); result = true;
+    	}};
+
+    	performer.perform(model);
+
+    	new Verifications() {{
+    		collaborator.receive(true);
+    	}};
+    }
+
+}
@@ -0,0 +1,57 @@
+package org.baeldung.mocks.jmockit;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import mockit.Expectations;
+import mockit.Injectable;
+import mockit.Mocked;
+import mockit.Tested;
+import mockit.Verifications;
+import mockit.integration.junit4.JMockit;
+
+@RunWith(JMockit.class)
+public class ReusingIntegrationTest {
+
+    @Injectable
+    private Collaborator collaborator;
+    
+    @Mocked
+    private Model model;
+
+    @Tested
+    private Performer performer;
+    
+    @Before
+    public void setup(){
+        new Expectations(){{
+           model.getInfo(); result = "foo"; minTimes = 0;
+           collaborator.collaborate("foo"); result = true; minTimes = 0; 
+        }};
+    }
+
+    @Test
+    public void testWithSetup() {
+        performer.perform(model);
+        verifyTrueCalls(1);
+    }
+    
+    protected void verifyTrueCalls(int calls){
+        new Verifications(){{
+           collaborator.receive(true); times = calls; 
+        }};
+    }
+    
+    final class TrueCallsVerification extends Verifications{
+        public TrueCallsVerification(int calls){
+            collaborator.receive(true); times = calls; 
+        }
+    }
+    
+    @Test
+    public void testWithFinalClass() {
+        performer.perform(model);
+        new TrueCallsVerification(1);
+    }
+}
@@ -0,0 +1,149 @@
+package org.baeldung.mocks.mockito;
+
+import org.baeldung.mocks.testCase.LoginController;
+import org.baeldung.mocks.testCase.LoginDao;
+import org.baeldung.mocks.testCase.LoginService;
+import org.baeldung.mocks.testCase.UserForm;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.ArgumentMatcher;
+import org.mockito.ArgumentMatchers;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.mockito.Spy;
+
+public class LoginControllerIntegrationTest {
+
+    @Mock
+    private LoginDao loginDao;
+
+    @Spy
+    @InjectMocks
+    private LoginService spiedLoginService;
+
+    @Mock
+    private LoginService loginService;
+
+    @InjectMocks
+    private LoginController loginController;
+
+    @Before
+    public void setUp() {
+        loginController = new LoginController();
+        MockitoAnnotations.initMocks(this);
+    }
+
+    @Test
+    public void assertThatNoMethodHasBeenCalled() {
+        loginController.login(null);
+        // no method called
+        Mockito.verifyZeroInteractions(loginService);
+    }
+
+    @Test
+    public void assertTwoMethodsHaveBeenCalled() {
+        UserForm userForm = new UserForm();
+        userForm.username = "foo";
+        Mockito.when(loginService.login(userForm))
+            .thenReturn(true);
+
+        String login = loginController.login(userForm);
+
+        Assert.assertEquals("OK", login);
+        Mockito.verify(loginService)
+            .login(userForm);
+        Mockito.verify(loginService)
+            .setCurrentUser("foo");
+    }
+
+    @Test
+    public void assertOnlyOneMethodHasBeenCalled() {
+        UserForm userForm = new UserForm();
+        userForm.username = "foo";
+        Mockito.when(loginService.login(userForm))
+            .thenReturn(false);
+
+        String login = loginController.login(userForm);
+
+        Assert.assertEquals("KO", login);
+        Mockito.verify(loginService)
+            .login(userForm);
+        Mockito.verifyNoMoreInteractions(loginService);
+    }
+
+    @Test
+    public void mockExceptionThrowing() {
+        UserForm userForm = new UserForm();
+        Mockito.when(loginService.login(userForm))
+            .thenThrow(IllegalArgumentException.class);
+
+        String login = loginController.login(userForm);
+
+        Assert.assertEquals("ERROR", login);
+        Mockito.verify(loginService)
+            .login(userForm);
+        Mockito.verifyZeroInteractions(loginService);
+    }
+
+    @Test
+    public void mockAnObjectToPassAround() {
+        UserForm userForm = Mockito.when(Mockito.mock(UserForm.class)
+            .getUsername())
+            .thenReturn("foo")
+            .getMock();
+        Mockito.when(loginService.login(userForm))
+            .thenReturn(true);
+
+        String login = loginController.login(userForm);
+
+        Assert.assertEquals("OK", login);
+        Mockito.verify(loginService)
+            .login(userForm);
+        Mockito.verify(loginService)
+            .setCurrentUser("foo");
+    }
+
+    @Test
+    public void argumentMatching() {
+        UserForm userForm = new UserForm();
+        userForm.username = "foo";
+        // default matcher
+        Mockito.when(loginService.login(Mockito.any(UserForm.class)))
+            .thenReturn(true);
+
+        String login = loginController.login(userForm);
+
+        Assert.assertEquals("OK", login);
+        Mockito.verify(loginService)
+            .login(userForm);
+        // complex matcher
+        Mockito.verify(loginService)
+            .setCurrentUser(ArgumentMatchers.argThat(new ArgumentMatcher<String>() {
+                @Override
+                public boolean matches(String argument) {
+                    return argument.startsWith("foo");
+                }
+            }));
+    }
+
+    @Test
+    public void partialMocking() {
+        // use partial mock
+        loginController.loginService = spiedLoginService;
+        UserForm userForm = new UserForm();
+        userForm.username = "foo";
+        // let service's login use implementation so let's mock DAO call
+        Mockito.when(loginDao.login(userForm))
+            .thenReturn(1);
+
+        String login = loginController.login(userForm);
+
+        Assert.assertEquals("OK", login);
+        // verify mocked call
+        Mockito.verify(spiedLoginService)
+            .setCurrentUser("foo");
+    }
+}