Merge branch 'master' of https://github.com/JonCook/tutorials

testing-modules/mocks/src/main/java/com/baeldung/easymock/ArticleReader.java

@@ -0,0 +1,36 @@
+package com.baeldung.easymock;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import static java.util.stream.Collectors.toList;
+
+public class ArticleReader {
+
+    private List<BaeldungArticle> articles;
+    private Iterator<BaeldungArticle> articleIter;
+
+    public ArticleReader() {
+        this(new ArrayList<>());
+    }
+
+    public ArticleReader(List<BaeldungArticle> articles) {
+        this.articles = articles;
+        this.articleIter = this.articles.iterator();
+    }
+
+    public List<BaeldungArticle> ofTopic(String topic) {
+        return articles
+          .stream()
+          .filter(article -> article
+            .title()
+            .contains(topic))
+          .collect(toList());
+    }
+
+    public BaeldungArticle next() {
+        return this.articleIter.next();
+    }
+
+}

testing-modules/mocks/src/main/java/com/baeldung/easymock/BaeldungArticle.java

@@ -0,0 +1,25 @@
+package com.baeldung.easymock;
+
+public class BaeldungArticle {
+
+    public static BaeldungArticle simpleArticle(String title, String content) {
+        return new BaeldungArticle(title, content);
+    }
+
+    private String title;
+    private String content;
+
+    private BaeldungArticle(String title, String content) {
+        this.title = title;
+        this.content = content;
+    }
+
+    public String title() {
+        return this.title;
+    }
+
+    public String content() {
+        return this.content;
+    }
+
+}

testing-modules/mocks/src/main/java/com/baeldung/easymock/BaeldungReader.java

@@ -0,0 +1,40 @@
+package com.baeldung.easymock;
+
+import java.util.List;
+
+public class BaeldungReader {
+
+    private ArticleReader articleReader;
+    private IArticleWriter articleWriter;
+
+    public BaeldungReader() {
+    }
+
+    ;
+
+    public BaeldungReader(ArticleReader articleReader) {
+        this.articleReader = articleReader;
+    }
+
+    public BaeldungReader(IArticleWriter writer) {
+        this.articleWriter = writer;
+    }
+
+    public BaeldungReader(ArticleReader articleReader, IArticleWriter writer) {
+        this.articleReader = articleReader;
+        this.articleWriter = writer;
+    }
+
+    public BaeldungArticle readNext() {
+        return articleReader.next();
+    }
+
+    public List<BaeldungArticle> readTopic(String topic) {
+        return articleReader.ofTopic(topic);
+    }
+
+    public String write(String title, String content) {
+        return articleWriter.write(title, content);
+    }
+
+}

testing-modules/mocks/src/main/java/com/baeldung/easymock/IArticleWriter.java

@@ -0,0 +1,7 @@
+package com.baeldung.easymock;
+
+public interface IArticleWriter {
+
+    String write(String title, String content);
+
+}

testing-modules/mocks/src/main/java/com/baeldung/easymock/IUserService.java

@@ -0,0 +1,9 @@
+package com.baeldung.easymock;
+
+import java.util.List;
+
+public interface IUserService {
+    public boolean addUser(User user);
+    public List<User> findByEmail(String email);    
+    public List<User> findByAge(double age);
+}

testing-modules/mocks/src/main/java/com/baeldung/easymock/User.java

