Home | History | Annotate | Download | only in defaultanswers 
      1 /*
      2  * Copyright (c) 2007 Mockito contributors
      3  * This program is made available under the terms of the MIT License.
      4  */
      5 
      6 package org.mockito.internal.stubbing.defaultanswers;
      7 
      8 import org.junit.Assume;
      9 import org.junit.Test;
     10 import org.mockito.invocation.Invocation;
     11 import org.mockitoutil.TestBase;
     12 
     13 import java.util.*;
     14 
     15 import static org.junit.Assert.*;
     16 import static org.mockito.Mockito.mock;
     17 
     18 public class ReturnsEmptyValuesTest extends TestBase {
     19 
     20     private final ReturnsEmptyValues values = new ReturnsEmptyValues();
     21 
     22     @Test
     23     public void should_return_empty_collections_or_null_for_non_collections() {
     24         assertTrue(((Collection<?>) values.returnValueFor(Collection.class)).isEmpty());
     25 
     26         assertTrue(((Set<?>) values.returnValueFor(Set.class)).isEmpty());
     27         assertTrue(((SortedSet<?>) values.returnValueFor(SortedSet.class)).isEmpty());
     28         assertTrue(((HashSet<?>) values.returnValueFor(HashSet.class)).isEmpty());
     29         assertTrue(((TreeSet<?>) values.returnValueFor(TreeSet.class)).isEmpty());
     30         assertTrue(((LinkedHashSet<?>) values.returnValueFor(LinkedHashSet.class)).isEmpty());
     31 
     32         assertTrue(((List<?>) values.returnValueFor(List.class)).isEmpty());
     33         assertTrue(((ArrayList<?>) values.returnValueFor(ArrayList.class)).isEmpty());
     34         assertTrue(((LinkedList<?>) values.returnValueFor(LinkedList.class)).isEmpty());
     35 
     36         assertTrue(((Map<?, ?>) values.returnValueFor(Map.class)).isEmpty());
     37         assertTrue(((SortedMap<?, ?>) values.returnValueFor(SortedMap.class)).isEmpty());
     38         assertTrue(((HashMap<?, ?>) values.returnValueFor(HashMap.class)).isEmpty());
     39         assertTrue(((TreeMap<?, ?>) values.returnValueFor(TreeMap.class)).isEmpty());
     40         assertTrue(((LinkedHashMap<?, ?>) values.returnValueFor(LinkedHashMap.class)).isEmpty());
     41 
     42         assertNull(values.returnValueFor(String.class));
     43     }
     44 
     45     @Test
     46     public void should_return_empty_iterable() throws Exception {
     47         assertFalse(((Iterable<?>) values.returnValueFor(Iterable.class)).iterator().hasNext());
     48     }
     49 
     50     @Test
     51     public void should_return_primitive() {
     52         assertEquals(false, values.returnValueFor(Boolean.TYPE));
     53         assertEquals((char) 0, values.returnValueFor(Character.TYPE));
     54         assertEquals((byte) 0, values.returnValueFor(Byte.TYPE));
     55         assertEquals((short) 0, values.returnValueFor(Short.TYPE));
     56         assertEquals(0, values.returnValueFor(Integer.TYPE));
     57         assertEquals(0L, values.returnValueFor(Long.TYPE));
     58         assertEquals(0F, values.returnValueFor(Float.TYPE));
     59         assertEquals(0D, values.returnValueFor(Double.TYPE));
     60     }
     61 
     62     @Test
     63     public void should_return_non_zero_for_compareTo_method() {
     64         //
     65         // given
     66         Date d = mock(Date.class);
     67         d.compareTo(new Date());
     68         Invocation compareTo = this.getLastInvocation();
     69 
     70         //when
     71         Object result = values.answer(compareTo);
     72 
     73         //then
     74         assertTrue(result != (Object) 0);
     75     }
     76 
     77     @Test
     78     public void should_return_zero_if_mock_is_compared_to_itself() {
     79         //given
     80         Date d = mock(Date.class);
     81         d.compareTo(d);
     82         Invocation compareTo = this.getLastInvocation();
     83 
     84         //when
     85         Object result = values.answer(compareTo);
     86 
     87         //then
     88         assertEquals(0, result);
     89     }
     90 
     91     @Test
     92     public void should_return_empty_Optional() throws Exception {
     93         verify_empty_Optional_is_returned("java.util.stream.Stream", "java.util.Optional");
     94     }
     95 
     96     @Test
     97     public void should_return_empty_OptionalDouble() throws Exception {
     98         verify_empty_Optional_is_returned("java.util.stream.DoubleStream", "java.util.OptionalDouble");
     99     }
    100 
    101     @Test
    102     public void should_return_empty_OptionalInt() throws Exception {
    103         verify_empty_Optional_is_returned("java.util.stream.IntStream", "java.util.OptionalInt");
    104     }
    105 
    106     @Test
    107     public void should_return_empty_OptionalLong() throws Exception {
    108         verify_empty_Optional_is_returned("java.util.stream.LongStream", "java.util.OptionalLong");
    109     }
    110 
    111     private void verify_empty_Optional_is_returned(String streamFqcn, String optionalFqcn) throws Exception {
    112         Class<?> streamType = getClassOrSkipTest(streamFqcn);
    113 
    114         //given
    115         Object stream = mock(streamType);
    116         Object optional = streamType.getMethod("findAny").invoke(stream);
    117         assertNotNull(optional);
    118         assertFalse((Boolean) Class.forName(optionalFqcn).getMethod("isPresent").invoke(optional));
    119 
    120         Invocation findAny = this.getLastInvocation();
    121 
    122         //when
    123         Object result = values.answer(findAny);
    124 
    125         //then
    126         assertEquals(optional, result);
    127     }
    128 
    129     @Test
    130     public void should_return_empty_Stream() throws Exception {
    131         verify_empty_Stream_is_returned("java.util.stream.Stream");
    132     }
    133 
    134     @Test
    135     public void should_return_empty_DoubleStream() throws Exception {
    136         verify_empty_Stream_is_returned("java.util.stream.DoubleStream");
    137     }
    138 
    139     @Test
    140     public void should_return_empty_IntStream() throws Exception {
    141         verify_empty_Stream_is_returned("java.util.stream.IntStream");
    142     }
    143 
    144     @Test
    145     public void should_return_empty_LongStream() throws Exception {
    146         verify_empty_Stream_is_returned("java.util.stream.LongStream");
    147     }
    148 
    149     private void verify_empty_Stream_is_returned(String streamFqcn) throws Exception {
    150         // given
    151         Class<?> streamType = getClassOrSkipTest(streamFqcn);
    152 
    153         // when
    154         Object stream = values.returnValueFor(streamType);
    155         long count = (Long) streamType.getMethod("count").invoke(stream);
    156 
    157         // then
    158         assertEquals("count of empty " + streamFqcn, 0L, count);
    159     }
    160 
    161     /**
    162      * Tries to load the given class. If the class is not found, the complete test is skipped.
    163      */
    164     private Class<?> getClassOrSkipTest(String className) {
    165         try {
    166             return Class.forName(className);
    167         } catch (ClassNotFoundException e) {
    168             Assume.assumeNoException("JVM does not support " + className, e);
    169             return null;
    170         }
    171     }
    172 
    173 }
    174