Merge pull request #8125 from eugenp/revert-8119-BAEL-3275-2

Revert "BAEL-3275: Using blocking queue for pub-sub"

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