@@ -0,0 +1,109 @@
+package com.baeldung.easymock;
+
+public class User {
+    private long id;
+    private String firstName;
+    private String lastName;
+    private double age;
+    private String email;
+    
+    public User() {
+        super();
+    }
+        
+    public User(String firstName, String lastName) {
+        super();
+        this.firstName = firstName;
+        this.lastName = lastName;
+    }
+
+    //
+    
+    public long getId() {
+        return id;
+    }
+    public void setId(long id) {
+        this.id = id;
+    }
+    public String getFirstName() {
+        return firstName;
+    }
+    public void setFirstName(String firstName) {
+        this.firstName = firstName;
+    }
+    public String getLastName() {
+        return lastName;
+    }
+    public void setLastName(String lastName) {
+        this.lastName = lastName;
+    }
+    public double getAge() {
+        return age;
+    }
+    public void setAge(double age) {
+        this.age = age;
+    }
+    public String getEmail() {
+        return email;
+    }
+    public void setEmail(String email) {
+        this.email = email;
+    }
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        long temp;
+        temp = Double.doubleToLongBits(age);
+        result = prime * result + (int) (temp ^ (temp >>> 32));
+        result = prime * result + ((email == null) ? 0 : email.hashCode());
+        result = prime * result + ((firstName == null) ? 0 : firstName.hashCode());
+        result = prime * result + (int) (id ^ (id >>> 32));
+        result = prime * result + ((lastName == null) ? 0 : lastName.hashCode());
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null) {
+            return false;
+        }
+        if (getClass() != obj.getClass()) {
+            return false;
+        }
+        User other = (User) obj;
+        if (Double.doubleToLongBits(age) != Double.doubleToLongBits(other.age)) {
+            return false;
+        }
+        if (email == null) {
+            if (other.email != null) {
+                return false;
+            }
+        } else if (!email.equals(other.email)) {
+            return false;
+        }
+        if (firstName == null) {
+            if (other.firstName != null) {
+                return false;
+            }
+        } else if (!firstName.equals(other.firstName)) {
+            return false;
+        }
+        if (id != other.id) {
+            return false;
+        }
+        if (lastName == null) {
+            if (other.lastName != null) {
+                return false;
+            }
+        } else if (!lastName.equals(other.lastName)) {
+            return false;
+        }
+        return true;
+    }
+
+}

testing-modules/mocks/src/main/java/com/baeldung/introductionjukito/Calculator.java

@@ -0,0 +1,7 @@
+package com.baeldung.introductionjukito;
+
+public interface Calculator {
+
+    public double add(double a, double b);
+
+}

testing-modules/mocks/src/main/java/com/baeldung/introductionjukito/ScientificCalculator.java

@@ -0,0 +1,5 @@
+package com.baeldung.introductionjukito;
+
+public class ScientificCalculator extends SimpleCalculator {
+    
+}

testing-modules/mocks/src/main/java/com/baeldung/introductionjukito/SimpleCalculator.java

@@ -0,0 +1,10 @@
+package com.baeldung.introductionjukito;
+
+public class SimpleCalculator implements Calculator {
+
+    @Override
+    public double add(double a, double b) {
+        return a+b;
+    }
+
+}

testing-modules/mocks/src/main/java/com/baeldung/jimfs/FileManipulation.java

@@ -0,0 +1,19 @@
+package com.baeldung.jimfs;
+
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+
+public class FileManipulation {
+
+    void move(final Path origin, final Path destination) {
+        try {
+            Files.createDirectories(destination);
+            Files.move(origin, destination, StandardCopyOption.REPLACE_EXISTING);
+        } catch (final IOException ex) {
+            throw new UncheckedIOException(ex);
+        }
+    }
+}

testing-modules/mocks/src/main/java/com/baeldung/jimfs/FilePathReader.java

@@ -0,0 +1,18 @@
+package com.baeldung.jimfs;
+
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.nio.file.Path;
+
+class FilePathReader {
+
+    String getSystemPath(final Path path) {
+        try {
+            return path
+              .toRealPath()
+              .toString();
+        } catch (final IOException ex) {
+            throw new UncheckedIOException(ex);
+        }
+    }
+}

testing-modules/mocks/src/main/java/com/baeldung/jimfs/FileRepository.java

