1 /*
2  * Copyright (C) 2019 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package com.android.modules.utils.testing;
18 
19 import static com.google.common.truth.Truth.assertThat;
20 
21 import androidx.test.filters.SmallTest;
22 import androidx.test.runner.AndroidJUnit4;
23 
24 import com.android.dx.mockito.inline.extended.ExtendedMockito;
25 import com.android.dx.mockito.inline.extended.StaticMockitoSessionBuilder;
26 
27 import org.junit.Rule;
28 import org.junit.Test;
29 import org.junit.runner.RunWith;
30 
31 import java.util.ArrayList;
32 import java.util.List;
33 
34 @RunWith(AndroidJUnit4.class)
35 @SmallTest
36 public class MultipleStaticMocksTest {
37     @Rule
38     public ExtendedMockitoRule mExtendedMockitoRule = new ExtendedMockitoRule.Builder(this)
39             .addStaticMockFixtures(AB::new, CD::new).build();
40 
41     private List<String> mCollected;
42 
43     @Test
testMultipleStaticMocks()44     public void testMultipleStaticMocks() throws Exception {
45         mCollected = new ArrayList<>();
46         int n = 0;
47 
48         A.a();
49         n = verifyCollected(n, "A.a");
50 
51         D.b();
52         n = verifyCollected(n, "D.b");
53 
54         C.b();
55         n = verifyCollected(n, "C.b");
56 
57         B.a();
58         n = verifyCollected(n, "B.a");
59     }
60 
verifyCollected(int n, String... last)61     private int verifyCollected(int n, String... last) {
62         assertThat(mCollected).hasSize(n + last.length);
63         assertThat(mCollected.subList(n, mCollected.size()))
64                 .containsExactlyElementsIn(last).inOrder();
65         return n + last.length;
66     }
67 
68     private static class A {
a()69         /* package */ static void a() {}
b()70         /* package */ static void b() {}
71     }
72 
73     private static class B {
a()74         /* package */ static void a() {}
b()75         /* package */ static void b() {}
76     }
77 
78     private static class C {
a()79         /* package */ static void a() {}
b()80         /* package */ static void b() {}
81     }
82 
83     private static class D {
a()84         /* package */ static void a() {}
b()85         /* package */ static void b() {}
86     }
87 
88     /**
89      * AB StaticMockFixture class that handles two mocked classes, {@link A} and {@link B}.
90      */
91     private class AB implements StaticMockFixture {
92         @Override
setUpMockedClasses( StaticMockitoSessionBuilder sessionBuilder)93         public StaticMockitoSessionBuilder setUpMockedClasses(
94                 StaticMockitoSessionBuilder sessionBuilder) {
95             sessionBuilder.spyStatic(A.class);
96             sessionBuilder.spyStatic(B.class);
97             return sessionBuilder;
98         }
99 
100         @Override
setUpMockBehaviors()101         public void setUpMockBehaviors() {
102             ExtendedMockito.doAnswer(invocation -> {
103                 mCollected.add("A.a");
104                 return null;
105             }).when(A::a);
106             ExtendedMockito.doAnswer(invocation -> {
107                 mCollected.add("A.b");
108                 return null;
109             }).when(A::b);
110             ExtendedMockito.doAnswer(invocation -> {
111                 mCollected.add("B.a");
112                 return null;
113             }).when(B::a);
114             ExtendedMockito.doAnswer(invocation -> {
115                 mCollected.add("B.b");
116                 return null;
117             }).when(B::b);
118         }
119 
120         @Override
tearDown()121         public void tearDown() {
122 
123         }
124     }
125 
126     /**
127      * AB StaticMockFixture class that handles two mocked classes, {@link C} and {@link D}.
128      */
129     private class CD implements StaticMockFixture {
130         @Override
setUpMockedClasses( StaticMockitoSessionBuilder sessionBuilder)131         public StaticMockitoSessionBuilder setUpMockedClasses(
132                 StaticMockitoSessionBuilder sessionBuilder) {
133             sessionBuilder.spyStatic(C.class);
134             sessionBuilder.spyStatic(D.class);
135             return sessionBuilder;
136         }
137 
138         @Override
setUpMockBehaviors()139         public void setUpMockBehaviors() {
140             ExtendedMockito.doAnswer(invocation -> {
141                 mCollected.add("C.a");
142                 return null;
143             }).when(C::a);
144             ExtendedMockito.doAnswer(invocation -> {
145                 mCollected.add("C.b");
146                 return null;
147             }).when(C::b);
148             ExtendedMockito.doAnswer(invocation -> {
149                 mCollected.add("D.a");
150                 return null;
151             }).when(D::a);
152             ExtendedMockito.doAnswer(invocation -> {
153                 mCollected.add("D.b");
154                 return null;
155             }).when(D::b);
156         }
157 
158         @Override
tearDown()159         public void tearDown() {
160 
161         }
162     }
163 }
164