Skip to content

Commit 97ab170

Browse files
benjchristensenbenjchristensen
committed
Fix ambiguous imports
Mockito.* and Observable.* both have a never() method in them.
1 parent cc7958d commit 97ab170

File tree

4 files changed

+79
-87
lines changed

4 files changed

+79
-87
lines changed

‎rxjava-core/src/test/java/rx/operators/OperationDistinctTest.java

Lines changed: 27 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -1,23 +1,21 @@
11
package rx.operators;
22

3+
import static org.mockito.Matchers.*;
4+
import static org.mockito.Mockito.*;
5+
import static org.mockito.MockitoAnnotations.*;
6+
import static rx.operators.OperationDistinct.*;
7+
8+
import java.util.Comparator;
9+
310
import org.junit.Before;
411
import org.junit.Test;
512
import org.mockito.InOrder;
613
import org.mockito.Mock;
14+
715
import rx.Observable;
816
import rx.Observer;
917
import rx.util.functions.Func1;
1018

11-
import java.util.Comparator;
12-
13-
import static org.mockito.Matchers.any;
14-
import static org.mockito.Matchers.anyString;
15-
import static org.mockito.Mockito.*;
16-
import static org.mockito.Mockito.never;
17-
import static org.mockito.MockitoAnnotations.initMocks;
18-
import static rx.Observable.*;
19-
import static rx.operators.OperationDistinct.distinct;
20-
2119
public class OperationDistinctTest {
2220

2321
@Mock
@@ -50,8 +48,8 @@ public void before() {
5048

5149
@Test
5250
public void testDistinctOfNone() {
53-
Observable<String> src = empty();
54-
create(distinct(src)).subscribe(w);
51+
Observable<String> src = Observable.empty();
52+
Observable.create(distinct(src)).subscribe(w);
5553

5654
verify(w, never()).onNext(anyString());
5755
verify(w, never()).onError(any(Throwable.class));
@@ -60,8 +58,8 @@ public void testDistinctOfNone() {
6058

6159
@Test
6260
public void testDistinctOfNoneWithKeySelector() {
63-
Observable<String> src = empty();
64-
create(distinct(src, TO_UPPER_WITH_EXCEPTION)).subscribe(w);
61+
Observable<String> src = Observable.empty();
62+
Observable.create(distinct(src, TO_UPPER_WITH_EXCEPTION)).subscribe(w);
6563

6664
verify(w, never()).onNext(anyString());
6765
verify(w, never()).onError(any(Throwable.class));
@@ -70,8 +68,8 @@ public void testDistinctOfNoneWithKeySelector() {
7068

7169
@Test
7270
public void testDistinctOfNormalSource() {
73-
Observable<String> src = from("a", "b", "c", "c", "c", "b", "b", "a", "e");
74-
create(distinct(src)).subscribe(w);
71+
Observable<String> src = Observable.from("a", "b", "c", "c", "c", "b", "b", "a", "e");
72+
Observable.create(distinct(src)).subscribe(w);
7573

7674
InOrder inOrder = inOrder(w);
7775
inOrder.verify(w, times(1)).onNext("a");
@@ -85,8 +83,8 @@ public void testDistinctOfNormalSource() {
8583

8684
@Test
8785
public void testDistinctOfNormalSourceWithKeySelector() {
88-
Observable<String> src = from("a", "B", "c", "C", "c", "B", "b", "a", "E");
89-
create(distinct(src, TO_UPPER_WITH_EXCEPTION)).subscribe(w);
86+
Observable<String> src = Observable.from("a", "B", "c", "C", "c", "B", "b", "a", "E");
87+
Observable.create(distinct(src, TO_UPPER_WITH_EXCEPTION)).subscribe(w);
9088

9189
InOrder inOrder = inOrder(w);
9290
inOrder.verify(w, times(1)).onNext("a");
@@ -100,8 +98,8 @@ public void testDistinctOfNormalSourceWithKeySelector() {
10098

10199
@Test
102100
public void testDistinctOfNormalSourceWithComparator() {
103-
Observable<String> src = from("1", "12", "123", "aaa", "321", "12", "21", "1", "12345");
104-
create(distinct(src, COMPARE_LENGTH)).subscribe(w);
101+
Observable<String> src = Observable.from("1", "12", "123", "aaa", "321", "12", "21", "1", "12345");
102+
Observable.create(distinct(src, COMPARE_LENGTH)).subscribe(w);
105103

106104
InOrder inOrder = inOrder(w);
107105
inOrder.verify(w, times(1)).onNext("1");
@@ -115,8 +113,8 @@ public void testDistinctOfNormalSourceWithComparator() {
115113

116114
@Test
117115
public void testDistinctOfNormalSourceWithKeySelectorAndComparator() {
118-
Observable<String> src = from("a", "x", "ab", "abc", "cba", "de", "x", "a", "abcd");
119-
create(distinct(src, TO_UPPER_WITH_EXCEPTION, COMPARE_LENGTH)).subscribe(w);
116+
Observable<String> src = Observable.from("a", "x", "ab", "abc", "cba", "de", "x", "a", "abcd");
117+
Observable.create(distinct(src, TO_UPPER_WITH_EXCEPTION, COMPARE_LENGTH)).subscribe(w);
120118

121119
InOrder inOrder = inOrder(w);
122120
inOrder.verify(w, times(1)).onNext("a");
@@ -130,13 +128,13 @@ public void testDistinctOfNormalSourceWithKeySelectorAndComparator() {
130128

131129
@Test
132130
public void testDistinctOfNormalSourceWithKeySelectorAndComparatorAndTwoSubscriptions() {
133-
Observable<String> src = from("a", "x", "ab", "abc", "cba", "de", "x", "a", "abcd");
134-
create(distinct(src, TO_UPPER_WITH_EXCEPTION, COMPARE_LENGTH)).subscribe(w);
131+
Observable<String> src = Observable.from("a", "x", "ab", "abc", "cba", "de", "x", "a", "abcd");
132+
Observable.create(distinct(src, TO_UPPER_WITH_EXCEPTION, COMPARE_LENGTH)).subscribe(w);
135133

136134
InOrder inOrder = inOrder(w);
137135
inOrder.verify(w, times(1)).onNext("a");
138136
inOrder.verify(w, times(1)).onNext("x");
139-
create(distinct(src, TO_UPPER_WITH_EXCEPTION, COMPARE_LENGTH)).subscribe(w2);
137+
Observable.create(distinct(src, TO_UPPER_WITH_EXCEPTION, COMPARE_LENGTH)).subscribe(w2);
140138
inOrder.verify(w, times(1)).onNext("abc");
141139
inOrder.verify(w, times(1)).onNext("abcd");
142140
inOrder.verify(w, times(1)).onCompleted();
@@ -155,8 +153,8 @@ public void testDistinctOfNormalSourceWithKeySelectorAndComparatorAndTwoSubscrip
155153

156154
@Test
157155
public void testDistinctOfSourceWithNulls() {
158-
Observable<String> src = from(null, "a", "a", null, null, "b", null);
159-
create(distinct(src)).subscribe(w);
156+
Observable<String> src = Observable.from(null, "a", "a", null, null, "b", null);
157+
Observable.create(distinct(src)).subscribe(w);
160158

161159
InOrder inOrder = inOrder(w);
162160
inOrder.verify(w, times(1)).onNext(null);
@@ -169,8 +167,8 @@ public void testDistinctOfSourceWithNulls() {
169167

170168
@Test
171169
public void testDistinctOfSourceWithExceptionsFromKeySelector() {
172-
Observable<String> src = from("a", "b", null, "c");
173-
create(distinct(src, TO_UPPER_WITH_EXCEPTION)).subscribe(w);
170+
Observable<String> src = Observable.from("a", "b", null, "c");
171+
Observable.create(distinct(src, TO_UPPER_WITH_EXCEPTION)).subscribe(w);
174172

175173
InOrder inOrder = inOrder(w);
176174
inOrder.verify(w, times(1)).onNext("a");

‎rxjava-core/src/test/java/rx/operators/OperationDistinctUntilChangedTest.java

Lines changed: 27 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -1,23 +1,21 @@
11
package rx.operators;
22

3+
import static org.mockito.Matchers.*;
4+
import static org.mockito.Mockito.*;
5+
import static org.mockito.MockitoAnnotations.*;
6+
import static rx.operators.OperationDistinctUntilChanged.*;
7+
8+
import java.util.Comparator;
9+
310
import org.junit.Before;
411
import org.junit.Test;
512
import org.mockito.InOrder;
613
import org.mockito.Mock;
14+
715
import rx.Observable;
816
import rx.Observer;
917
import rx.util.functions.Func1;
1018

11-
import java.util.Comparator;
12-
13-
import static org.mockito.Matchers.any;
14-
import static org.mockito.Matchers.anyString;
15-
import static org.mockito.Mockito.*;
16-
import static org.mockito.Mockito.never;
17-
import static org.mockito.MockitoAnnotations.initMocks;
18-
import static rx.Observable.*;
19-
import static rx.operators.OperationDistinctUntilChanged.distinctUntilChanged;
20-
2119
public class OperationDistinctUntilChangedTest {
2220

2321
@Mock
@@ -50,8 +48,8 @@ public void before() {
5048

5149
@Test
5250
public void testDistinctUntilChangedOfNone() {
53-
Observable<String> src = empty();
54-
create(distinctUntilChanged(src)).subscribe(w);
51+
Observable<String> src = Observable.empty();
52+
Observable.create(distinctUntilChanged(src)).subscribe(w);
5553

5654
verify(w, never()).onNext(anyString());
5755
verify(w, never()).onError(any(Throwable.class));
@@ -60,8 +58,8 @@ public void testDistinctUntilChangedOfNone() {
6058

6159
@Test
6260
public void testDistinctUntilChangedOfNoneWithKeySelector() {
63-
Observable<String> src = empty();
64-
create(distinctUntilChanged(src, TO_UPPER_WITH_EXCEPTION)).subscribe(w);
61+
Observable<String> src = Observable.empty();
62+
Observable.create(distinctUntilChanged(src, TO_UPPER_WITH_EXCEPTION)).subscribe(w);
6563

6664
verify(w, never()).onNext(anyString());
6765
verify(w, never()).onError(any(Throwable.class));
@@ -70,8 +68,8 @@ public void testDistinctUntilChangedOfNoneWithKeySelector() {
7068

7169
@Test
7270
public void testDistinctUntilChangedOfNormalSource() {
73-
Observable<String> src = from("a", "b", "c", "c", "c", "b", "b", "a", "e");
74-
create(distinctUntilChanged(src)).subscribe(w);
71+
Observable<String> src = Observable.from("a", "b", "c", "c", "c", "b", "b", "a", "e");
72+
Observable.create(distinctUntilChanged(src)).subscribe(w);
7573

7674
InOrder inOrder = inOrder(w);
7775
inOrder.verify(w, times(1)).onNext("a");
@@ -87,8 +85,8 @@ public void testDistinctUntilChangedOfNormalSource() {
8785

8886
@Test
8987
public void testDistinctUntilChangedOfNormalSourceWithKeySelector() {
90-
Observable<String> src = from("a", "b", "c", "C", "c", "B", "b", "a", "e");
91-
create(distinctUntilChanged(src, TO_UPPER_WITH_EXCEPTION)).subscribe(w);
88+
Observable<String> src = Observable.from("a", "b", "c", "C", "c", "B", "b", "a", "e");
89+
Observable.create(distinctUntilChanged(src, TO_UPPER_WITH_EXCEPTION)).subscribe(w);
9290

9391
InOrder inOrder = inOrder(w);
9492
inOrder.verify(w, times(1)).onNext("a");
@@ -104,8 +102,8 @@ public void testDistinctUntilChangedOfNormalSourceWithKeySelector() {
104102

105103
@Test
106104
public void testDistinctUntilChangedOfSourceWithNulls() {
107-
Observable<String> src = from(null, "a", "a", null, null, "b", null, null);
108-
create(distinctUntilChanged(src)).subscribe(w);
105+
Observable<String> src = Observable.from(null, "a", "a", null, null, "b", null, null);
106+
Observable.create(distinctUntilChanged(src)).subscribe(w);
109107

110108
InOrder inOrder = inOrder(w);
111109
inOrder.verify(w, times(1)).onNext(null);
@@ -120,8 +118,8 @@ public void testDistinctUntilChangedOfSourceWithNulls() {
120118

121119
@Test
122120
public void testDistinctUntilChangedOfSourceWithExceptionsFromKeySelector() {
123-
Observable<String> src = from("a", "b", null, "c");
124-
create(distinctUntilChanged(src, TO_UPPER_WITH_EXCEPTION)).subscribe(w);
121+
Observable<String> src = Observable.from("a", "b", null, "c");
122+
Observable.create(distinctUntilChanged(src, TO_UPPER_WITH_EXCEPTION)).subscribe(w);
125123

126124
InOrder inOrder = inOrder(w);
127125
inOrder.verify(w, times(1)).onNext("a");
@@ -133,8 +131,8 @@ public void testDistinctUntilChangedOfSourceWithExceptionsFromKeySelector() {
133131

134132
@Test
135133
public void testDistinctUntilChangedWithComparator() {
136-
Observable<String> src = from("a", "b", "c", "aa", "bb", "c", "ddd");
137-
create(distinctUntilChanged(src, COMPARE_LENGTH)).subscribe(w);
134+
Observable<String> src = Observable.from("a", "b", "c", "aa", "bb", "c", "ddd");
135+
Observable.create(distinctUntilChanged(src, COMPARE_LENGTH)).subscribe(w);
138136
InOrder inOrder = inOrder(w);
139137
inOrder.verify(w, times(1)).onNext("a");
140138
inOrder.verify(w, times(1)).onNext("aa");
@@ -147,8 +145,8 @@ public void testDistinctUntilChangedWithComparator() {
147145

148146
@Test
149147
public void testDistinctUntilChangedWithComparatorAndKeySelector() {
150-
Observable<String> src = from("a", "b", "x", "aa", "bb", "c", "ddd");
151-
create(distinctUntilChanged(src, TO_UPPER_WITH_EXCEPTION, COMPARE_LENGTH)).subscribe(w);
148+
Observable<String> src = Observable.from("a", "b", "x", "aa", "bb", "c", "ddd");
149+
Observable.create(distinctUntilChanged(src, TO_UPPER_WITH_EXCEPTION, COMPARE_LENGTH)).subscribe(w);
152150
InOrder inOrder = inOrder(w);
153151
inOrder.verify(w, times(1)).onNext("a");
154152
inOrder.verify(w, times(1)).onNext("x");
@@ -161,12 +159,12 @@ public void testDistinctUntilChangedWithComparatorAndKeySelector() {
161159

162160
@Test
163161
public void testDistinctUntilChangedWithComparatorAndKeySelectorandTwoSubscriptions() {
164-
Observable<String> src = from("a", "b", "x", "aa", "bb", "c", "ddd");
165-
create(distinctUntilChanged(src, TO_UPPER_WITH_EXCEPTION, COMPARE_LENGTH)).subscribe(w);
162+
Observable<String> src = Observable.from("a", "b", "x", "aa", "bb", "c", "ddd");
163+
Observable.create(distinctUntilChanged(src, TO_UPPER_WITH_EXCEPTION, COMPARE_LENGTH)).subscribe(w);
166164
InOrder inOrder = inOrder(w);
167165
inOrder.verify(w, times(1)).onNext("a");
168166
inOrder.verify(w, times(1)).onNext("x");
169-
create(distinctUntilChanged(src, TO_UPPER_WITH_EXCEPTION, COMPARE_LENGTH)).subscribe(w2);
167+
Observable.create(distinctUntilChanged(src, TO_UPPER_WITH_EXCEPTION, COMPARE_LENGTH)).subscribe(w2);
170168
inOrder.verify(w, times(1)).onNext("c");
171169
inOrder.verify(w, times(1)).onNext("ddd");
172170
inOrder.verify(w, times(1)).onCompleted();

‎rxjava-core/src/test/java/rx/operators/OperationFirstOrDefaultTest.java

Lines changed: 14 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -1,20 +1,18 @@
11
package rx.operators;
22

3+
import static org.mockito.Matchers.*;
4+
import static org.mockito.Mockito.*;
5+
import static org.mockito.MockitoAnnotations.*;
6+
import static rx.operators.OperationFirstOrDefault.*;
7+
38
import org.junit.Before;
49
import org.junit.Test;
510
import org.mockito.Mock;
11+
612
import rx.Observable;
713
import rx.Observer;
814
import rx.util.functions.Func1;
915

10-
import static org.mockito.Matchers.any;
11-
import static org.mockito.Matchers.anyString;
12-
import static org.mockito.Mockito.never;
13-
import static org.mockito.Mockito.*;
14-
import static org.mockito.MockitoAnnotations.initMocks;
15-
import static rx.Observable.*;
16-
import static rx.operators.OperationFirstOrDefault.firstOrDefault;
17-
1816
public class OperationFirstOrDefaultTest {
1917

2018
@Mock
@@ -34,8 +32,8 @@ public void before() {
3432

3533
@Test
3634
public void testFirstOrElseOfNone() {
37-
Observable<String> src = empty();
38-
create(firstOrDefault(src, "default")).subscribe(w);
35+
Observable<String> src = Observable.empty();
36+
Observable.create(firstOrDefault(src, "default")).subscribe(w);
3937

4038
verify(w, times(1)).onNext(anyString());
4139
verify(w, times(1)).onNext("default");
@@ -45,8 +43,8 @@ public void testFirstOrElseOfNone() {
4543

4644
@Test
4745
public void testFirstOrElseOfSome() {
48-
Observable<String> src = from("a", "b", "c");
49-
create(firstOrDefault(src, "default")).subscribe(w);
46+
Observable<String> src = Observable.from("a", "b", "c");
47+
Observable.create(firstOrDefault(src, "default")).subscribe(w);
5048

5149
verify(w, times(1)).onNext(anyString());
5250
verify(w, times(1)).onNext("a");
@@ -56,8 +54,8 @@ public void testFirstOrElseOfSome() {
5654

5755
@Test
5856
public void testFirstOrElseWithPredicateOfNoneMatchingThePredicate() {
59-
Observable<String> src = from("a", "b", "c");
60-
create(firstOrDefault(src, IS_D, "default")).subscribe(w);
57+
Observable<String> src = Observable.from("a", "b", "c");
58+
Observable.create(firstOrDefault(src, IS_D, "default")).subscribe(w);
6159

6260
verify(w, times(1)).onNext(anyString());
6361
verify(w, times(1)).onNext("default");
@@ -67,8 +65,8 @@ public void testFirstOrElseWithPredicateOfNoneMatchingThePredicate() {
6765

6866
@Test
6967
public void testFirstOrElseWithPredicateOfSome() {
70-
Observable<String> src = from("a", "b", "c", "d", "e", "f");
71-
create(firstOrDefault(src, IS_D, "default")).subscribe(w);
68+
Observable<String> src = Observable.from("a", "b", "c", "d", "e", "f");
69+
Observable.create(firstOrDefault(src, IS_D, "default")).subscribe(w);
7270

7371
verify(w, times(1)).onNext(anyString());
7472
verify(w, times(1)).onNext("d");

0 commit comments

Comments
 (0)