@@ -0,0 +1,43 @@
+package com.baeldung.jimfs;
+
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+public class FileRepository {
+
+    void create(final Path path, final String fileName) {
+        final Path filePath = path.resolve(fileName);
+        try {
+            Files.createFile(filePath);
+        } catch (final IOException ex) {
+            throw new UncheckedIOException(ex);
+        }
+    }
+
+    String read(final Path path) {
+        try {
+            return new String(Files.readAllBytes(path));
+        } catch (final IOException ex) {
+            throw new UncheckedIOException(ex);
+        }
+    }
+
+    String update(final Path path, final String newContent) {
+        try {
+            Files.write(path, newContent.getBytes());
+            return newContent;
+        } catch (final IOException ex) {
+            throw new UncheckedIOException(ex);
+        }
+    }
+
+    void delete(final Path path) {
+        try {
+            Files.deleteIfExists(path);
+        } catch (final IOException ex) {
+            throw new UncheckedIOException(ex);
+        }
+    }
+}

testing-modules/mocks/src/main/java/com/baeldung/mocks/jmockit/AppManager.java

@@ -0,0 +1,26 @@
+package com.baeldung.mocks.jmockit;
+
+import java.util.Random;
+
+public class AppManager {
+
+    public boolean managerResponse(String question) {
+        return AppManager.isResponsePositive(question);
+    }
+
+    public static boolean isResponsePositive(String value) {
+        if (value == null)
+            return false;
+        int orgLength = value.length();
+        int randomNumber = randomNumber();
+        return orgLength == randomNumber ? true : false;
+    }
+
+    private static int randomNumber() {
+        return new Random().nextInt(7);
+    }
+
+    private static Integer stringToInteger(String num) {
+        return Integer.parseInt(num);
+    }
+}

testing-modules/mocks/src/main/java/org/baeldung/mocks/jmockit/AdvancedCollaborator.java

@@ -0,0 +1,20 @@
+package org.baeldung.mocks.jmockit;
+
+public class AdvancedCollaborator {
+    int i;
+    private int privateField = 5;
+    public AdvancedCollaborator(){}
+    public AdvancedCollaborator(String string) throws Exception{
+        i = string.length();
+    }
+    public String methodThatCallsPrivateMethod(int i){
+        return privateMethod() + i;
+    }
+    public int methodThatReturnsThePrivateField(){
+        return privateField;
+    }
+    private String privateMethod(){
+        return "default:";
+    }
+    class InnerAdvancedCollaborator{}
+}

testing-modules/mocks/src/main/java/org/baeldung/mocks/jmockit/Collaborator.java

@@ -0,0 +1,12 @@
+package org.baeldung.mocks.jmockit;
+
+public class Collaborator {
+
+	public boolean collaborate(String string){
+		return false;
+	}
+
+	public void receive(boolean bool){
+		//NOOP
+	}
+}

testing-modules/mocks/src/main/java/org/baeldung/mocks/jmockit/ExpectationsCollaborator.java

@@ -0,0 +1,19 @@
+package org.baeldung.mocks.jmockit;
+
+import java.util.List;
+
+public interface ExpectationsCollaborator {
+    String methodForAny1(String s, int i, Boolean b);
+    void methodForAny2(Long l,  List<String> lst);
+    String methodForWith1(String s, int i);
+    void methodForWith2(Boolean b, List<String> l);
+    String methodForNulls1(String s, List<String> l);
+    void methodForNulls2(String s, List<String> l);
+    void methodForTimes1();
+    void methodForTimes2();
+    void methodForTimes3();
+    void methodForArgThat(Object o);
+    String methodReturnsString();
+    int methodReturnsInt();
+    Object methodForDelegate(int i);
+}

testing-modules/mocks/src/main/java/org/baeldung/mocks/jmockit/Model.java

@@ -0,0 +1,7 @@
+package org.baeldung.mocks.jmockit;
+
+public class Model {
+    public String getInfo() {
+        return "info";
+    }
+}

testing-modules/mocks/src/main/java/org/baeldung/mocks/jmockit/Performer.java

@@ -0,0 +1,10 @@
+package org.baeldung.mocks.jmockit;
+
+public class Performer {
+	private Collaborator collaborator;
+	
+	public void perform(Model model){
+		boolean value = collaborator.collaborate(model.getInfo());
+		collaborator.receive(value);
+	}
+}

testing-modules/mocks/src/main/java/org/baeldung/mocks/testCase/LoginController.java

