How to use method of org.mockito.internal.configuration.injection.MockInjection class

1/**
2 * Copyright (c) 2007 Mockito contributors
3 * This program is made available under the terms of the MIT License.
4 */
5package org.mockito.internal.configuration;
6
7
8import java.lang.reflect.Field;
9import java.util.Set;
10import org.junit.Test;
11import org.mockito.internal.configuration.injection.MockInjection;
12
13
14@SuppressWarnings("unchecked")
15public class MockInjectionTest {
16    private MockInjectionTest.AnObjectWithConstructor withConstructor;
17
18    private MockInjectionTest.AnObjectWithoutConstructor withoutConstructor;
19
20    @Test(expected = IllegalArgumentException.class)
21    public void should_not_allow_null_on_field() {
22        MockInjection.onField(((Field) (null)), this);
23    }
24
25    @Test(expected = IllegalArgumentException.class)
26    public void should_not_allow_null_on_fields() {
27        MockInjection.onFields(((Set<Field>) (null)), this);
28    }
29
30    @Test(expected = IllegalArgumentException.class)
31    public void should_not_allow_null_on_instance_owning_the_field() throws Exception {
32        MockInjection.onField(field("withConstructor"), null);
33    }
34
35    @Test(expected = IllegalArgumentException.class)
36    public void should_not_allow_null_on_mocks() throws Exception {
37        MockInjection.onField(field("withConstructor"), this).withMocks(null);
38    }
39
40    @Test
41    public void can_try_constructor_injection() throws Exception {
42        MockInjection.onField(field("withConstructor"), this).withMocks(oneSetMock()).tryConstructorInjection().apply();
43        assertThat(withConstructor.initializedWithConstructor).isEqualTo(true);
44    }
45
46    @Test
47    public void should_not_fail_if_constructor_injection_is_not_possible() throws Exception {
48        MockInjection.onField(field("withoutConstructor"), this).withMocks(otherKindOfMocks()).tryConstructorInjection().apply();
49        assertThat(withoutConstructor).isNull();
50    }
51
52    @Test
53    public void can_try_property_or_setter_injection() throws Exception {
54        MockInjection.onField(field("withoutConstructor"), this).withMocks(oneSetMock()).tryPropertyOrFieldInjection().apply();
55        assertThat(withoutConstructor.theSet).isNotNull();
56    }
57
58    @Test
59    public void should_not_fail_if_property_or_field_injection_is_not_possible() throws Exception {
60        MockInjection.onField(field("withoutConstructor"), this).withMocks(otherKindOfMocks()).tryPropertyOrFieldInjection().apply();
61        assertThat(withoutConstructor.theSet).isNull();
62    }
63
64    public static class AnObjectWithConstructor {
65        public boolean initializedWithConstructor = false;
66
67        public AnObjectWithConstructor(Set<String> strings) {
68            initializedWithConstructor = true;
69        }
70    }
71
72    public static class AnObjectWithoutConstructor {
73        private Set<?> theSet;
74    }
75}
76
77

Source: MockInjectionTest.java

/**
 * Copyright (c) 2007 Mockito contributors
 * This program is made available under the terms of the MIT License.
 */
package org.mockito.internal.configuration;


import java.lang.reflect.Field;
import java.util.Set;
import org.junit.Test;
import org.mockito.internal.configuration.injection.MockInjection;


@SuppressWarnings("unchecked")
public class MockInjectionTest {
    private MockInjectionTest.AnObjectWithConstructor withConstructor;

    private MockInjectionTest.AnObjectWithoutConstructor withoutConstructor;

    @Test(expected = IllegalArgumentException.class)
    public void should_not_allow_null_on_field() {
        MockInjection.onField(((Field) (null)), this);
    }

    @Test(expected = IllegalArgumentException.class)
    public void should_not_allow_null_on_fields() {
        MockInjection.onFields(((Set<Field>) (null)), this);
    }

    @Test(expected = IllegalArgumentException.class)
    public void should_not_allow_null_on_instance_owning_the_field() throws Exception {
        MockInjection.onField(field("withConstructor"), null);
    }

    @Test(expected = IllegalArgumentException.class)
    public void should_not_allow_null_on_mocks() throws Exception {
        MockInjection.onField(field("withConstructor"), this).withMocks(null);
    }

    @Test
    public void can_try_constructor_injection() throws Exception {
        MockInjection.onField(field("withConstructor"), this).withMocks(oneSetMock()).tryConstructorInjection().apply();
        assertThat(withConstructor.initializedWithConstructor).isEqualTo(true);
    }

    @Test
    public void should_not_fail_if_constructor_injection_is_not_possible() throws Exception {
        MockInjection.onField(field("withoutConstructor"), this).withMocks(otherKindOfMocks()).tryConstructorInjection().apply();
        assertThat(withoutConstructor).isNull();
    }

    @Test
    public void can_try_property_or_setter_injection() throws Exception {
        MockInjection.onField(field("withoutConstructor"), this).withMocks(oneSetMock()).tryPropertyOrFieldInjection().apply();
        assertThat(withoutConstructor.theSet).isNotNull();
    }

    @Test
    public void should_not_fail_if_property_or_field_injection_is_not_possible() throws Exception {
        MockInjection.onField(field("withoutConstructor"), this).withMocks(otherKindOfMocks()).tryPropertyOrFieldInjection().apply();
        assertThat(withoutConstructor.theSet).isNull();
    }

    public static class AnObjectWithConstructor {
        public boolean initializedWithConstructor = false;

        public AnObjectWithConstructor(Set<String> strings) {
            initializedWithConstructor = true;
        }
    }

    public static class AnObjectWithoutConstructor {
        private Set<?> theSet;
    }
}