Spark graphx moved to a new project due to a incompatibility of scala compiler

testing-modules/mockito-2/src/main/java/com/baeldung/mockito/java8/JobPosition.java

@@ -0,0 +1,20 @@
+package com.baeldung.mockito.java8;
+
+public class JobPosition {
+    private String title;
+    
+    public JobPosition() {}
+    
+    public JobPosition(String title) {
+        super();
+        this.title = title;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title = title;
+    }
+}

testing-modules/mockito-2/src/main/java/com/baeldung/mockito/java8/JobService.java

@@ -0,0 +1,20 @@
+package com.baeldung.mockito.java8;
+
+import java.util.Optional;
+import java.util.stream.Stream;
+
+public interface JobService {
+    Optional<JobPosition> findCurrentJobPosition(Person person);
+
+    default boolean assignJobPosition(Person person, JobPosition jobPosition) {
+        if (!findCurrentJobPosition(person).isPresent()) {
+            person.setCurrentJobPosition(jobPosition);
+
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    Stream<JobPosition> listJobs(Person person);
+}

testing-modules/mockito-2/src/main/java/com/baeldung/mockito/java8/Person.java

@@ -0,0 +1,28 @@
+package com.baeldung.mockito.java8;
+
+public class Person {
+    private String name;
+    private JobPosition currentJobPosition;
+    
+    public Person() {}
+    
+    public Person(String name) {
+        this.name = name;
+    }
+
+    public JobPosition getCurrentJobPosition() {
+        return currentJobPosition;
+    }
+
+    public void setCurrentJobPosition(JobPosition currentJobPosition) {
+        this.currentJobPosition = currentJobPosition;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+}

testing-modules/mockito-2/src/main/java/com/baeldung/mockito/java8/UnemploymentService.java

@@ -0,0 +1,11 @@
+package com.baeldung.mockito.java8;
+
+import java.util.Optional;
+
+public interface UnemploymentService {
+
+    boolean personIsEntitledToUnemploymentSupport(Person person);
+
+    Optional<JobPosition> searchJob(Person person, String searchString); 
+
+}

testing-modules/mockito-2/src/main/java/com/baeldung/mockito/java8/UnemploymentServiceImpl.java

@@ -0,0 +1,26 @@
+package com.baeldung.mockito.java8;
+
+import java.util.Optional;
+import java.util.stream.Stream;
+
+public class UnemploymentServiceImpl implements UnemploymentService {
+    private final JobService jobService;
+    
+    public UnemploymentServiceImpl(JobService jobService) {
+        this.jobService = jobService;
+    }
+
+    @Override
+    public boolean personIsEntitledToUnemploymentSupport(Person person) {
+        Optional<JobPosition> optional = jobService.findCurrentJobPosition(person);
+        
+        return !optional.isPresent();
+    }
+
+    @Override
+    public Optional<JobPosition> searchJob(Person person, String searchString) {
+        Stream<JobPosition> stream = jobService.listJobs(person);
+        
+        return stream.filter((j) -> j.getTitle().contains(searchString)).findFirst();
+    }
+}

testing-modules/mockito-2/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/mockito-2/src/test/java/com/baeldung/mockito/bddmockito/BDDMockitoUnitTest.java

@@ -0,0 +1,104 @@
+package com.baeldung.mockito.bddmockito;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.mockito.invocation.InvocationOnMock;
+
+import static org.junit.Assert.fail;
+import static org.mockito.BDDMockito.*;
+
+
+public class BDDMockitoUnitTest {
+    
+    PhoneBookService phoneBookService;
+    PhoneBookRepository phoneBookRepository;
+    
+    String momContactName = "Mom";
+    String momPhoneNumber = "01234";
+    String xContactName = "x";
+    String tooLongPhoneNumber = "01111111111111";
+    
+    @Before
+    public void init() {
+        phoneBookRepository = Mockito.mock(PhoneBookRepository.class);
+        phoneBookService = new PhoneBookService(phoneBookRepository);
+    }
+    
+    @Test
+    public void givenValidContactName_whenSearchInPhoneBook_thenRetunPhoneNumber() {
+        given(phoneBookRepository.contains(momContactName)).willReturn(true);
+        given(phoneBookRepository.getPhoneNumberByContactName(momContactName))
+          .will((InvocationOnMock invocation) -> {
+            if(invocation.getArgument(0).equals(momContactName)) {
+                return momPhoneNumber;
+            } else {
+                return null;
+            }
+        });
+        
+        String phoneNumber = phoneBookService.search(momContactName);
+        
+        then(phoneBookRepository).should().contains(momContactName);
+        then(phoneBookRepository).should().getPhoneNumberByContactName(momContactName);
+        Assert.assertEquals(phoneNumber, momPhoneNumber);
+    }
+    
+    @Test
+    public void givenInvalidContactName_whenSearch_thenRetunNull() {
+        given(phoneBookRepository.contains(xContactName)).willReturn(false);
+        
+        String phoneNumber = phoneBookService.search(xContactName);
+        
+        then(phoneBookRepository).should().contains(xContactName);
+        then(phoneBookRepository).should(never()).getPhoneNumberByContactName(xContactName);
+        Assert.assertEquals(phoneNumber, null);
+    }
+    
+    @Test
+    public void givenValidContactNameAndPhoneNumber_whenRegister_thenSucceed() {
+        given(phoneBookRepository.contains(momContactName)).willReturn(false);
+        
+        phoneBookService.register(momContactName, momPhoneNumber);
+        
+        verify(phoneBookRepository).insert(momContactName, momPhoneNumber);
+    }
+    
+    @Test
+    public void givenEmptyPhoneNumber_whenRegister_thenFail() {
+        given(phoneBookRepository.contains(momContactName)).willReturn(false);
+        
+        phoneBookService.register(xContactName, "");
+        
+        then(phoneBookRepository).should(never()).insert(momContactName, momPhoneNumber);
+    }
+    
+    @Test
+    public void givenLongPhoneNumber_whenRegister_thenFail() {
+        given(phoneBookRepository.contains(xContactName)).willReturn(false);
+        willThrow(new RuntimeException())
+          .given(phoneBookRepository).insert(any(String.class), eq(tooLongPhoneNumber));
+        
+        try {
+            phoneBookService.register(xContactName, tooLongPhoneNumber);
+            fail("Should throw exception");
+        } catch (RuntimeException ex) { }
+        
+        then(phoneBookRepository).should(never()).insert(momContactName, tooLongPhoneNumber);
+    }
+    
+    @Test
+    public void givenExistentContactName_whenRegister_thenFail() {
+        given(phoneBookRepository.contains(momContactName))
+          .willThrow(new RuntimeException("Name already exist"));
+        
+        try {
+            phoneBookService.register(momContactName, momPhoneNumber);
+            fail("Should throw exception");
+        } catch(Exception ex) { }
+        
+        then(phoneBookRepository).should(never()).insert(momContactName, momPhoneNumber);
+    }
+
+}

testing-modules/mockito-2/src/test/java/com/baeldung/mockito/bddmockito/PhoneBookRepository.java

@@ -0,0 +1,26 @@
+package com.baeldung.mockito.bddmockito;
+
+public interface PhoneBookRepository {
+
+	/**
+	 * Insert phone record
+	 * @param name Contact name
+	 * @param phone Phone number
+	 */
+    void insert(String name, String phone);
+    
+    /**
+     * Search for contact phone number
+     * @param name Contact name
+     * @return phone number
+     */
+    String getPhoneNumberByContactName(String name);
+    
+    /**
+     * Check if the phonebook contains this contact
+     * @param name Contact name
+     * @return true if this contact name exists
+     */
+    boolean contains(String name);
+    
+}

testing-modules/mockito-2/src/test/java/com/baeldung/mockito/bddmockito/PhoneBookService.java

@@ -0,0 +1,34 @@
+package com.baeldung.mockito.bddmockito;
+
+public class PhoneBookService {
+    
+    private PhoneBookRepository phoneBookRepository;
+    
+    public PhoneBookService(PhoneBookRepository phoneBookRepository) {
+        this.phoneBookRepository = phoneBookRepository;
+    }
+
+    /**
+     * Register a contact
+     * @param name Contact name
+     * @param phone Phone number
+     */
+    public void register(String name, String phone) {
+        if(!name.isEmpty() && !phone.isEmpty() && !phoneBookRepository.contains(name)) {
+            phoneBookRepository.insert(name, phone);
+        }
+    }
+    
+    /**
+     * Search for a phone number by contact name
+     * @param name Contact name
+     * @return Phone number
+     */
+    public String search(String name) {
+        if(!name.isEmpty() && phoneBookRepository.contains(name)) {
+            return phoneBookRepository.getPhoneNumberByContactName(name);
+        }
+        return null;
+    }
+    
+}

testing-modules/mockito-2/src/test/java/com/baeldung/mockito/java8/ArgumentMatcherWithLambdaUnitTest.java

@@ -0,0 +1,44 @@
+package com.baeldung.mockito.java8;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.when;
+
+import java.util.Optional;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.ArgumentMatchers;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+
+public class ArgumentMatcherWithLambdaUnitTest {
+
+    @InjectMocks
+    private UnemploymentServiceImpl unemploymentService;
+    
+    @Mock
+    private JobService jobService;
+
+    @Test
+    public void whenPersonWithJob_thenIsNotEntitled() {
+        Person peter = new Person("Peter");
+        Person linda = new Person("Linda");
+        
+        JobPosition teacher = new JobPosition("Teacher");
+
+        when(jobService.findCurrentJobPosition(
+                ArgumentMatchers.argThat((p) -> p.getName().equals("Peter")))
+             ).thenReturn(Optional.of(teacher));
+        
+        assertTrue(unemploymentService.personIsEntitledToUnemploymentSupport(linda));
+        assertFalse(unemploymentService.personIsEntitledToUnemploymentSupport(peter));
+    }
+
+    @Before
+    public void init() {
+        MockitoAnnotations.initMocks(this);
+    }
+}

testing-modules/mockito-2/src/test/java/com/baeldung/mockito/java8/ArgumentMatcherWithoutLambdaUnitTest.java

@@ -0,0 +1,51 @@
+package com.baeldung.mockito.java8;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.*;
+
+import java.util.Optional;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.when;
+
+
+public class ArgumentMatcherWithoutLambdaUnitTest {
+
+    private class PeterArgumentMatcher implements ArgumentMatcher<Person> {
+
+        @Override
+        public boolean matches(Person p) {
+            return p
+              .getName()
+              .equals("Peter");
+        }
+    }
+
+    @InjectMocks
+    private UnemploymentServiceImpl unemploymentService;
+    
+    @Mock
+    private JobService jobService;
+
+    @Test
+    public void whenPersonWithJob_thenIsNotEntitled() {
+        Person peter = new Person("Peter");
+        Person linda = new Person("Linda");
+        
+        JobPosition teacher = new JobPosition("Teacher");
+
+        when(jobService.findCurrentJobPosition(
+                ArgumentMatchers.argThat(new PeterArgumentMatcher()))
+             ).thenReturn(Optional.of(teacher));
+        
+        assertTrue(unemploymentService.personIsEntitledToUnemploymentSupport(linda));
+        assertFalse(unemploymentService.personIsEntitledToUnemploymentSupport(peter));
+    }
+
+    @Before
+    public void init() {
+        MockitoAnnotations.initMocks(this);
+    }
+}

testing-modules/mockito-2/src/test/java/com/baeldung/mockito/java8/CustomAnswerWithLambdaUnitTest.java

@@ -0,0 +1,46 @@
+package com.baeldung.mockito.java8;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+import java.util.stream.Stream;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.when;
+
+public class CustomAnswerWithLambdaUnitTest {
+
+    @InjectMocks
+    private UnemploymentServiceImpl unemploymentService;
+
+    @Mock
+    private JobService jobService;
+
+    @Test
+    public void whenPersonWithJobHistory_thenSearchReturnsValue() {
+        Person peter = new Person("Peter");
+
+        assertEquals("Teacher", unemploymentService.searchJob(peter, "").get().getTitle());
+    }
+
+    @Test
+    public void whenPersonWithNoJobHistory_thenSearchReturnsEmpty() {
+        Person linda = new Person("Linda");
+
+        assertFalse(unemploymentService.searchJob(linda, "").isPresent());
+    }
+
+    @Before
+    public void init() {
+        MockitoAnnotations.initMocks(this);
+
+        when(jobService.listJobs(any(Person.class))).then((i) ->
+          Stream.of(new JobPosition("Teacher"))
+          .filter(p -> ((Person) i.getArgument(0)).getName().equals("Peter")));
+    }
+}

testing-modules/mockito-2/src/test/java/com/baeldung/mockito/java8/CustomAnswerWithoutLambdaUnitTest.java

@@ -0,0 +1,61 @@
+package com.baeldung.mockito.java8;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+
+import java.util.stream.Stream;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.when;
+
+
+public class CustomAnswerWithoutLambdaUnitTest {
+    
+    private class PersonAnswer implements Answer<Stream<JobPosition>> {
+
+        @Override
+        public Stream<JobPosition> answer(InvocationOnMock invocation) throws Throwable {
+            Person person = invocation.getArgument(0);
+            
+            if(person.getName().equals("Peter")) {
+                return Stream.<JobPosition>builder().add(new JobPosition("Teacher")).build();
+            } 
+            
+            return Stream.empty();
+        }
+    }
+    
+    @InjectMocks
+    private UnemploymentServiceImpl unemploymentService;
+    
+    @Mock
+    private JobService jobService;
+
+    @Test
+    public void whenPersonWithJobHistory_thenSearchReturnsValue() {
+        Person peter = new Person("Peter");
+        
+        assertEquals("Teacher", unemploymentService.searchJob(peter, "").get().getTitle());
+    }
+
+    @Test
+    public void whenPersonWithNoJobHistory_thenSearchReturnsEmpty() {
+        Person linda = new Person("Linda");
+
+        assertFalse(unemploymentService.searchJob(linda, "").isPresent());
+    }
+
+    @Before
+    public void init() {
+        MockitoAnnotations.initMocks(this);
+        
+        when(jobService.listJobs(any(Person.class))).then(new PersonAnswer());
+    }
+}

testing-modules/mockito-2/src/test/java/com/baeldung/mockito/java8/JobServiceUnitTest.java

@@ -0,0 +1,44 @@
+package com.baeldung.mockito.java8;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.doCallRealMethod;
+import static org.mockito.Mockito.when;
+
+import java.util.Optional;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+
+public class JobServiceUnitTest {
+    @Mock
+    private JobService jobService;
+
+    @Test
+    public void givenDefaultMethod_whenCallRealMethod_thenNoExceptionIsRaised() {
+        Person person = new Person();
+
+        when(jobService.findCurrentJobPosition(person)).thenReturn(Optional.of(new JobPosition()));
+        doCallRealMethod().when(jobService).assignJobPosition(Mockito.any(Person.class), Mockito.any(JobPosition.class));
+
+        assertFalse(jobService.assignJobPosition(person, new JobPosition()));
+    }
+
+    @Test
+    public void givenReturnIsOfTypeOptional_whenDefaultValueIsReturned_thenValueIsEmpty() {
+        Person person = new Person();
+
+        when(jobService.findCurrentJobPosition(person)).thenReturn(Optional.empty());
+        doCallRealMethod().when(jobService).assignJobPosition(Mockito.any(Person.class), Mockito.any(JobPosition.class));
+
+        assertTrue(jobService.assignJobPosition(person, new JobPosition()));
+    }
+
+    @Before
+    public void init() {
+        MockitoAnnotations.initMocks(this);
+    }
+}

testing-modules/mockito-2/src/test/java/com/baeldung/mockito/java8/UnemploymentServiceImplUnitTest.java

@@ -0,0 +1,62 @@
+package com.baeldung.mockito.java8;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.when;
+
+import java.util.Optional;
+import java.util.stream.Stream;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+public class UnemploymentServiceImplUnitTest {
+    @Mock
+    private JobService jobService;
+
+    @InjectMocks
+    private UnemploymentServiceImpl unemploymentService;
+
+    @Test
+    public void givenReturnIsOfTypeOptional_whenMocked_thenValueIsEmpty() {
+        Person person = new Person();
+
+        when(jobService.findCurrentJobPosition(any(Person.class))).thenReturn(Optional.empty());
+
+        assertTrue(unemploymentService.personIsEntitledToUnemploymentSupport(person));
+    }
+
+    @Test
+    public void givenReturnIsOfTypeOptional_whenDefaultValueIsReturned_thenValueIsEmpty() {
+        Person person = new Person();
+
+        // This will fail when Mockito 1 is used
+        assertTrue(unemploymentService.personIsEntitledToUnemploymentSupport(person));
+    }
+
+    @Test
+    public void givenReturnIsOfTypeStream_whenMocked_thenValueIsEmpty() {
+        Person person = new Person();
+
+        when(jobService.listJobs(any(Person.class))).thenReturn(Stream.empty());
+
+        assertFalse(unemploymentService.searchJob(person, "").isPresent());
+    }
+
+    @Test
+    public void givenReturnIsOfTypeStream_whenDefaultValueIsReturned_thenValueIsEmpty() {
+        Person person = new Person();
+
+        // This will fail when Mockito 1 is used
+        assertFalse(unemploymentService.searchJob(person, "").isPresent());
+    }
+
+    @Before
+    public void init() {
+        MockitoAnnotations.initMocks(this);
+    }
+}

testing-modules/mockito-2/src/test/java/com/baeldung/mockito/lazyverification/LazyVerificationUnitTest.java

@@ -0,0 +1,34 @@
+package com.baeldung.mockito.lazyverification;
+
+import org.junit.Test;
+import org.mockito.exceptions.base.MockitoAssertionError;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.VerificationCollector;
+
+import java.util.List;
+
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+public class LazyVerificationUnitTest {
+
+    @Test
+    public void whenLazilyVerified_thenReportsMultipleFailures() {
+        VerificationCollector collector = MockitoJUnit.collector()
+            .assertLazily();
+
+        List mockList = mock(List.class);
+        verify(mockList).add("one");
+        verify(mockList).clear();
+
+        try {
+            collector.collectAndReport();
+        } catch (MockitoAssertionError error) {
+            assertTrue(error.getMessage()
+                .contains("1. Wanted but not invoked:"));
+            assertTrue(error.getMessage()
+                .contains("2. Wanted but not invoked:"));
+        }
+    }
+}

testing-modules/mockito-2/src/test/java/com/baeldung/mockito/misusing/ExpectedTestFailureRule.java

@@ -0,0 +1,51 @@
+package com.baeldung.mockito.misusing;
+
+import org.hamcrest.Matchers;
+import org.junit.Assert;
+import org.junit.rules.MethodRule;
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.Statement;
+
+public class ExpectedTestFailureRule implements MethodRule {
+
+    private final MethodRule testedRule;
+    private FailureAssert failureAssert = null;
+
+    public ExpectedTestFailureRule(MethodRule testedRule) {
+        this.testedRule = testedRule;
+    }
+
+    @Override
+    public Statement apply(final Statement base, final FrameworkMethod method, final Object target) {
+        return new Statement() {
+            public void evaluate() throws Throwable {
+                try {
+                    testedRule.apply(base, method, target)
+                        .evaluate();
+                } catch (Throwable t) {
+                    if (failureAssert == null) {
+                        throw t;
+                    }
+                    failureAssert.doAssert(t);
+                    return;
+                }
+            }
+        };
+    }
+
+    @SuppressWarnings("unchecked")
+    public void expectedFailure(final Class<? extends Throwable> expected) {
+        FailureAssert assertion = t -> Assert.assertThat(t, Matchers.isA((Class<Throwable>) expected));
+        this.expectedFailure(assertion);
+    }
+
+    private void expectedFailure(FailureAssert failureAssert) {
+        this.failureAssert = failureAssert;
+    }
+
+    @FunctionalInterface
+    private interface FailureAssert {
+        abstract void doAssert(Throwable t);
+    }
+
+}

testing-modules/mockito-2/src/test/java/com/baeldung/mockito/misusing/MockitoUnecessaryStubUnitTest.java

@@ -0,0 +1,52 @@
+package com.baeldung.mockito.misusing;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.Mockito.lenient;
+import static org.mockito.Mockito.when;
+
+import java.util.ArrayList;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.mockito.exceptions.misusing.UnnecessaryStubbingException;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.quality.Strictness;
+
+public class MockitoUnecessaryStubUnitTest {
+
+    @Rule
+    public ExpectedTestFailureRule rule = new ExpectedTestFailureRule(MockitoJUnit.rule()
+        .strictness(Strictness.STRICT_STUBS));
+
+    @Mock
+    private ArrayList<String> mockList;
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+    }
+
+    @Test
+    public void givenUnusedStub_whenInvokingGetThenThrowUnnecessaryStubbingException() {
+        rule.expectedFailure(UnnecessaryStubbingException.class);
+
+        when(mockList.add("one")).thenReturn(true);
+        when(mockList.get(anyInt())).thenReturn("hello");
+
+        assertEquals("List should contain hello", "hello", mockList.get(1));
+    }
+
+    @Test
+    public void givenLenientdStub_whenInvokingGetThenDontThrowUnnecessaryStubbingException() {
+        lenient().when(mockList.add("one"))
+            .thenReturn(true);
+        when(mockList.get(anyInt())).thenReturn("hello");
+
+        assertEquals("List should contain hello", "hello", mockList.get(1));
+    }
+
+}

testing-modules/mockito-2/src/test/java/com/baeldung/mockito/spy/MockitoMisusingUnitTest.java

@@ -0,0 +1,38 @@
+package com.baeldung.mockito.spy;
+
+import org.junit.After;
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.mockito.exceptions.misusing.NotAMockException;
+import org.mockito.internal.progress.ThreadSafeMockingProgress;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.junit.Assert.assertThat;
+import static org.junit.jupiter.api.Assertions.fail;
+
+public class MockitoMisusingUnitTest {
+
+    @After
+    public void tearDown() {
+        ThreadSafeMockingProgress.mockingProgress().reset();
+    }
+    
+    @Test
+    public void givenNotASpy_whenDoReturn_thenThrowNotAMock() {
+        try {
+            List<String> list = new ArrayList<String>();
+
+            Mockito.doReturn(100, Mockito.withSettings().lenient())
+                .when(list)
+                .size();
+
+            fail("Should have thrown a NotAMockException because 'list' is not a mock!");
+        } catch (NotAMockException e) {
+            assertThat(e.getMessage(), containsString("Argument passed to when() is not a mock!"));
+        }
+    }
+
+}

testing-modules/mockito-2/src/test/java/com/baeldung/mockito/spy/MockitoSpyUnitTest.java

@@ -0,0 +1,76 @@
+package com.baeldung.mockito.spy;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mockito;
+import org.mockito.Spy;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+@RunWith(MockitoJUnitRunner.class)
+public class MockitoSpyUnitTest {
+
+    @Spy
+    private List<String> aSpyList = new ArrayList<String>();
+
+    @Test
+    public void whenSpyingOnList_thenCorrect() {
+        final List<String> list = new ArrayList<String>();
+        final List<String> spyList = Mockito.spy(list);
+
+        spyList.add("one");
+        spyList.add("two");
+
+        Mockito.verify(spyList).add("one");
+        Mockito.verify(spyList).add("two");
+
+        assertEquals(2, spyList.size());
+    }
+
+    @Test
+    public void whenUsingTheSpyAnnotation_thenObjectIsSpied() {
+        aSpyList.add("one");
+        aSpyList.add("two");
+
+        Mockito.verify(aSpyList).add("one");
+        Mockito.verify(aSpyList).add("two");
+
+        assertEquals(2, aSpyList.size());
+    }
+
+    @Test
+    public void whenStubASpy_thenStubbed() {
+        final List<String> list = new ArrayList<String>();
+        final List<String> spyList = Mockito.spy(list);
+
+        assertEquals(0, spyList.size());
+
+        Mockito.doReturn(100).when(spyList).size();
+        assertEquals(100, spyList.size());
+    }
+
+    @Test
+    public void whenCreateMock_thenCreated() {
+        final List<String> mockedList = Mockito.mock(ArrayList.class);
+
+        mockedList.add("one");
+        Mockito.verify(mockedList).add("one");
+
+        assertEquals(0, mockedList.size());
+    }
+
+    @Test
+    public void whenCreateSpy_thenCreate() {
+        final List<String> spyList = Mockito.spy(new ArrayList<String>());
+
+        spyList.add("one");
+        Mockito.verify(spyList).add("one");
+
+        assertEquals(1, spyList.size());
+    }
+
+}