@@ -0,0 +1,29 @@
+package org.baeldung.mocks.testCase;
+
+public class LoginController {
+
+    public LoginService loginService;
+
+    public String login(UserForm userForm) {
+        if (null == userForm) {
+            return "ERROR";
+        } else {
+            boolean logged;
+
+            try {
+                logged = loginService.login(userForm);
+            } catch (Exception e) {
+                return "ERROR";
+            }
+
+            if (logged) {
+                loginService.setCurrentUser(userForm.getUsername());
+                return "OK";
+            } else {
+                return "KO";
+            }
+        }
+    }
+
+    // standard setters and getters
+}

testing-modules/mocks/src/main/java/org/baeldung/mocks/testCase/LoginDao.java

@@ -0,0 +1,9 @@
+package org.baeldung.mocks.testCase;
+
+public class LoginDao {
+
+    public int login(UserForm userForm) {
+        //actual call to a third party library
+        return 0;
+    }
+}

testing-modules/mocks/src/main/java/org/baeldung/mocks/testCase/LoginService.java

@@ -0,0 +1,33 @@
+package org.baeldung.mocks.testCase;
+
+public class LoginService {
+
+    private LoginDao loginDao;
+
+    private String currentUser;
+
+    public boolean login(UserForm userForm) {
+        assert null != userForm;
+
+        int loginResults = loginDao.login(userForm);
+
+        switch (loginResults) {
+            case 1:
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    public void setCurrentUser(String username) {
+        if (null != username) {
+            this.currentUser = username;
+        }
+    }
+
+    public void setLoginDao(LoginDao loginDao) {
+        this.loginDao = loginDao;
+    }
+
+    // standard setters and getters
+}

testing-modules/mocks/src/main/java/org/baeldung/mocks/testCase/UserForm.java

@@ -0,0 +1,15 @@
+package org.baeldung.mocks.testCase;
+
+public class UserForm {
+
+    // public access modifiers as only for testing
+
+    public String password;
+
+    public String username;
+
+    public String getUsername() {
+        return username;
+    }
+
+}

testing-modules/mocks/src/main/resources/logback.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
+            </pattern>
+        </encoder>
+    </appender>
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT" />
+    </root>
+</configuration>

testing-modules/mocks/src/test/java/com/baeldung/easymock/ArgumentMatchersUnitTest.java

@@ -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;
+    }
+}
+
+

testing-modules/mocks/src/test/java/com/baeldung/easymock/BaeldungReaderAnnotatedUnitTest.java

@@ -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);
+    }
+
+}
+

testing-modules/mocks/src/test/java/com/baeldung/easymock/BaeldungReaderAnnotatedWithRuleUnitTest.java

@@ -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);
+    }
+
+}
+

testing-modules/mocks/src/test/java/com/baeldung/easymock/BaeldungReaderMockDelegationUnitTest.java

@@ -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();
+    }
+
+}

testing-modules/mocks/src/test/java/com/baeldung/easymock/BaeldungReaderMockSupportUnitTest.java

@@ -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);
+    }
+
+}

testing-modules/mocks/src/test/java/com/baeldung/easymock/BaeldungReaderUnitTest.java

@@ -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);
+    }
+
+}

testing-modules/mocks/src/test/java/com/baeldung/introductionjukito/CalculatorUnitTest.java

@@ -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);
+    }
+}

testing-modules/mocks/src/test/java/com/baeldung/javafaker/JavaFakerUnitTest.java

@@ -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"));
+
+    }
+}

testing-modules/mocks/src/test/java/com/baeldung/jimfs/FileManipulationUnitTest.java

@@ -0,0 +1,39 @@
+package com.baeldung.jimfs;
+
+import com.google.common.jimfs.Configuration;
+import com.google.common.jimfs.Jimfs;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import java.nio.file.FileSystem;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class FileManipulationUnitTest implements FileTestProvider {
+
+    private final FileManipulation fileManipulation = new FileManipulation();
+
+    private static Stream<Arguments> provideFileSystem() {
+        return Stream.of(Arguments.of(Jimfs.newFileSystem(Configuration.unix())), Arguments.of(Jimfs.newFileSystem(Configuration.windows())), Arguments.of(Jimfs.newFileSystem(Configuration.osX())));
+    }
+
+    @ParameterizedTest
+    @DisplayName("Should move file to new destination")
+    @MethodSource("provideFileSystem")
+    void givenEachSystem_whenMovingFile_thenMovedToNewPath(final FileSystem fileSystem) throws Exception {
+        final Path origin = fileSystem.getPath(RESOURCE_FILE_NAME);
+        Files.copy(getResourceFilePath(), origin);
+        final Path destination = fileSystem.getPath("newDirectory", RESOURCE_FILE_NAME);
+
+        fileManipulation.move(origin, destination);
+
+        assertFalse(Files.exists(origin));
+        assertTrue(Files.exists(destination));
+    }
+}

testing-modules/mocks/src/test/java/com/baeldung/jimfs/FilePathReaderUnitTest.java

@@ -0,0 +1,48 @@
+package com.baeldung.jimfs;
+
+import com.google.common.jimfs.Configuration;
+import com.google.common.jimfs.Jimfs;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.nio.file.FileSystem;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class FilePathReaderUnitTest {
+
+    private static final String DIRECTORY_NAME = "baeldung";
+
+    private final FilePathReader filePathReader = new FilePathReader();
+
+    @Test
+    @DisplayName("Should get path on windows")
+    void givenWindowsSystem_shouldGetPath_thenReturnWindowsPath() throws Exception {
+        final FileSystem fileSystem = Jimfs.newFileSystem(Configuration.windows());
+        final Path path = getPathToFile(fileSystem);
+
+        final String stringPath = filePathReader.getSystemPath(path);
+
+        assertEquals("C:\\work\\" + DIRECTORY_NAME, stringPath);
+    }
+
+    @Test
+    @DisplayName("Should get path on unix")
+    void givenUnixSystem_shouldGetPath_thenReturnUnixPath() throws Exception {
+        final FileSystem fileSystem = Jimfs.newFileSystem(Configuration.unix());
+        final Path path = getPathToFile(fileSystem);
+
+        final String stringPath = filePathReader.getSystemPath(path);
+
+        assertEquals("/work/" + DIRECTORY_NAME, stringPath);
+    }
+
+    private Path getPathToFile(final FileSystem fileSystem) throws Exception {
+        final Path path = fileSystem.getPath(DIRECTORY_NAME);
+        Files.createDirectory(path);
+
+        return path;
+    }
+}

testing-modules/mocks/src/test/java/com/baeldung/jimfs/FileRepositoryUnitTest.java

@@ -0,0 +1,67 @@
+package com.baeldung.jimfs;
+
+import com.google.common.jimfs.Configuration;
+import com.google.common.jimfs.Jimfs;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.nio.file.FileSystem;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class FileRepositoryUnitTest implements FileTestProvider {
+
+    private final FileRepository fileRepository = new FileRepository();
+
+    @Test
+    @DisplayName("Should create a file on a file system")
+    void givenUnixSystem_whenCreatingFile_thenCreatedInPath() {
+        final FileSystem fileSystem = Jimfs.newFileSystem(Configuration.unix());
+        final String fileName = "newFile.txt";
+        final Path pathToStore = fileSystem.getPath("");
+
+        fileRepository.create(pathToStore, fileName);
+
+        assertTrue(Files.exists(pathToStore.resolve(fileName)));
+    }
+
+    @Test
+    @DisplayName("Should read the content of the file")
+    void givenOSXSystem_whenReadingFile_thenContentIsReturned() throws Exception {
+        final FileSystem fileSystem = Jimfs.newFileSystem(Configuration.osX());
+        final Path resourceFilePath = fileSystem.getPath(RESOURCE_FILE_NAME);
+        Files.copy(getResourceFilePath(), resourceFilePath);
+
+        final String content = fileRepository.read(resourceFilePath);
+
+        assertEquals(FILE_CONTENT, content);
+    }
+
+    @Test
+    @DisplayName("Should update the content of the file")
+    void givenWindowsSystem_whenUpdatingFile_thenContentHasChanged() throws Exception {
+        final FileSystem fileSystem = Jimfs.newFileSystem(Configuration.windows());
+        final Path resourceFilePath = fileSystem.getPath(RESOURCE_FILE_NAME);
+        Files.copy(getResourceFilePath(), resourceFilePath);
+        final String newContent = "I'm updating you.";
+
+        final String content = fileRepository.update(resourceFilePath, newContent);
+
+        assertEquals(newContent, content);
+        assertEquals(newContent, fileRepository.read(resourceFilePath));
+    }
+
+    @Test
+    @DisplayName("Should delete file")
+    void givenCurrentSystem_whenDeletingFile_thenFileHasBeenDeleted() throws Exception {
+        final FileSystem fileSystem = Jimfs.newFileSystem();
+        final Path resourceFilePath = fileSystem.getPath(RESOURCE_FILE_NAME);
+        Files.copy(getResourceFilePath(), resourceFilePath);
+
+        fileRepository.delete(resourceFilePath);
+
+        assertFalse(Files.exists(resourceFilePath));
+    }
+}

testing-modules/mocks/src/test/java/com/baeldung/jimfs/FileTestProvider.java

@@ -0,0 +1,16 @@
+package com.baeldung.jimfs;
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+public interface FileTestProvider {
+    String FILE_CONTENT = "I'm the file content.";
+    String RESOURCE_FILE_NAME = "fileRepositoryRead.txt";
+
+    default Path getResourceFilePath() {
+        final String resourceFilePath = getClass()
+          .getResource("/" + RESOURCE_FILE_NAME)
+          .getPath();
+        return Paths.get(resourceFilePath);
+    }
+}

testing-modules/mocks/src/test/java/com/baeldung/mocks/jmockit/AppManagerUnitTest.java

@@ -0,0 +1,31 @@
+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?"));
+    }
+}

testing-modules/mocks/src/test/java/org/baeldung/mocks/easymock/LoginControllerIntegrationTest.java

@@ -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);
+    }
+}

testing-modules/mocks/src/test/java/org/baeldung/mocks/jmockit/AdvancedCollaboratorIntegrationTest.java

@@ -0,0 +1,90 @@
+package org.baeldung.mocks.jmockit;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.ArrayList;
+import java.util.List;
+
+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 testToSetPrivateFieldDirectly() {
+        Deencapsulation.setField(mock, "privateField", 10);
+        assertEquals(10, mock.methodThatReturnsThePrivateField());
+    }
+
+    @Test
+    public void testToGetPrivateFieldDirectly() {
+        int value = Deencapsulation.getField(mock, "privateField");
+        assertEquals(5, value);
+    }
+
+    @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<>()));
+    }
+}

testing-modules/mocks/src/test/java/org/baeldung/mocks/jmockit/ExpectationsIntegrationTest.java

@@ -0,0 +1,157 @@
+package org.baeldung.mocks.jmockit;
+
+import mockit.Delegate;
+import mockit.Expectations;
+import mockit.Mocked;
+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 Expectations() {{
+            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) {
+        }
+    }
+}

testing-modules/mocks/src/test/java/org/baeldung/mocks/jmockit/LoginControllerIntegrationTest.java

@@ -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) {
+        };
+    }
+}

testing-modules/mocks/src/test/java/org/baeldung/mocks/jmockit/PerformerIntegrationTest.java

@@ -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);
+    	}};
+    }
+
+}

testing-modules/mocks/src/test/java/org/baeldung/mocks/jmockit/ReusingIntegrationTest.java

@@ -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);
+    }
+}

testing-modules/mocks/src/test/java/org/baeldung/mocks/mockito/LoginControllerIntegrationTest.java

@@ -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");
+    }
+}

testing-modules/mocks/src/test/resources/fileRepositoryRead.txt

@@ -0,0 +1 @@
+I'm the file content.