diff --git a/build.gradle b/build.gradle index 0413b92cfc..71533d1c01 100644 --- a/build.gradle +++ b/build.gradle @@ -5,36 +5,39 @@ buildscript { description = 'RxJava: Reactive Extensions for the JVM – a library for composing asynchronous and event-based programs using observable sequences for the Java VM.' -apply plugin: 'java' apply plugin: 'nebula.rxjava-project' -sourceCompatibility = JavaVersion.VERSION_1_6 -targetCompatibility = JavaVersion.VERSION_1_6 +subprojects { + apply plugin: 'java' + apply plugin: 'nebula.rxjava-project' -dependencies { + sourceCompatibility = 1.8 + targetCompatibility = 1.8 + + dependencies { compile 'org.reactivestreams:reactive-streams:1.0.0' testCompile 'junit:junit:4.12' testCompile 'org.mockito:mockito-core:1.10.19' - perfCompile 'org.openjdk.jmh:jmh-core:1.10.5' - perfCompile 'org.openjdk.jmh:jmh-generator-annprocess:1.10.5' - // perfCompile 'org.reactivex:rxjava:1.0.14' -} + perfCompile 'org.openjdk.jmh:jmh-core:1.11.3' + perfCompile 'org.openjdk.jmh:jmh-generator-annprocess:1.11.3' + } -javadoc { + javadoc { exclude "**/io/reactivex/internal/**" -} + } -// support for snapshot/final releases with the various branches RxJava uses -nebulaRelease { + // support for snapshot/final releases with the various branches RxJava uses + nebulaRelease { addReleaseBranchPattern(/\d+\.\d+\.\d+/) addReleaseBranchPattern('HEAD') -} + } -if (project.hasProperty('release.useLastTag')) { + if (project.hasProperty('release.useLastTag')) { tasks.prepare.enabled = false -} + } -test{ - maxHeapSize = "2g" + test{ + maxHeapSize = "2g" + } } diff --git a/rxjava-java6/build.gradle b/rxjava-java6/build.gradle new file mode 100644 index 0000000000..7bfe33efd6 --- /dev/null +++ b/rxjava-java6/build.gradle @@ -0,0 +1,12 @@ +buildscript { + repositories { jcenter() } + dependencies { classpath 'me.tatarka:gradle-retrolambda:3.2.5' } +} + +apply plugin: 'me.tatarka.retrolambda' + +sourceSets { + main { java.source project(':rxjava').sourceSets.main.java } + perf { java.source project(':rxjava').sourceSets.perf.java } + test { java.source project(':rxjava').sourceSets.test.java } +} diff --git a/src/main/java/io/reactivex/functions/BiConsumer.java b/rxjava-java6/src/main/java/io/reactivex/functions/BiConsumer.java similarity index 100% rename from src/main/java/io/reactivex/functions/BiConsumer.java rename to rxjava-java6/src/main/java/io/reactivex/functions/BiConsumer.java diff --git a/src/main/java/io/reactivex/functions/BiFunction.java b/rxjava-java6/src/main/java/io/reactivex/functions/BiFunction.java similarity index 100% rename from src/main/java/io/reactivex/functions/BiFunction.java rename to rxjava-java6/src/main/java/io/reactivex/functions/BiFunction.java diff --git a/src/main/java/io/reactivex/functions/BiPredicate.java b/rxjava-java6/src/main/java/io/reactivex/functions/BiPredicate.java similarity index 100% rename from src/main/java/io/reactivex/functions/BiPredicate.java rename to rxjava-java6/src/main/java/io/reactivex/functions/BiPredicate.java diff --git a/src/main/java/io/reactivex/functions/BooleanSupplier.java b/rxjava-java6/src/main/java/io/reactivex/functions/BooleanSupplier.java similarity index 100% rename from src/main/java/io/reactivex/functions/BooleanSupplier.java rename to rxjava-java6/src/main/java/io/reactivex/functions/BooleanSupplier.java diff --git a/src/main/java/io/reactivex/functions/Consumer.java b/rxjava-java6/src/main/java/io/reactivex/functions/Consumer.java similarity index 100% rename from src/main/java/io/reactivex/functions/Consumer.java rename to rxjava-java6/src/main/java/io/reactivex/functions/Consumer.java diff --git a/src/main/java/io/reactivex/functions/Function.java b/rxjava-java6/src/main/java/io/reactivex/functions/Function.java similarity index 100% rename from src/main/java/io/reactivex/functions/Function.java rename to rxjava-java6/src/main/java/io/reactivex/functions/Function.java diff --git a/src/main/java/io/reactivex/functions/Function3.java b/rxjava-java6/src/main/java/io/reactivex/functions/Function3.java similarity index 100% rename from src/main/java/io/reactivex/functions/Function3.java rename to rxjava-java6/src/main/java/io/reactivex/functions/Function3.java diff --git a/src/main/java/io/reactivex/functions/Function4.java b/rxjava-java6/src/main/java/io/reactivex/functions/Function4.java similarity index 100% rename from src/main/java/io/reactivex/functions/Function4.java rename to rxjava-java6/src/main/java/io/reactivex/functions/Function4.java diff --git a/src/main/java/io/reactivex/functions/Function5.java b/rxjava-java6/src/main/java/io/reactivex/functions/Function5.java similarity index 100% rename from src/main/java/io/reactivex/functions/Function5.java rename to rxjava-java6/src/main/java/io/reactivex/functions/Function5.java diff --git a/src/main/java/io/reactivex/functions/Function6.java b/rxjava-java6/src/main/java/io/reactivex/functions/Function6.java similarity index 100% rename from src/main/java/io/reactivex/functions/Function6.java rename to rxjava-java6/src/main/java/io/reactivex/functions/Function6.java diff --git a/src/main/java/io/reactivex/functions/Function7.java b/rxjava-java6/src/main/java/io/reactivex/functions/Function7.java similarity index 100% rename from src/main/java/io/reactivex/functions/Function7.java rename to rxjava-java6/src/main/java/io/reactivex/functions/Function7.java diff --git a/src/main/java/io/reactivex/functions/Function8.java b/rxjava-java6/src/main/java/io/reactivex/functions/Function8.java similarity index 100% rename from src/main/java/io/reactivex/functions/Function8.java rename to rxjava-java6/src/main/java/io/reactivex/functions/Function8.java diff --git a/src/main/java/io/reactivex/functions/Function9.java b/rxjava-java6/src/main/java/io/reactivex/functions/Function9.java similarity index 100% rename from src/main/java/io/reactivex/functions/Function9.java rename to rxjava-java6/src/main/java/io/reactivex/functions/Function9.java diff --git a/src/main/java/io/reactivex/functions/IntFunction.java b/rxjava-java6/src/main/java/io/reactivex/functions/IntFunction.java similarity index 100% rename from src/main/java/io/reactivex/functions/IntFunction.java rename to rxjava-java6/src/main/java/io/reactivex/functions/IntFunction.java diff --git a/src/main/java/io/reactivex/functions/LongConsumer.java b/rxjava-java6/src/main/java/io/reactivex/functions/LongConsumer.java similarity index 100% rename from src/main/java/io/reactivex/functions/LongConsumer.java rename to rxjava-java6/src/main/java/io/reactivex/functions/LongConsumer.java diff --git a/src/main/java/io/reactivex/functions/Predicate.java b/rxjava-java6/src/main/java/io/reactivex/functions/Predicate.java similarity index 100% rename from src/main/java/io/reactivex/functions/Predicate.java rename to rxjava-java6/src/main/java/io/reactivex/functions/Predicate.java diff --git a/src/main/java/io/reactivex/functions/Supplier.java b/rxjava-java6/src/main/java/io/reactivex/functions/Supplier.java similarity index 100% rename from src/main/java/io/reactivex/functions/Supplier.java rename to rxjava-java6/src/main/java/io/reactivex/functions/Supplier.java diff --git a/rxjava/build.gradle b/rxjava/build.gradle new file mode 100644 index 0000000000..8c897007ac --- /dev/null +++ b/rxjava/build.gradle @@ -0,0 +1,20 @@ +buildscript { + repositories { jcenter() } + dependencies { classpath 'ru.vyarus:gradle-animalsniffer-plugin:1.0.0' } +} + +apply plugin: 'ru.vyarus.animalsniffer' + +sourceSets { + java8 +} + +dependencies { + compile sourceSets.java8.output + signature 'org.codehaus.mojo.signature:java16-sun:1.10@signature' +} + +animalsniffer { + toolVersion = '1.15' + ignoreFailures = false +} diff --git a/rxjava/src/java8/java/io/reactivex/functions/BiConsumer.java b/rxjava/src/java8/java/io/reactivex/functions/BiConsumer.java new file mode 100644 index 0000000000..754dba7bef --- /dev/null +++ b/rxjava/src/java8/java/io/reactivex/functions/BiConsumer.java @@ -0,0 +1,17 @@ +/** + * Copyright 2016 Netflix, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is + * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See + * the License for the specific language governing permissions and limitations under the License. + */ + +package io.reactivex.functions; + +public interface BiConsumer extends java.util.function.BiConsumer { +} diff --git a/rxjava/src/java8/java/io/reactivex/functions/BiFunction.java b/rxjava/src/java8/java/io/reactivex/functions/BiFunction.java new file mode 100644 index 0000000000..8ff3cb47e2 --- /dev/null +++ b/rxjava/src/java8/java/io/reactivex/functions/BiFunction.java @@ -0,0 +1,17 @@ +/** + * Copyright 2016 Netflix, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is + * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See + * the License for the specific language governing permissions and limitations under the License. + */ + +package io.reactivex.functions; + +public interface BiFunction extends java.util.function.BiFunction { +} diff --git a/rxjava/src/java8/java/io/reactivex/functions/BiPredicate.java b/rxjava/src/java8/java/io/reactivex/functions/BiPredicate.java new file mode 100644 index 0000000000..7f3557a4ab --- /dev/null +++ b/rxjava/src/java8/java/io/reactivex/functions/BiPredicate.java @@ -0,0 +1,17 @@ +/** + * Copyright 2016 Netflix, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is + * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See + * the License for the specific language governing permissions and limitations under the License. + */ + +package io.reactivex.functions; + +public interface BiPredicate extends java.util.function.BiPredicate { +} diff --git a/rxjava/src/java8/java/io/reactivex/functions/BooleanSupplier.java b/rxjava/src/java8/java/io/reactivex/functions/BooleanSupplier.java new file mode 100644 index 0000000000..12a9a86365 --- /dev/null +++ b/rxjava/src/java8/java/io/reactivex/functions/BooleanSupplier.java @@ -0,0 +1,17 @@ +/** + * Copyright 2016 Netflix, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is + * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See + * the License for the specific language governing permissions and limitations under the License. + */ + +package io.reactivex.functions; + +public interface BooleanSupplier extends java.util.function.BooleanSupplier { +} diff --git a/rxjava/src/java8/java/io/reactivex/functions/Consumer.java b/rxjava/src/java8/java/io/reactivex/functions/Consumer.java new file mode 100644 index 0000000000..4dd6c4c3d8 --- /dev/null +++ b/rxjava/src/java8/java/io/reactivex/functions/Consumer.java @@ -0,0 +1,17 @@ +/** + * Copyright 2016 Netflix, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is + * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See + * the License for the specific language governing permissions and limitations under the License. + */ + +package io.reactivex.functions; + +public interface Consumer extends java.util.function.Consumer { +} diff --git a/rxjava/src/java8/java/io/reactivex/functions/Function.java b/rxjava/src/java8/java/io/reactivex/functions/Function.java new file mode 100644 index 0000000000..34f2fbe61c --- /dev/null +++ b/rxjava/src/java8/java/io/reactivex/functions/Function.java @@ -0,0 +1,17 @@ +/** + * Copyright 2016 Netflix, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is + * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See + * the License for the specific language governing permissions and limitations under the License. + */ + +package io.reactivex.functions; + +public interface Function extends java.util.function.Function { +} diff --git a/rxjava/src/java8/java/io/reactivex/functions/Function3.java b/rxjava/src/java8/java/io/reactivex/functions/Function3.java new file mode 100644 index 0000000000..33df46eff7 --- /dev/null +++ b/rxjava/src/java8/java/io/reactivex/functions/Function3.java @@ -0,0 +1,18 @@ +/** + * Copyright 2016 Netflix, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is + * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See + * the License for the specific language governing permissions and limitations under the License. + */ + +package io.reactivex.functions; + +public interface Function3 { + R apply(T1 t1, T2 t2, T3 t3); +} diff --git a/rxjava/src/java8/java/io/reactivex/functions/Function4.java b/rxjava/src/java8/java/io/reactivex/functions/Function4.java new file mode 100644 index 0000000000..721f121379 --- /dev/null +++ b/rxjava/src/java8/java/io/reactivex/functions/Function4.java @@ -0,0 +1,18 @@ +/** + * Copyright 2016 Netflix, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is + * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See + * the License for the specific language governing permissions and limitations under the License. + */ + +package io.reactivex.functions; + +public interface Function4 { + R apply(T1 t1, T2 t2, T3 t3, T4 t4); +} diff --git a/rxjava/src/java8/java/io/reactivex/functions/Function5.java b/rxjava/src/java8/java/io/reactivex/functions/Function5.java new file mode 100644 index 0000000000..596999b99c --- /dev/null +++ b/rxjava/src/java8/java/io/reactivex/functions/Function5.java @@ -0,0 +1,18 @@ +/** + * Copyright 2016 Netflix, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is + * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See + * the License for the specific language governing permissions and limitations under the License. + */ + +package io.reactivex.functions; + +public interface Function5 { + R apply(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5); +} diff --git a/rxjava/src/java8/java/io/reactivex/functions/Function6.java b/rxjava/src/java8/java/io/reactivex/functions/Function6.java new file mode 100644 index 0000000000..6e97c883f8 --- /dev/null +++ b/rxjava/src/java8/java/io/reactivex/functions/Function6.java @@ -0,0 +1,18 @@ +/** + * Copyright 2016 Netflix, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is + * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See + * the License for the specific language governing permissions and limitations under the License. + */ + +package io.reactivex.functions; + +public interface Function6 { + R apply(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6); +} diff --git a/rxjava/src/java8/java/io/reactivex/functions/Function7.java b/rxjava/src/java8/java/io/reactivex/functions/Function7.java new file mode 100644 index 0000000000..d617712323 --- /dev/null +++ b/rxjava/src/java8/java/io/reactivex/functions/Function7.java @@ -0,0 +1,18 @@ +/** + * Copyright 2016 Netflix, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is + * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See + * the License for the specific language governing permissions and limitations under the License. + */ + +package io.reactivex.functions; + +public interface Function7 { + R apply(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7); +} diff --git a/rxjava/src/java8/java/io/reactivex/functions/Function8.java b/rxjava/src/java8/java/io/reactivex/functions/Function8.java new file mode 100644 index 0000000000..8cae766078 --- /dev/null +++ b/rxjava/src/java8/java/io/reactivex/functions/Function8.java @@ -0,0 +1,18 @@ +/** + * Copyright 2016 Netflix, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is + * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See + * the License for the specific language governing permissions and limitations under the License. + */ + +package io.reactivex.functions; + +public interface Function8 { + R apply(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8); +} diff --git a/rxjava/src/java8/java/io/reactivex/functions/Function9.java b/rxjava/src/java8/java/io/reactivex/functions/Function9.java new file mode 100644 index 0000000000..2c90418f2a --- /dev/null +++ b/rxjava/src/java8/java/io/reactivex/functions/Function9.java @@ -0,0 +1,18 @@ +/** + * Copyright 2016 Netflix, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is + * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See + * the License for the specific language governing permissions and limitations under the License. + */ + +package io.reactivex.functions; + +public interface Function9 { + R apply(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9); +} diff --git a/rxjava/src/java8/java/io/reactivex/functions/IntFunction.java b/rxjava/src/java8/java/io/reactivex/functions/IntFunction.java new file mode 100644 index 0000000000..4783926bb0 --- /dev/null +++ b/rxjava/src/java8/java/io/reactivex/functions/IntFunction.java @@ -0,0 +1,16 @@ +/** + * Copyright 2016 Netflix, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is + * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See + * the License for the specific language governing permissions and limitations under the License. + */ +package io.reactivex.functions; + +public interface IntFunction extends java.util.function.IntFunction { +} diff --git a/rxjava/src/java8/java/io/reactivex/functions/LongConsumer.java b/rxjava/src/java8/java/io/reactivex/functions/LongConsumer.java new file mode 100644 index 0000000000..731e53cddf --- /dev/null +++ b/rxjava/src/java8/java/io/reactivex/functions/LongConsumer.java @@ -0,0 +1,16 @@ +/** + * Copyright 2016 Netflix, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is + * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See + * the License for the specific language governing permissions and limitations under the License. + */ +package io.reactivex.functions; + +public interface LongConsumer extends java.util.function.LongConsumer { +} diff --git a/rxjava/src/java8/java/io/reactivex/functions/Predicate.java b/rxjava/src/java8/java/io/reactivex/functions/Predicate.java new file mode 100644 index 0000000000..2729389591 --- /dev/null +++ b/rxjava/src/java8/java/io/reactivex/functions/Predicate.java @@ -0,0 +1,17 @@ +/** + * Copyright 2016 Netflix, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is + * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See + * the License for the specific language governing permissions and limitations under the License. + */ + +package io.reactivex.functions; + +public interface Predicate extends java.util.function.Predicate { +} diff --git a/rxjava/src/java8/java/io/reactivex/functions/Supplier.java b/rxjava/src/java8/java/io/reactivex/functions/Supplier.java new file mode 100644 index 0000000000..96dae523a2 --- /dev/null +++ b/rxjava/src/java8/java/io/reactivex/functions/Supplier.java @@ -0,0 +1,17 @@ +/** + * Copyright 2016 Netflix, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is + * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See + * the License for the specific language governing permissions and limitations under the License. + */ + +package io.reactivex.functions; + +public interface Supplier extends java.util.function.Supplier { +} diff --git a/src/main/java/io/reactivex/BackpressureStrategy.java b/rxjava/src/main/java/io/reactivex/BackpressureStrategy.java similarity index 100% rename from src/main/java/io/reactivex/BackpressureStrategy.java rename to rxjava/src/main/java/io/reactivex/BackpressureStrategy.java diff --git a/src/main/java/io/reactivex/Completable.java b/rxjava/src/main/java/io/reactivex/Completable.java similarity index 73% rename from src/main/java/io/reactivex/Completable.java rename to rxjava/src/main/java/io/reactivex/Completable.java index f769188ae9..3b8c1c9be1 100644 --- a/src/main/java/io/reactivex/Completable.java +++ b/rxjava/src/main/java/io/reactivex/Completable.java @@ -85,21 +85,13 @@ public interface CompletableTransformer extends Function { + s.onSubscribe(EmptyDisposable.INSTANCE); + s.onComplete(); }); /** Single instance of a never Completable. */ - static final Completable NEVER = create(new CompletableOnSubscribe() { - @Override - public void accept(CompletableSubscriber s) { - s.onSubscribe(EmptyDisposable.INSTANCE); - } - }); + static final Completable NEVER = create(s -> s.onSubscribe(EmptyDisposable.INSTANCE)); /** * Returns a Completable which terminates as soon as one of the source Completables @@ -118,61 +110,58 @@ public static Completable amb(final Completable... sources) { return sources[0]; } - return create(new CompletableOnSubscribe() { - @Override - public void accept(final CompletableSubscriber s) { - final CompositeDisposable set = new CompositeDisposable(); - s.onSubscribe(set); + return create(s -> { + final CompositeDisposable set = new CompositeDisposable(); + s.onSubscribe(set); - final AtomicBoolean once = new AtomicBoolean(); - - CompletableSubscriber inner = new CompletableSubscriber() { - @Override - public void onComplete() { - if (once.compareAndSet(false, true)) { - set.dispose(); - s.onComplete(); - } - } + final AtomicBoolean once = new AtomicBoolean(); - @Override - public void onError(Throwable e) { - if (once.compareAndSet(false, true)) { - set.dispose(); - s.onError(e); - } else { - RxJavaPlugins.onError(e); - } + CompletableSubscriber inner = new CompletableSubscriber() { + @Override + public void onComplete() { + if (once.compareAndSet(false, true)) { + set.dispose(); + s.onComplete(); } + } - @Override - public void onSubscribe(Disposable d) { - set.add(d); - } - - }; - - for (Completable c : sources) { - if (set.isDisposed()) { - return; - } - if (c == null) { - NullPointerException npe = new NullPointerException("One of the sources is null"); - if (once.compareAndSet(false, true)) { - set.dispose(); - s.onError(npe); - } else { - RxJavaPlugins.onError(npe); - } - return; + @Override + public void onError(Throwable e) { + if (once.compareAndSet(false, true)) { + set.dispose(); + s.onError(e); + } else { + RxJavaPlugins.onError(e); } - if (once.get() || set.isDisposed()) { - return; + } + + @Override + public void onSubscribe(Disposable d) { + set.add(d); + } + + }; + + for (Completable c : sources) { + if (set.isDisposed()) { + return; + } + if (c == null) { + NullPointerException npe = new NullPointerException("One of the sources is null"); + if (once.compareAndSet(false, true)) { + set.dispose(); + s.onError(npe); + } else { + RxJavaPlugins.onError(npe); } - - // no need to have separate subscribers because inner is stateless - c.subscribe(inner); + return; + } + if (once.get() || set.isDisposed()) { + return; } + + // no need to have separate subscribers because inner is stateless + c.subscribe(inner); } }); } @@ -188,120 +177,117 @@ public void onSubscribe(Disposable d) { public static Completable amb(final Iterable sources) { Objects.requireNonNull(sources, "sources is null"); - return create(new CompletableOnSubscribe() { - @Override - public void accept(final CompletableSubscriber s) { - final CompositeDisposable set = new CompositeDisposable(); - s.onSubscribe(set); + return create(s -> { + final CompositeDisposable set = new CompositeDisposable(); + s.onSubscribe(set); - final AtomicBoolean once = new AtomicBoolean(); - - CompletableSubscriber inner = new CompletableSubscriber() { - @Override - public void onComplete() { - if (once.compareAndSet(false, true)) { - set.dispose(); - s.onComplete(); - } - } + final AtomicBoolean once = new AtomicBoolean(); - @Override - public void onError(Throwable e) { - if (once.compareAndSet(false, true)) { - set.dispose(); - s.onError(e); - } else { - RxJavaPlugins.onError(e); - } + CompletableSubscriber inner = new CompletableSubscriber() { + @Override + public void onComplete() { + if (once.compareAndSet(false, true)) { + set.dispose(); + s.onComplete(); } + } - @Override - public void onSubscribe(Disposable d) { - set.add(d); + @Override + public void onError(Throwable e) { + if (once.compareAndSet(false, true)) { + set.dispose(); + s.onError(e); + } else { + RxJavaPlugins.onError(e); } - - }; - - Iterator it; - + } + + @Override + public void onSubscribe(Disposable d) { + set.add(d); + } + + }; + + Iterator it; + + try { + it = sources.iterator(); + } catch (Throwable e) { + s.onError(e); + return; + } + + if (it == null) { + s.onError(new NullPointerException("The iterator returned is null")); + return; + } + + boolean empty = true; + + for (;;) { + if (once.get() || set.isDisposed()) { + return; + } + + boolean b; + try { - it = sources.iterator(); + b = it.hasNext(); } catch (Throwable e) { - s.onError(e); + if (once.compareAndSet(false, true)) { + set.dispose(); + s.onError(e); + } else { + RxJavaPlugins.onError(e); + } return; } - - if (it == null) { - s.onError(new NullPointerException("The iterator returned is null")); + + if (!b) { + if (empty) { + s.onComplete(); + } + break; + } + + empty = false; + + if (once.get() || set.isDisposed()) { return; } - - boolean empty = true; - - for (;;) { - if (once.get() || set.isDisposed()) { - return; - } - - boolean b; - - try { - b = it.hasNext(); - } catch (Throwable e) { - if (once.compareAndSet(false, true)) { - set.dispose(); - s.onError(e); - } else { - RxJavaPlugins.onError(e); - } - return; - } - - if (!b) { - if (empty) { - s.onComplete(); - } - break; - } - - empty = false; - - if (once.get() || set.isDisposed()) { - return; - } - Completable c; - - try { - c = it.next(); - } catch (Throwable e) { - if (once.compareAndSet(false, true)) { - set.dispose(); - s.onError(e); - } else { - RxJavaPlugins.onError(e); - } - return; - } - - if (c == null) { - NullPointerException npe = new NullPointerException("One of the sources is null"); - if (once.compareAndSet(false, true)) { - set.dispose(); - s.onError(npe); - } else { - RxJavaPlugins.onError(npe); - } - return; + Completable c; + + try { + c = it.next(); + } catch (Throwable e) { + if (once.compareAndSet(false, true)) { + set.dispose(); + s.onError(e); + } else { + RxJavaPlugins.onError(e); } - - if (once.get() || set.isDisposed()) { - return; + return; + } + + if (c == null) { + NullPointerException npe = new NullPointerException("One of the sources is null"); + if (once.compareAndSet(false, true)) { + set.dispose(); + s.onError(npe); + } else { + RxJavaPlugins.onError(npe); } - - // no need to have separate subscribers because inner is stateless - c.subscribe(inner); + return; } + + if (once.get() || set.isDisposed()) { + return; + } + + // no need to have separate subscribers because inner is stateless + c.subscribe(inner); } }); } @@ -403,27 +389,24 @@ public static Completable create(CompletableOnSubscribe onSubscribe) { @SchedulerSupport(SchedulerKind.NONE) public static Completable defer(final Supplier completableSupplier) { Objects.requireNonNull(completableSupplier, "completableSupplier"); - return create(new CompletableOnSubscribe() { - @Override - public void accept(CompletableSubscriber s) { - Completable c; - - try { - c = completableSupplier.get(); - } catch (Throwable e) { - s.onSubscribe(EmptyDisposable.INSTANCE); - s.onError(e); - return; - } - - if (c == null) { - s.onSubscribe(EmptyDisposable.INSTANCE); - s.onError(new NullPointerException("The completable returned is null")); - return; - } - - c.subscribe(s); + return create(s -> { + Completable c; + + try { + c = completableSupplier.get(); + } catch (Throwable e) { + s.onSubscribe(EmptyDisposable.INSTANCE); + s.onError(e); + return; } + + if (c == null) { + s.onSubscribe(EmptyDisposable.INSTANCE); + s.onError(new NullPointerException("The completable returned is null")); + return; + } + + c.subscribe(s); }); } @@ -440,23 +423,20 @@ public void accept(CompletableSubscriber s) { @SchedulerSupport(SchedulerKind.NONE) public static Completable error(final Supplier errorSupplier) { Objects.requireNonNull(errorSupplier, "errorSupplier is null"); - return create(new CompletableOnSubscribe() { - @Override - public void accept(CompletableSubscriber s) { - s.onSubscribe(EmptyDisposable.INSTANCE); - Throwable error; - - try { - error = errorSupplier.get(); - } catch (Throwable e) { - error = e; - } - - if (error == null) { - error = new NullPointerException("The error supplied is null"); - } - s.onError(error); + return create(s -> { + s.onSubscribe(EmptyDisposable.INSTANCE); + Throwable error; + + try { + error = errorSupplier.get(); + } catch (Throwable e) { + error = e; + } + + if (error == null) { + error = new NullPointerException("The error supplied is null"); } + s.onError(error); }); } @@ -469,12 +449,9 @@ public void accept(CompletableSubscriber s) { @SchedulerSupport(SchedulerKind.NONE) public static Completable error(final Throwable error) { Objects.requireNonNull(error, "error is null"); - return create(new CompletableOnSubscribe() { - @Override - public void accept(CompletableSubscriber s) { - s.onSubscribe(EmptyDisposable.INSTANCE); - s.onError(error); - } + return create(s -> { + s.onSubscribe(EmptyDisposable.INSTANCE); + s.onError(error); }); } @@ -487,22 +464,19 @@ public void accept(CompletableSubscriber s) { @SchedulerSupport(SchedulerKind.NONE) public static Completable fromCallable(final Callable callable) { Objects.requireNonNull(callable, "callable is null"); - return create(new CompletableOnSubscribe() { - @Override - public void accept(CompletableSubscriber s) { - BooleanDisposable bs = new BooleanDisposable(); - s.onSubscribe(bs); - try { - callable.call(); - } catch (Throwable e) { - if (!bs.isDisposed()) { - s.onError(e); - } - return; - } + return create(s -> { + BooleanDisposable bs = new BooleanDisposable(); + s.onSubscribe(bs); + try { + callable.call(); + } catch (Throwable e) { if (!bs.isDisposed()) { - s.onComplete(); + s.onError(e); } + return; + } + if (!bs.isDisposed()) { + s.onComplete(); } }); } @@ -519,35 +493,30 @@ public void accept(CompletableSubscriber s) { @SchedulerSupport(SchedulerKind.NONE) public static Completable fromFlowable(final Observable flowable) { Objects.requireNonNull(flowable, "flowable is null"); - return create(new CompletableOnSubscribe() { - @Override - public void accept(final CompletableSubscriber cs) { - flowable.subscribe(new Subscriber() { + return create(cs -> flowable.subscribe(new Subscriber() { - @Override - public void onComplete() { - cs.onComplete(); - } + @Override + public void onComplete() { + cs.onComplete(); + } - @Override - public void onError(Throwable t) { - cs.onError(t); - } + @Override + public void onError(Throwable t) { + cs.onError(t); + } - @Override - public void onNext(T t) { - // ignored - } + @Override + public void onNext(T t) { + // ignored + } - @Override - public void onSubscribe(Subscription s) { - cs.onSubscribe(Disposables.from(s)); - s.request(Long.MAX_VALUE); - } - - }); + @Override + public void onSubscribe(Subscription s) { + cs.onSubscribe(Disposables.from(s)); + s.request(Long.MAX_VALUE); } - }); + + })); } /** @@ -561,34 +530,29 @@ public void onSubscribe(Subscription s) { @SchedulerSupport(SchedulerKind.NONE) public static Completable fromNbpObservable(final NbpObservable observable) { Objects.requireNonNull(observable, "observable is null"); - return create(new CompletableOnSubscribe() { - @Override - public void accept(final CompletableSubscriber s) { - observable.subscribe(new NbpSubscriber() { + return create(s -> observable.subscribe(new NbpSubscriber() { - @Override - public void onComplete() { - s.onComplete(); - } + @Override + public void onComplete() { + s.onComplete(); + } - @Override - public void onError(Throwable e) { - s.onError(e); - } + @Override + public void onError(Throwable e) { + s.onError(e); + } - @Override - public void onNext(T value) { - // ignored - } + @Override + public void onNext(T value) { + // ignored + } - @Override - public void onSubscribe(Disposable d) { - s.onSubscribe(d); - } - - }); + @Override + public void onSubscribe(Disposable d) { + s.onSubscribe(d); } - }); + + })); } /** @@ -601,22 +565,19 @@ public void onSubscribe(Disposable d) { @SchedulerSupport(SchedulerKind.NONE) public static Completable fromRunnable(final Runnable run) { Objects.requireNonNull(run, "run is null"); - return create(new CompletableOnSubscribe() { - @Override - public void accept(CompletableSubscriber s) { - BooleanDisposable bs = new BooleanDisposable(); - s.onSubscribe(bs); - try { - run.run(); - } catch (Throwable e) { - if (!bs.isDisposed()) { - s.onError(e); - } - return; - } + return create(s -> { + BooleanDisposable bs = new BooleanDisposable(); + s.onSubscribe(bs); + try { + run.run(); + } catch (Throwable e) { if (!bs.isDisposed()) { - s.onComplete(); + s.onError(e); } + return; + } + if (!bs.isDisposed()) { + s.onComplete(); } }); } @@ -632,29 +593,24 @@ public void accept(CompletableSubscriber s) { @SchedulerSupport(SchedulerKind.NONE) public static Completable fromSingle(final Single single) { Objects.requireNonNull(single, "single is null"); - return create(new CompletableOnSubscribe() { - @Override - public void accept(final CompletableSubscriber s) { - single.subscribe(new SingleSubscriber() { + return create(s -> single.subscribe(new SingleSubscriber() { - @Override - public void onError(Throwable e) { - s.onError(e); - } + @Override + public void onError(Throwable e) { + s.onError(e); + } - @Override - public void onSubscribe(Disposable d) { - s.onSubscribe(d); - } + @Override + public void onSubscribe(Disposable d) { + s.onSubscribe(d); + } - @Override - public void onSuccess(T value) { - s.onComplete(); - } - - }); + @Override + public void onSuccess(T value) { + s.onComplete(); } - }); + + })); } /** @@ -816,19 +772,11 @@ public static Completable timer(long delay, TimeUnit unit) { public static Completable timer(final long delay, final TimeUnit unit, final Scheduler scheduler) { Objects.requireNonNull(unit, "unit is null"); Objects.requireNonNull(scheduler, "scheduler is null"); - return create(new CompletableOnSubscribe() { - @Override - public void accept(final CompletableSubscriber s) { - MultipleAssignmentDisposable mad = new MultipleAssignmentDisposable(); - s.onSubscribe(mad); - if (!mad.isDisposed()) { - mad.set(scheduler.scheduleDirect(new Runnable() { - @Override - public void run() { - s.onComplete(); - } - }, delay, unit)); - } + return create(s -> { + MultipleAssignmentDisposable mad = new MultipleAssignmentDisposable(); + s.onSubscribe(mad); + if (!mad.isDisposed()) { + mad.set(scheduler.scheduleDirect(s::onComplete, delay, unit)); } }); } @@ -888,101 +836,93 @@ public static Completable using( Objects.requireNonNull(completableFunction, "completableFunction is null"); Objects.requireNonNull(disposer, "disposer is null"); - return create(new CompletableOnSubscribe() { - @Override - public void accept(final CompletableSubscriber s) { - final R resource; - - try { - resource = resourceSupplier.get(); - } catch (Throwable e) { - s.onSubscribe(EmptyDisposable.INSTANCE); - s.onError(e); - return; - } - - Completable cs; - - try { - cs = completableFunction.apply(resource); - } catch (Throwable e) { - s.onSubscribe(EmptyDisposable.INSTANCE); - s.onError(e); - return; - } - - if (cs == null) { - s.onSubscribe(EmptyDisposable.INSTANCE); - s.onError(new NullPointerException("The completable supplied is null")); - return; + return create(s -> { + final R resource; + + try { + resource = resourceSupplier.get(); + } catch (Throwable e) { + s.onSubscribe(EmptyDisposable.INSTANCE); + s.onError(e); + return; + } + + Completable cs; + + try { + cs = completableFunction.apply(resource); + } catch (Throwable e) { + s.onSubscribe(EmptyDisposable.INSTANCE); + s.onError(e); + return; + } + + if (cs == null) { + s.onSubscribe(EmptyDisposable.INSTANCE); + s.onError(new NullPointerException("The completable supplied is null")); + return; + } + + final AtomicBoolean once = new AtomicBoolean(); + + cs.subscribe(new CompletableSubscriber() { + Disposable d; + void disposeThis() { + d.dispose(); + if (once.compareAndSet(false, true)) { + try { + disposer.accept(resource); + } catch (Throwable ex) { + RxJavaPlugins.onError(ex); + } + } } - - final AtomicBoolean once = new AtomicBoolean(); - - cs.subscribe(new CompletableSubscriber() { - Disposable d; - void disposeThis() { - d.dispose(); + + @Override + public void onComplete() { + if (eager) { if (once.compareAndSet(false, true)) { try { disposer.accept(resource); } catch (Throwable ex) { - RxJavaPlugins.onError(ex); + s.onError(ex); + return; } } } - @Override - public void onComplete() { - if (eager) { - if (once.compareAndSet(false, true)) { - try { - disposer.accept(resource); - } catch (Throwable ex) { - s.onError(ex); - return; - } + s.onComplete(); + + if (!eager) { + disposeThis(); + } + } + + @Override + public void onError(Throwable e) { + if (eager) { + if (once.compareAndSet(false, true)) { + try { + disposer.accept(resource); + } catch (Throwable ex) { + e = new CompositeException(ex, e); } } - - s.onComplete(); - - if (!eager) { - disposeThis(); - } } - @Override - public void onError(Throwable e) { - if (eager) { - if (once.compareAndSet(false, true)) { - try { - disposer.accept(resource); - } catch (Throwable ex) { - e = new CompositeException(ex, e); - } - } - } - - s.onError(e); - - if (!eager) { - disposeThis(); - } - } - - @Override - public void onSubscribe(Disposable d) { - this.d = d; - s.onSubscribe(new Disposable() { - @Override - public void dispose() { - disposeThis(); - } - }); + s.onError(e); + + if (!eager) { + disposeThis(); } - }); - } + } + + @Override + public void onSubscribe(Disposable d) { + this.d = d; + s.onSubscribe(this::disposeThis); + } + }); }); } @@ -1177,46 +1117,33 @@ public final Completable delay(long delay, TimeUnit unit, Scheduler scheduler) { public final Completable delay(final long delay, final TimeUnit unit, final Scheduler scheduler, final boolean delayError) { Objects.requireNonNull(unit, "unit is null"); Objects.requireNonNull(scheduler, "scheduler is null"); - return create(new CompletableOnSubscribe() { - @Override - public void accept(final CompletableSubscriber s) { - final CompositeDisposable set = new CompositeDisposable(); - - subscribe(new CompletableSubscriber() { - - - @Override - public void onComplete() { - set.add(scheduler.scheduleDirect(new Runnable() { - @Override - public void run() { - s.onComplete(); - } - }, delay, unit)); - } + return create(s -> { + final CompositeDisposable set = new CompositeDisposable(); - @Override - public void onError(final Throwable e) { - if (delayError) { - set.add(scheduler.scheduleDirect(new Runnable() { - @Override - public void run() { - s.onError(e); - } - }, delay, unit)); - } else { - s.onError(e); - } - } + subscribe(new CompletableSubscriber() { + + + @Override + public void onComplete() { + set.add(scheduler.scheduleDirect(s::onComplete, delay, unit)); + } - @Override - public void onSubscribe(Disposable d) { - set.add(d); - s.onSubscribe(set); + @Override + public void onError(final Throwable e) { + if (delayError) { + set.add(scheduler.scheduleDirect(() -> s.onError(e), delay, unit)); + } else { + s.onError(e); } - - }); - } + } + + @Override + public void onSubscribe(Disposable d) { + set.add(d); + s.onSubscribe(set); + } + + }); }); } @@ -1276,68 +1203,60 @@ protected final Completable doOnLifecycle( Objects.requireNonNull(onComplete, "onComplete is null"); Objects.requireNonNull(onAfterComplete, "onAfterComplete is null"); Objects.requireNonNull(onDisposed, "onDisposed is null"); - return create(new CompletableOnSubscribe() { + return create(s -> subscribe(new CompletableSubscriber() { + @Override - public void accept(final CompletableSubscriber s) { - subscribe(new CompletableSubscriber() { + public void onComplete() { + try { + onComplete.run(); + } catch (Throwable e) { + s.onError(e); + return; + } - @Override - public void onComplete() { - try { - onComplete.run(); - } catch (Throwable e) { - s.onError(e); - return; - } - - s.onComplete(); - - try { - onAfterComplete.run(); - } catch (Throwable e) { - RxJavaPlugins.onError(e); - } - } + s.onComplete(); - @Override - public void onError(Throwable e) { - try { - onError.accept(e); - } catch (Throwable ex) { - e = new CompositeException(ex, e); - } - - s.onError(e); - } + try { + onAfterComplete.run(); + } catch (Throwable e) { + RxJavaPlugins.onError(e); + } + } - @Override - public void onSubscribe(final Disposable d) { - - try { - onSubscribe.accept(d); - } catch (Throwable ex) { - d.dispose(); - s.onSubscribe(EmptyDisposable.INSTANCE); - s.onError(ex); - return; - } - - s.onSubscribe(new Disposable() { - @Override - public void dispose() { - try { - onDisposed.run(); - } catch (Throwable e) { - RxJavaPlugins.onError(e); - } - d.dispose(); - } - }); + @Override + public void onError(Throwable e) { + try { + onError.accept(e); + } catch (Throwable ex) { + e = new CompositeException(ex, e); + } + + s.onError(e); + } + + @Override + public void onSubscribe(final Disposable d) { + + try { + onSubscribe.accept(d); + } catch (Throwable ex) { + d.dispose(); + s.onSubscribe(EmptyDisposable.INSTANCE); + s.onError(ex); + return; + } + + s.onSubscribe(() -> { + try { + onDisposed.run(); + } catch (Throwable e) { + RxJavaPlugins.onError(e); } - + d.dispose(); }); } - }); + + })); } /** @@ -1360,12 +1279,7 @@ public final Completable doOnSubscribe(Consumer onSubscribe) */ @SchedulerSupport(SchedulerKind.NONE) public final Completable doOnTerminate(final Runnable onTerminate) { - return doOnLifecycle(Functions.emptyConsumer(), new Consumer() { - @Override - public void accept(Throwable e) { - onTerminate.run(); - } - }, onTerminate, Functions.emptyRunnable(), Functions.emptyRunnable()); + return doOnLifecycle(Functions.emptyConsumer(), e -> onTerminate.run(), onTerminate, Functions.emptyRunnable(), Functions.emptyRunnable()); } /** @@ -1391,7 +1305,7 @@ public final Completable endWith(Completable other) { */ @SchedulerSupport(SchedulerKind.CUSTOM) public final NbpObservable endWith(NbpObservable next) { - return next.startWith(this.toNbpObservable()); + return next.startWith(this.toNbpObservable()); } /** @@ -1404,7 +1318,7 @@ public final NbpObservable endWith(NbpObservable next) { */ @SchedulerSupport(SchedulerKind.CUSTOM) public final Observable endWith(Observable next) { - return next.startWith(this.toFlowable()); + return next.startWith(this.toFlowable()); } /** @@ -1522,20 +1436,17 @@ public void onSubscribe(Disposable d) { @SchedulerSupport(SchedulerKind.NONE) public final Completable lift(final CompletableOperator onLift) { Objects.requireNonNull(onLift, "onLift is null"); - return create(new CompletableOnSubscribe() { - @Override - public void accept(CompletableSubscriber s) { - try { - // TODO plugin wrapping + return create(s -> { + try { + // TODO plugin wrapping - CompletableSubscriber sw = onLift.apply(s); - - subscribe(sw); - } catch (NullPointerException ex) { - throw ex; - } catch (Throwable ex) { - throw toNpe(ex); - } + CompletableSubscriber sw = onLift.apply(s); + + subscribe(sw); + } catch (NullPointerException ex) { + throw ex; + } catch (Throwable ex) { + throw toNpe(ex); } }); } @@ -1562,53 +1473,44 @@ public final Completable mergeWith(Completable other) { @SchedulerSupport(SchedulerKind.CUSTOM) public final Completable observeOn(final Scheduler scheduler) { Objects.requireNonNull(scheduler, "scheduler is null"); - return create(new CompletableOnSubscribe() { - @Override - public void accept(final CompletableSubscriber s) { - - final ArrayCompositeResource ad = new ArrayCompositeResource(2, Disposables.consumeAndDispose()); - final Scheduler.Worker w = scheduler.createWorker(); - ad.set(0, w); - - s.onSubscribe(ad); - - subscribe(new CompletableSubscriber() { - - @Override - public void onComplete() { - w.schedule(new Runnable() { - @Override - public void run() { - try { - s.onComplete(); - } finally { - ad.dispose(); - } - } - }); - } + return create(s -> { - @Override - public void onError(final Throwable e) { - w.schedule(new Runnable() { - @Override - public void run() { - try { - s.onError(e); - } finally { - ad.dispose(); - } - } - }); - } + final ArrayCompositeResource ad = new ArrayCompositeResource<>(2, Disposables.consumeAndDispose()); + final Scheduler.Worker w = scheduler.createWorker(); + ad.set(0, w); - @Override - public void onSubscribe(Disposable d) { - ad.set(1, d); - } - - }); - } + s.onSubscribe(ad); + + subscribe(new CompletableSubscriber() { + + @Override + public void onComplete() { + w.schedule(() -> { + try { + s.onComplete(); + } finally { + ad.dispose(); + } + }); + } + + @Override + public void onError(final Throwable e) { + w.schedule(() -> { + try { + s.onError(e); + } finally { + ad.dispose(); + } + }); + } + + @Override + public void onSubscribe(Disposable d) { + ad.set(1, d); + } + + }); }); } @@ -1633,42 +1535,37 @@ public final Completable onErrorComplete() { public final Completable onErrorComplete(final Predicate predicate) { Objects.requireNonNull(predicate, "predicate is null"); - return create(new CompletableOnSubscribe() { + return create(s -> subscribe(new CompletableSubscriber() { + @Override - public void accept(final CompletableSubscriber s) { - subscribe(new CompletableSubscriber() { + public void onComplete() { + s.onComplete(); + } - @Override - public void onComplete() { - s.onComplete(); - } + @Override + public void onError(Throwable e) { + boolean b; - @Override - public void onError(Throwable e) { - boolean b; - - try { - b = predicate.test(e); - } catch (Throwable ex) { - s.onError(new CompositeException(ex, e)); - return; - } - - if (b) { - s.onComplete(); - } else { - s.onError(e); - } - } + try { + b = predicate.test(e); + } catch (Throwable ex) { + s.onError(new CompositeException(ex, e)); + return; + } - @Override - public void onSubscribe(Disposable d) { - s.onSubscribe(d); - } - - }); + if (b) { + s.onComplete(); + } else { + s.onError(e); + } } - }); + + @Override + public void onSubscribe(Disposable d) { + s.onSubscribe(d); + } + + })); } /** @@ -1682,62 +1579,59 @@ public void onSubscribe(Disposable d) { @SchedulerSupport(SchedulerKind.NONE) public final Completable onErrorResumeNext(final Function errorMapper) { Objects.requireNonNull(errorMapper, "errorMapper is null"); - return create(new CompletableOnSubscribe() { - @Override - public void accept(final CompletableSubscriber s) { - final SerialDisposable sd = new SerialDisposable(); - subscribe(new CompletableSubscriber() { + return create(s -> { + final SerialDisposable sd = new SerialDisposable(); + subscribe(new CompletableSubscriber() { - @Override - public void onComplete() { - s.onComplete(); + @Override + public void onComplete() { + s.onComplete(); + } + + @Override + public void onError(Throwable e) { + Completable c; + + try { + c = errorMapper.apply(e); + } catch (Throwable ex) { + s.onError(new CompositeException(ex, e)); + return; } - @Override - public void onError(Throwable e) { - Completable c; - - try { - c = errorMapper.apply(e); - } catch (Throwable ex) { - s.onError(new CompositeException(ex, e)); - return; + if (c == null) { + NullPointerException npe = new NullPointerException("The completable returned is null"); + npe.initCause(e); + s.onError(npe); + return; + } + + c.subscribe(new CompletableSubscriber() { + + @Override + public void onComplete() { + s.onComplete(); } - - if (c == null) { - NullPointerException npe = new NullPointerException("The completable returned is null"); - npe.initCause(e); - s.onError(npe); - return; + + @Override + public void onError(Throwable e) { + s.onError(e); } - - c.subscribe(new CompletableSubscriber() { - @Override - public void onComplete() { - s.onComplete(); - } + @Override + public void onSubscribe(Disposable d) { + sd.set(d); + } - @Override - public void onError(Throwable e) { - s.onError(e); - } + }); + } - @Override - public void onSubscribe(Disposable d) { - sd.set(d); - } - - }); - } + @Override + public void onSubscribe(Disposable d) { + sd.set(d); + } - @Override - public void onSubscribe(Disposable d) { - sd.set(d); - } - - }); - } + }); }); } @@ -1875,7 +1769,7 @@ public final Completable startWith(Completable other) { @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable startWith(NbpObservable other) { Objects.requireNonNull(other, "other is null"); - return other.endWith(this.toNbpObservable()); + return other.endWith(this.toNbpObservable()); } /** * Returns an Observable which first delivers the events @@ -1888,7 +1782,7 @@ public final NbpObservable startWith(NbpObservable other) { @SchedulerSupport(SchedulerKind.NONE) public final Observable startWith(Observable other) { Objects.requireNonNull(other, "other is null"); - return other.endWith(this.toFlowable()); + return other.endWith(this.toFlowable()); } /** @@ -2109,17 +2003,9 @@ public void onSubscribe(Disposable d) { public final Completable subscribeOn(final Scheduler scheduler) { Objects.requireNonNull(scheduler, "scheduler is null"); - return create(new CompletableOnSubscribe() { - @Override - public void accept(final CompletableSubscriber s) { - // FIXME cancellation of this schedule - scheduler.scheduleDirect(new Runnable() { - @Override - public void run() { - subscribe(s); - } - }); - } + return create(s -> { + // FIXME cancellation of this schedule + scheduler.scheduleDirect(() -> subscribe(s)); }); } @@ -2222,12 +2108,7 @@ public final U to(Function converter) { */ @SchedulerSupport(SchedulerKind.NONE) public final Observable toFlowable() { - return Observable.create(new Publisher() { - @Override - public void subscribe(Subscriber s) { - Completable.this.subscribe(s); - } - }); + return Observable.create(this::subscribe); } /** @@ -2238,12 +2119,7 @@ public void subscribe(Subscriber s) { */ @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable toNbpObservable() { - return NbpObservable.create(new NbpOnSubscribe() { - @Override - public void accept(NbpSubscriber s) { - subscribe(s); - } - }); + return NbpObservable.create(this::subscribe); } /** @@ -2257,41 +2133,38 @@ public void accept(NbpSubscriber s) { @SchedulerSupport(SchedulerKind.NONE) public final Single toSingle(final Supplier completionValueSupplier) { Objects.requireNonNull(completionValueSupplier, "completionValueSupplier is null"); - return Single.create(new SingleOnSubscribe() { - @Override - public void accept(final SingleSubscriber s) { - subscribe(new CompletableSubscriber() { - - @Override - public void onComplete() { - T v; + return Single.create(s -> { + subscribe(new CompletableSubscriber() { - try { - v = completionValueSupplier.get(); - } catch (Throwable e) { - s.onError(e); - return; - } - - if (v == null) { - s.onError(new NullPointerException("The value supplied is null")); - } else { - s.onSuccess(v); - } - } + @Override + public void onComplete() { + T v; - @Override - public void onError(Throwable e) { + try { + v = completionValueSupplier.get(); + } catch (Throwable e) { s.onError(e); + return; } - @Override - public void onSubscribe(Disposable d) { - s.onSubscribe(d); + if (v == null) { + s.onError(new NullPointerException("The value supplied is null")); + } else { + s.onSuccess(v); } - - }); - } + } + + @Override + public void onError(Throwable e) { + s.onError(e); + } + + @Override + public void onSubscribe(Disposable d) { + s.onSubscribe(d); + } + + }); }); } @@ -2306,12 +2179,7 @@ public void onSubscribe(Disposable d) { @SchedulerSupport(SchedulerKind.NONE) public final Single toSingleDefault(final T completionValue) { Objects.requireNonNull(completionValue, "completionValue is null"); - return toSingle(new Supplier() { - @Override - public T get() { - return completionValue; - } - }); + return toSingle(() -> completionValue); } /** @@ -2324,38 +2192,21 @@ public T get() { @SchedulerSupport(SchedulerKind.CUSTOM) public final Completable unsubscribeOn(final Scheduler scheduler) { Objects.requireNonNull(scheduler, "scheduler is null"); - return create(new CompletableOnSubscribe() { + return create(s -> subscribe(new CompletableSubscriber() { @Override - public void accept(final CompletableSubscriber s) { - subscribe(new CompletableSubscriber() { - - @Override - public void onComplete() { - s.onComplete(); - } + public void onComplete() { + s.onComplete(); + } - @Override - public void onError(Throwable e) { - s.onError(e); - } + @Override + public void onError(Throwable e) { + s.onError(e); + } - @Override - public void onSubscribe(final Disposable d) { - s.onSubscribe(new Disposable() { - @Override - public void dispose() { - scheduler.scheduleDirect(new Runnable() { - @Override - public void run() { - d.dispose(); - } - }); - } - }); - } - - }); + @Override + public void onSubscribe(final Disposable d) { + s.onSubscribe(() -> scheduler.scheduleDirect(d::dispose)); } - }); + })); } } \ No newline at end of file diff --git a/src/main/java/io/reactivex/NbpObservable.java b/rxjava/src/main/java/io/reactivex/NbpObservable.java similarity index 77% rename from src/main/java/io/reactivex/NbpObservable.java rename to rxjava/src/main/java/io/reactivex/NbpObservable.java index 7e865606cc..480fb4d1e3 100644 --- a/src/main/java/io/reactivex/NbpObservable.java +++ b/rxjava/src/main/java/io/reactivex/NbpObservable.java @@ -65,27 +65,19 @@ public interface NbpTransformer extends Function EMPTY = create(new NbpOnSubscribe() { - @Override - public void accept(NbpSubscriber s) { - s.onSubscribe(EmptyDisposable.INSTANCE); - s.onComplete(); - } + static final NbpObservable EMPTY = create(s -> { + s.onSubscribe(EmptyDisposable.INSTANCE); + s.onComplete(); }); /** A never NbpObservable instance as there is no need to instantiate this more than once. */ - static final NbpObservable NEVER = create(new NbpOnSubscribe() { - @Override - public void accept(NbpSubscriber s) { - s.onSubscribe(EmptyDisposable.INSTANCE); - } - }); + static final NbpObservable NEVER = create(s -> s.onSubscribe(EmptyDisposable.INSTANCE)); static final Object OBJECT = new Object(); public static NbpObservable amb(Iterable> sources) { Objects.requireNonNull(sources, "sources is null"); - return create(new NbpOnSubscribeAmb(null, sources)); + return create(new NbpOnSubscribeAmb<>(null, sources)); } @SuppressWarnings("unchecked") @@ -99,7 +91,7 @@ public static NbpObservable amb(NbpObservable... sources) { if (len == 1) { return (NbpObservable)sources[0]; } - return create(new NbpOnSubscribeAmb(sources, null)); + return create(new NbpOnSubscribeAmb<>(sources, null)); } /** @@ -133,7 +125,7 @@ public static NbpObservable combineLatest(Iterable(null, sources, combiner, s, delayError)); + return create(new NbpOnSubscribeCombineLatest<>(null, sources, combiner, s, delayError)); } @SchedulerSupport(SchedulerKind.NONE) @@ -155,18 +147,16 @@ public static NbpObservable combineLatest(NbpObservable[] } // the queue holds a pair of values so we need to double the capacity int s = bufferSize << 1; - return create(new NbpOnSubscribeCombineLatest(sources, null, combiner, s, delayError)); + return create(new NbpOnSubscribeCombineLatest<>(sources, null, combiner, s, delayError)); } - - @SuppressWarnings("unchecked") + @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable combineLatest( NbpObservable p1, NbpObservable p2, BiFunction combiner) { return combineLatest(Functions.toFunction(combiner), false, bufferSize(), p1, p2); } - - @SuppressWarnings("unchecked") + @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable combineLatest( NbpObservable p1, NbpObservable p2, @@ -174,8 +164,7 @@ public static NbpObservable combineLatest( Function3 combiner) { return combineLatest(Functions.toFunction(combiner), false, bufferSize(), p1, p2, p3); } - - @SuppressWarnings("unchecked") + @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable combineLatest( NbpObservable p1, NbpObservable p2, @@ -183,8 +172,7 @@ public static NbpObservable combineLatest( Function4 combiner) { return combineLatest(Functions.toFunction(combiner), false, bufferSize(), p1, p2, p3, p4); } - - @SuppressWarnings("unchecked") + @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable combineLatest( NbpObservable p1, NbpObservable p2, @@ -193,8 +181,7 @@ public static NbpObservable combineLatest( Function5 combiner) { return combineLatest(Functions.toFunction(combiner), false, bufferSize(), p1, p2, p3, p4, p5); } - - @SuppressWarnings("unchecked") + @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable combineLatest( NbpObservable p1, NbpObservable p2, @@ -203,8 +190,7 @@ public static NbpObservable combineLatest( Function6 combiner) { return combineLatest(Functions.toFunction(combiner), false, bufferSize(), p1, p2, p3, p4, p5, p6); } - - @SuppressWarnings("unchecked") + @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable combineLatest( NbpObservable p1, NbpObservable p2, @@ -215,7 +201,6 @@ public static NbpObservable combineLatest( return combineLatest(Functions.toFunction(combiner), false, bufferSize(), p1, p2, p3, p4, p5, p6, p7); } - @SuppressWarnings("unchecked") @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable combineLatest( NbpObservable p1, NbpObservable p2, @@ -226,7 +211,6 @@ public static NbpObservable combineLatest return combineLatest(Functions.toFunction(combiner), false, bufferSize(), p1, p2, p3, p4, p5, p6, p7, p8); } - @SuppressWarnings("unchecked") @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable combineLatest( NbpObservable p1, NbpObservable p2, @@ -238,29 +222,26 @@ public static NbpObservable combineLa return combineLatest(Functions.toFunction(combiner), false, bufferSize(), p1, p2, p3, p4, p5, p6, p7, p8, p9); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable concat(int prefetch, Iterable> sources) { Objects.requireNonNull(sources, "sources is null"); - return fromIterable(sources).concatMap((Function)Functions.identity(), prefetch); + return fromIterable(sources).concatMap(Functions.identity(), prefetch); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable concat(Iterable> sources) { Objects.requireNonNull(sources, "sources is null"); - return fromIterable(sources).concatMap((Function)Functions.identity()); + return fromIterable(sources).concatMap(Functions.identity()); } @SchedulerSupport(SchedulerKind.NONE) - public static final NbpObservable concat(NbpObservable> sources) { + public static NbpObservable concat(NbpObservable> sources) { return concat(sources, bufferSize()); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @SchedulerSupport(SchedulerKind.NONE) - public static final NbpObservable concat(NbpObservable> sources, int bufferSize) { - return sources.concatMap((Function)Functions.identity()); + public static NbpObservable concat(NbpObservable> sources, int bufferSize) { + return sources.concatMap(Functions.identity()); } @SuppressWarnings("unchecked") @@ -339,11 +320,10 @@ public static NbpObservable concat( return concatArray(p1, p2, p3, p4, p5, p6, p7, p8, p9); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable concatArray(int prefetch, NbpObservable... sources) { Objects.requireNonNull(sources, "sources is null"); - return fromArray(sources).concatMap((Function)Functions.identity(), prefetch); + return fromArray(sources).concatMap(Functions.identity(), prefetch); } /** @@ -364,19 +344,19 @@ public static NbpObservable concatArray(NbpObservable... sou if (sources.length == 1) { return (NbpObservable)sources[0]; } - return fromArray(sources).concatMap((Function)Functions.identity()); + return fromArray(sources).concatMap(Functions.identity()); } public static NbpObservable create(NbpOnSubscribe onSubscribe) { Objects.requireNonNull(onSubscribe, "onSubscribe is null"); // TODO plugin wrapper - return new NbpObservable(onSubscribe); + return new NbpObservable<>(onSubscribe); } @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable defer(Supplier> supplier) { Objects.requireNonNull(supplier, "supplier is null"); - return create(new NbpOnSubscribeDefer(supplier)); + return create(new NbpOnSubscribeDefer<>(supplier)); } @SchedulerSupport(SchedulerKind.NONE) @@ -388,18 +368,13 @@ public static NbpObservable empty() { @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable error(Supplier errorSupplier) { Objects.requireNonNull(errorSupplier, "errorSupplier is null"); - return create(new NbpOnSubscribeErrorSource(errorSupplier)); + return create(new NbpOnSubscribeErrorSource<>(errorSupplier)); } @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable error(final Throwable e) { Objects.requireNonNull(e, "e is null"); - return error(new Supplier() { - @Override - public Throwable get() { - return e; - } - }); + return error(() -> e); } @SchedulerSupport(SchedulerKind.NONE) @@ -411,14 +386,14 @@ public static NbpObservable fromArray(T... values) { if (values.length == 1) { return just(values[0]); } - return create(new NbpOnSubscribeArraySource(values)); + return create(new NbpOnSubscribeArraySource<>(values)); } // TODO match naming with RxJava 1.x @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable fromCallable(Callable supplier) { Objects.requireNonNull(supplier, "supplier is null"); - return create(new NbpOnSubscribeScalarAsyncSource(supplier)); + return create(new NbpOnSubscribeScalarAsyncSource<>(supplier)); } /* @@ -429,15 +404,14 @@ public static NbpObservable fromCallable(Callable supplier) @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable fromFuture(Future future) { Objects.requireNonNull(future, "future is null"); - return create(new NbpOnSubscribeFutureSource(future, 0L, null)); + return create(new NbpOnSubscribeFutureSource<>(future, 0L, null)); } @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable fromFuture(Future future, long timeout, TimeUnit unit) { Objects.requireNonNull(future, "future is null"); Objects.requireNonNull(unit, "unit is null"); - NbpObservable o = create(new NbpOnSubscribeFutureSource(future, timeout, unit)); - return o; + return create(new NbpOnSubscribeFutureSource<>(future, timeout, unit)); } @SchedulerSupport(SchedulerKind.CUSTOM) @@ -456,64 +430,52 @@ public static NbpObservable fromFuture(Future future, Schedu public static NbpObservable fromIterable(Iterable source) { Objects.requireNonNull(source, "source is null"); - return create(new NbpOnSubscribeIterableSource(source)); + return create(new NbpOnSubscribeIterableSource<>(source)); } public static NbpObservable fromPublisher(final Publisher publisher) { Objects.requireNonNull(publisher, "publisher is null"); - return create(new NbpOnSubscribe() { - @Override - public void accept(final NbpSubscriber s) { - publisher.subscribe(new Subscriber() { - - @Override - public void onComplete() { - s.onComplete(); - } + return create(s -> + publisher.subscribe(new Subscriber() { + @Override + public void onComplete() { + s.onComplete(); + } - @Override - public void onError(Throwable t) { - s.onError(t); - } + @Override + public void onError(Throwable t) { + s.onError(t); + } - @Override - public void onNext(T t) { - s.onNext(t); - } + @Override + public void onNext(T t) { + s.onNext(t); + } - @Override - public void onSubscribe(Subscription inner) { - s.onSubscribe(Disposables.from(inner)); - inner.request(Long.MAX_VALUE); - } - - }); - } - }); + @Override + public void onSubscribe(Subscription inner) { + s.onSubscribe(Disposables.from(inner)); + inner.request(Long.MAX_VALUE); + } + }) + ); } @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable generate(final Consumer> generator) { Objects.requireNonNull(generator, "generator is null"); - return generate(Functions.nullSupplier(), - new BiFunction, Object>() { - @Override - public Object apply(Object s, NbpSubscriber o) { - generator.accept(o); - return s; - } - }, Functions.emptyConsumer()); + return generate(Functions.nullSupplier(), (s, o) -> { + generator.accept(o); + return s; + }, Functions.emptyConsumer()); } @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable generate(Supplier initialState, final BiConsumer> generator) { Objects.requireNonNull(generator, "generator is null"); - return generate(initialState, new BiFunction, S>() { - @Override - public S apply(S s, NbpSubscriber o) { - generator.accept(s, o); - return s; - } + return generate(initialState, (s, o) -> { + generator.accept(s, o); + return s; }, Functions.emptyConsumer()); } @@ -523,12 +485,9 @@ public static NbpObservable generate( final BiConsumer> generator, Consumer disposeState) { Objects.requireNonNull(generator, "generator is null"); - return generate(initialState, new BiFunction, S>() { - @Override - public S apply(S s, NbpSubscriber o) { - generator.accept(s, o); - return s; - } + return generate(initialState, (s, o) -> { + generator.accept(s, o); + return s; }, disposeState); } @@ -542,7 +501,7 @@ public static NbpObservable generate(Supplier initialState, BiFunct Objects.requireNonNull(initialState, "initialState is null"); Objects.requireNonNull(generator, "generator is null"); Objects.requireNonNull(disposeState, "diposeState is null"); - return create(new NbpOnSubscribeGenerate(initialState, generator, disposeState)); + return create(new NbpOnSubscribeGenerate<>(initialState, generator, disposeState)); } @SchedulerSupport(SchedulerKind.COMPUTATION) @@ -601,12 +560,12 @@ public static NbpObservable intervalRange(long start, long count, long ini public static NbpObservable just(T value) { Objects.requireNonNull(value, "The value is null"); - return new NbpObservableScalarSource(value); + return new NbpObservableScalarSource<>(value); } @SuppressWarnings("unchecked") @SchedulerSupport(SchedulerKind.NONE) - public static final NbpObservable just(T v1, T v2) { + public static NbpObservable just(T v1, T v2) { Objects.requireNonNull(v1, "The first value is null"); Objects.requireNonNull(v2, "The second value is null"); @@ -615,7 +574,7 @@ public static final NbpObservable just(T v1, T v2) { @SuppressWarnings("unchecked") @SchedulerSupport(SchedulerKind.NONE) - public static final NbpObservable just(T v1, T v2, T v3) { + public static NbpObservable just(T v1, T v2, T v3) { Objects.requireNonNull(v1, "The first value is null"); Objects.requireNonNull(v2, "The second value is null"); Objects.requireNonNull(v3, "The third value is null"); @@ -625,7 +584,7 @@ public static final NbpObservable just(T v1, T v2, T v3) { @SuppressWarnings("unchecked") @SchedulerSupport(SchedulerKind.NONE) - public static final NbpObservable just(T v1, T v2, T v3, T v4) { + public static NbpObservable just(T v1, T v2, T v3, T v4) { Objects.requireNonNull(v1, "The first value is null"); Objects.requireNonNull(v2, "The second value is null"); Objects.requireNonNull(v3, "The third value is null"); @@ -636,7 +595,7 @@ public static final NbpObservable just(T v1, T v2, T v3, T v4) { @SuppressWarnings("unchecked") @SchedulerSupport(SchedulerKind.NONE) - public static final NbpObservable just(T v1, T v2, T v3, T v4, T v5) { + public static NbpObservable just(T v1, T v2, T v3, T v4, T v5) { Objects.requireNonNull(v1, "The first value is null"); Objects.requireNonNull(v2, "The second value is null"); Objects.requireNonNull(v3, "The third value is null"); @@ -648,7 +607,7 @@ public static final NbpObservable just(T v1, T v2, T v3, T v4, T v5) { @SuppressWarnings("unchecked") @SchedulerSupport(SchedulerKind.NONE) - public static final NbpObservable just(T v1, T v2, T v3, T v4, T v5, T v6) { + public static NbpObservable just(T v1, T v2, T v3, T v4, T v5, T v6) { Objects.requireNonNull(v1, "The first value is null"); Objects.requireNonNull(v2, "The second value is null"); Objects.requireNonNull(v3, "The third value is null"); @@ -661,7 +620,7 @@ public static final NbpObservable just(T v1, T v2, T v3, T v4, T v5, T v6 @SuppressWarnings("unchecked") @SchedulerSupport(SchedulerKind.NONE) - public static final NbpObservable just(T v1, T v2, T v3, T v4, T v5, T v6, T v7) { + public static NbpObservable just(T v1, T v2, T v3, T v4, T v5, T v6, T v7) { Objects.requireNonNull(v1, "The first value is null"); Objects.requireNonNull(v2, "The second value is null"); Objects.requireNonNull(v3, "The third value is null"); @@ -675,7 +634,7 @@ public static final NbpObservable just(T v1, T v2, T v3, T v4, T v5, T v6 @SuppressWarnings("unchecked") @SchedulerSupport(SchedulerKind.NONE) - public static final NbpObservable just(T v1, T v2, T v3, T v4, T v5, T v6, T v7, T v8) { + public static NbpObservable just(T v1, T v2, T v3, T v4, T v5, T v6, T v7, T v8) { Objects.requireNonNull(v1, "The first value is null"); Objects.requireNonNull(v2, "The second value is null"); Objects.requireNonNull(v3, "The third value is null"); @@ -690,7 +649,7 @@ public static final NbpObservable just(T v1, T v2, T v3, T v4, T v5, T v6 @SuppressWarnings("unchecked") @SchedulerSupport(SchedulerKind.NONE) - public static final NbpObservable just(T v1, T v2, T v3, T v4, T v5, T v6, T v7, T v8, T v9) { + public static NbpObservable just(T v1, T v2, T v3, T v4, T v5, T v6, T v7, T v8, T v9) { Objects.requireNonNull(v1, "The first value is null"); Objects.requireNonNull(v2, "The second value is null"); Objects.requireNonNull(v3, "The third value is null"); @@ -704,68 +663,58 @@ public static final NbpObservable just(T v1, T v2, T v3, T v4, T v5, T v6 return fromArray(v1, v2, v3, v4, v5, v6, v7, v8, v9); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable merge(int maxConcurrency, int bufferSize, Iterable> sources) { - return fromIterable(sources).flatMap((Function)Functions.identity(), false, maxConcurrency, bufferSize); + return fromIterable(sources).flatMap(Functions.identity(), false, maxConcurrency, bufferSize); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable merge(int maxConcurrency, int bufferSize, NbpObservable... sources) { - return fromArray(sources).flatMap((Function)Functions.identity(), false, maxConcurrency, bufferSize); + return fromArray(sources).flatMap(Functions.identity(), false, maxConcurrency, bufferSize); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable merge(int maxConcurrency, NbpObservable... sources) { - return fromArray(sources).flatMap((Function)Functions.identity(), maxConcurrency); + return fromArray(sources).flatMap(Functions.identity(), maxConcurrency); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable merge(Iterable> sources) { - return fromIterable(sources).flatMap((Function)Functions.identity()); + return fromIterable(sources).flatMap(Functions.identity()); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable merge(Iterable> sources, int maxConcurrency) { - return fromIterable(sources).flatMap((Function)Functions.identity(), maxConcurrency); + return fromIterable(sources).flatMap(Functions.identity(), maxConcurrency); } - @SuppressWarnings({ "unchecked", "rawtypes" }) public static NbpObservable merge(NbpObservable> sources) { - return sources.flatMap((Function)Functions.identity()); + return sources.flatMap(Functions.identity()); } - - @SuppressWarnings({ "unchecked", "rawtypes" }) + @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable merge(NbpObservable> sources, int maxConcurrency) { - return sources.flatMap((Function)Functions.identity(), maxConcurrency); + return sources.flatMap(Functions.identity(), maxConcurrency); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable merge(NbpObservable p1, NbpObservable p2) { Objects.requireNonNull(p1, "p1 is null"); Objects.requireNonNull(p2, "p2 is null"); - return fromArray(p1, p2).flatMap((Function)Functions.identity(), false, 2); + return fromArray(p1, p2).flatMap(Functions.identity(), false, 2); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable merge(NbpObservable p1, NbpObservable p2, NbpObservable p3) { Objects.requireNonNull(p1, "p1 is null"); Objects.requireNonNull(p2, "p2 is null"); Objects.requireNonNull(p3, "p3 is null"); - return fromArray(p1, p2, p3).flatMap((Function)Functions.identity(), false, 3); + return fromArray(p1, p2, p3).flatMap(Functions.identity(), false, 3); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable merge( @@ -775,76 +724,65 @@ public static NbpObservable merge( Objects.requireNonNull(p2, "p2 is null"); Objects.requireNonNull(p3, "p3 is null"); Objects.requireNonNull(p4, "p4 is null"); - return fromArray(p1, p2, p3, p4).flatMap((Function)Functions.identity(), false, 4); + return fromArray(p1, p2, p3, p4).flatMap(Functions.identity(), false, 4); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable merge(NbpObservable... sources) { - return fromArray(sources).flatMap((Function)Functions.identity(), sources.length); + return fromArray(sources).flatMap(Functions.identity(), sources.length); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable mergeDelayError(boolean delayErrors, Iterable> sources) { - return fromIterable(sources).flatMap((Function)Functions.identity(), true); + return fromIterable(sources).flatMap(Functions.identity(), true); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable mergeDelayError(int maxConcurrency, int bufferSize, Iterable> sources) { - return fromIterable(sources).flatMap((Function)Functions.identity(), true, maxConcurrency, bufferSize); + return fromIterable(sources).flatMap(Functions.identity(), true, maxConcurrency, bufferSize); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable mergeDelayError(int maxConcurrency, int bufferSize, NbpObservable... sources) { - return fromArray(sources).flatMap((Function)Functions.identity(), true, maxConcurrency, bufferSize); + return fromArray(sources).flatMap(Functions.identity(), true, maxConcurrency, bufferSize); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable mergeDelayError(int maxConcurrency, Iterable> sources) { - return fromIterable(sources).flatMap((Function)Functions.identity(), true, maxConcurrency); + return fromIterable(sources).flatMap(Functions.identity(), true, maxConcurrency); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable mergeDelayError(int maxConcurrency, NbpObservable... sources) { - return fromArray(sources).flatMap((Function)Functions.identity(), true, maxConcurrency); + return fromArray(sources).flatMap(Functions.identity(), true, maxConcurrency); } - @SuppressWarnings({ "unchecked", "rawtypes" }) public static NbpObservable mergeDelayError(NbpObservable> sources) { - return sources.flatMap((Function)Functions.identity(), true); + return sources.flatMap(Functions.identity(), true); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable mergeDelayError(NbpObservable> sources, int maxConcurrency) { - return sources.flatMap((Function)Functions.identity(), true, maxConcurrency); + return sources.flatMap(Functions.identity(), true, maxConcurrency); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable mergeDelayError(NbpObservable p1, NbpObservable p2) { Objects.requireNonNull(p1, "p1 is null"); Objects.requireNonNull(p2, "p2 is null"); - return fromArray(p1, p2).flatMap((Function)Functions.identity(), true, 2); + return fromArray(p1, p2).flatMap(Functions.identity(), true, 2); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable mergeDelayError(NbpObservable p1, NbpObservable p2, NbpObservable p3) { Objects.requireNonNull(p1, "p1 is null"); Objects.requireNonNull(p2, "p2 is null"); Objects.requireNonNull(p3, "p3 is null"); - return fromArray(p1, p2, p3).flatMap((Function)Functions.identity(), true, 3); + return fromArray(p1, p2, p3).flatMap(Functions.identity(), true, 3); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable mergeDelayError( @@ -854,13 +792,12 @@ public static NbpObservable mergeDelayError( Objects.requireNonNull(p2, "p2 is null"); Objects.requireNonNull(p3, "p3 is null"); Objects.requireNonNull(p4, "p4 is null"); - return fromArray(p1, p2, p3, p4).flatMap((Function)Functions.identity(), true, 4); + return fromArray(p1, p2, p3, p4).flatMap(Functions.identity(), true, 4); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable mergeDelayError(NbpObservable... sources) { - return fromArray(sources).flatMap((Function)Functions.identity(), true, sources.length); + return fromArray(sources).flatMap(Functions.identity(), true, sources.length); } @SchedulerSupport(SchedulerKind.NONE) @@ -883,9 +820,7 @@ public static NbpObservable range(final int start, final int count) { if ((long)start + (count - 1) > Integer.MAX_VALUE) { throw new IllegalArgumentException("Integer overflow"); } - return create(new NbpOnSubscribe() { - @Override - public void accept(NbpSubscriber s) { + return create(s -> { BooleanDisposable d = new BooleanDisposable(); s.onSubscribe(d); @@ -897,7 +832,7 @@ public void accept(NbpSubscriber s) { s.onComplete(); } } - }); + ); } @SchedulerSupport(SchedulerKind.NONE) @@ -916,7 +851,7 @@ public static NbpObservable sequenceEqual(NbpObservable(p1, p2, isEqual, bufferSize)); + return create(new NbpOnSubscribeSequenceEqual<>(p1, p2, isEqual, bufferSize)); } @SchedulerSupport(SchedulerKind.NONE) @@ -924,17 +859,15 @@ public static NbpObservable sequenceEqual(NbpObservable NbpObservable switchOnNext(int bufferSize, NbpObservable> sources) { - return sources.switchMap((Function)Functions.identity(), bufferSize); + return sources.switchMap(Functions.identity(), bufferSize); } - @SuppressWarnings({ "rawtypes", "unchecked" }) @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable switchOnNext(NbpObservable> sources) { - return sources.switchMap((Function)Functions.identity()); + return sources.switchMap(Functions.identity()); } @SchedulerSupport(SchedulerKind.COMPUTATION) @@ -963,7 +896,7 @@ public static NbpObservable using(Supplier resourceSuppli Objects.requireNonNull(resourceSupplier, "resourceSupplier is null"); Objects.requireNonNull(sourceSupplier, "sourceSupplier is null"); Objects.requireNonNull(disposer, "disposer is null"); - return create(new NbpOnSubscribeUsing(resourceSupplier, sourceSupplier, disposer, eager)); + return create(new NbpOnSubscribeUsing<>(resourceSupplier, sourceSupplier, disposer, eager)); } private static void validateBufferSize(int bufferSize) { @@ -976,7 +909,7 @@ private static void validateBufferSize(int bufferSize) { public static NbpObservable zip(Iterable> sources, Function zipper) { Objects.requireNonNull(zipper, "zipper is null"); Objects.requireNonNull(sources, "sources is null"); - return create(new NbpOnSubscribeZip(null, sources, zipper, bufferSize(), false)); + return create(new NbpOnSubscribeZip<>(null, sources, zipper, bufferSize(), false)); } @SchedulerSupport(SchedulerKind.NONE) @@ -990,7 +923,6 @@ public NbpObservable apply(List> list) { }); } - @SuppressWarnings("unchecked") @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable zip( NbpObservable p1, NbpObservable p2, @@ -998,7 +930,6 @@ public static NbpObservable zip( return zipArray(Functions.toFunction(zipper), false, bufferSize(), p1, p2); } - @SuppressWarnings("unchecked") @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable zip( NbpObservable p1, NbpObservable p2, @@ -1006,7 +937,6 @@ public static NbpObservable zip( return zipArray(Functions.toFunction(zipper), delayError, bufferSize(), p1, p2); } - @SuppressWarnings("unchecked") @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable zip( NbpObservable p1, NbpObservable p2, @@ -1014,7 +944,6 @@ public static NbpObservable zip( return zipArray(Functions.toFunction(zipper), delayError, bufferSize, p1, p2); } - @SuppressWarnings("unchecked") @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable zip( NbpObservable p1, NbpObservable p2, NbpObservable p3, @@ -1022,7 +951,6 @@ public static NbpObservable zip( return zipArray(Functions.toFunction(zipper), false, bufferSize(), p1, p2, p3); } - @SuppressWarnings("unchecked") @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable zip( NbpObservable p1, NbpObservable p2, NbpObservable p3, @@ -1031,7 +959,6 @@ public static NbpObservable zip( return zipArray(Functions.toFunction(zipper), false, bufferSize(), p1, p2, p3, p4); } - @SuppressWarnings("unchecked") @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable zip( NbpObservable p1, NbpObservable p2, NbpObservable p3, @@ -1040,7 +967,6 @@ public static NbpObservable zip( return zipArray(Functions.toFunction(zipper), false, bufferSize(), p1, p2, p3, p4, p5); } - @SuppressWarnings("unchecked") @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable zip( NbpObservable p1, NbpObservable p2, NbpObservable p3, @@ -1049,7 +975,6 @@ public static NbpObservable zip( return zipArray(Functions.toFunction(zipper), false, bufferSize(), p1, p2, p3, p4, p5, p6); } - @SuppressWarnings("unchecked") @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable zip( NbpObservable p1, NbpObservable p2, NbpObservable p3, @@ -1059,7 +984,6 @@ public static NbpObservable zip( return zipArray(Functions.toFunction(zipper), false, bufferSize(), p1, p2, p3, p4, p5, p6, p7); } - @SuppressWarnings("unchecked") @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable zip( NbpObservable p1, NbpObservable p2, NbpObservable p3, @@ -1069,7 +993,6 @@ public static NbpObservable zip( return zipArray(Functions.toFunction(zipper), false, bufferSize(), p1, p2, p3, p4, p5, p6, p7, p8); } - @SuppressWarnings("unchecked") @SchedulerSupport(SchedulerKind.NONE) public static NbpObservable zip( NbpObservable p1, NbpObservable p2, NbpObservable p3, @@ -1087,7 +1010,7 @@ public static NbpObservable zipArray(Function(sources, null, zipper, bufferSize, delayError)); + return create(new NbpOnSubscribeZip<>(sources, null, zipper, bufferSize, delayError)); } @SchedulerSupport(SchedulerKind.NONE) @@ -1097,7 +1020,7 @@ public static NbpObservable zipIterable(Function(null, sources, zipper, bufferSize, delayError)); + return create(new NbpOnSubscribeZip<>(null, sources, zipper, bufferSize, delayError)); } @@ -1110,7 +1033,7 @@ protected NbpObservable(NbpOnSubscribe onSubscribe) { @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable all(Predicate predicate) { Objects.requireNonNull(predicate, "predicate is null"); - return lift(new NbpOperatorAll(predicate)); + return lift(new NbpOperatorAll<>(predicate)); } @SuppressWarnings("unchecked") @@ -1123,17 +1046,12 @@ public final NbpObservable ambWith(NbpObservable other) { @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable any(Predicate predicate) { Objects.requireNonNull(predicate, "predicate is null"); - return lift(new NbpOperatorAny(predicate)); + return lift(new NbpOperatorAny<>(predicate)); } @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable asObservable() { - return create(new NbpOnSubscribe() { - @Override - public void accept(NbpSubscriber s) { - NbpObservable.this.subscribe(s); - } - }); + return create(this::subscribe); } @SchedulerSupport(SchedulerKind.NONE) @@ -1143,12 +1061,7 @@ public final NbpObservable> buffer(int count) { @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable> buffer(int count, int skip) { - return buffer(count, skip, new Supplier>() { - @Override - public List get() { - return new ArrayList(); - } - }); + return buffer(count, skip, ArrayList::new); } @SchedulerSupport(SchedulerKind.NONE) @@ -1160,7 +1073,7 @@ public final > NbpObservable buffer(int count throw new IllegalArgumentException("skip > 0 required but it was " + count); } Objects.requireNonNull(bufferSupplier, "bufferSupplier is null"); - return lift(new NbpOperatorBuffer(count, skip, bufferSupplier)); + return lift(new NbpOperatorBuffer<>(count, skip, bufferSupplier)); } @SchedulerSupport(SchedulerKind.NONE) @@ -1170,22 +1083,12 @@ public final > NbpObservable buffer(int count @SchedulerSupport(SchedulerKind.COMPUTATION) public final NbpObservable> buffer(long timespan, long timeskip, TimeUnit unit) { - return buffer(timespan, timeskip, unit, Schedulers.computation(), new Supplier>() { - @Override - public List get() { - return new ArrayList(); - } - }); + return buffer(timespan, timeskip, unit, Schedulers.computation(), ArrayList::new); } @SchedulerSupport(SchedulerKind.CUSTOM) public final NbpObservable> buffer(long timespan, long timeskip, TimeUnit unit, Scheduler scheduler) { - return buffer(timespan, timeskip, unit, scheduler, new Supplier>() { - @Override - public List get() { - return new ArrayList(); - } - }); + return buffer(timespan, timeskip, unit, scheduler, ArrayList::new); } @SchedulerSupport(SchedulerKind.CUSTOM) @@ -1193,7 +1096,7 @@ public final > NbpObservable buffer(long time Objects.requireNonNull(unit, "unit is null"); Objects.requireNonNull(scheduler, "scheduler is null"); Objects.requireNonNull(bufferSupplier, "bufferSupplier is null"); - return lift(new NbpOperatorBufferTimed(timespan, timeskip, unit, scheduler, bufferSupplier, Integer.MAX_VALUE, false)); + return lift(new NbpOperatorBufferTimed<>(timespan, timeskip, unit, scheduler, bufferSupplier, Integer.MAX_VALUE, false)); } @SchedulerSupport(SchedulerKind.COMPUTATION) @@ -1208,12 +1111,7 @@ public final NbpObservable> buffer(long timespan, TimeUnit unit, int cou @SchedulerSupport(SchedulerKind.CUSTOM) public final NbpObservable> buffer(long timespan, TimeUnit unit, int count, Scheduler scheduler) { - return buffer(timespan, unit, count, scheduler, new Supplier>() { - @Override - public List get() { - return new ArrayList(); - } - }, false); + return buffer(timespan, unit, count, scheduler, ArrayList::new, false); } @SchedulerSupport(SchedulerKind.CUSTOM) @@ -1228,29 +1126,19 @@ public final > NbpObservable buffer( if (count <= 0) { throw new IllegalArgumentException("count > 0 required but it was " + count); } - return lift(new NbpOperatorBufferTimed(timespan, timespan, unit, scheduler, bufferSupplier, count, restartTimerOnMaxSize)); + return lift(new NbpOperatorBufferTimed<>(timespan, timespan, unit, scheduler, bufferSupplier, count, restartTimerOnMaxSize)); } @SchedulerSupport(SchedulerKind.CUSTOM) public final NbpObservable> buffer(long timespan, TimeUnit unit, Scheduler scheduler) { - return buffer(timespan, unit, Integer.MAX_VALUE, scheduler, new Supplier>() { - @Override - public List get() { - return new ArrayList(); - } - }, false); + return buffer(timespan, unit, Integer.MAX_VALUE, scheduler, ArrayList::new, false); } @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable> buffer( NbpObservable bufferOpenings, Function> bufferClosingSelector) { - return buffer(bufferOpenings, bufferClosingSelector, new Supplier>() { - @Override - public List get() { - return new ArrayList(); - } - }); + return buffer(bufferOpenings, bufferClosingSelector, ArrayList::new); } @SchedulerSupport(SchedulerKind.NONE) @@ -1261,7 +1149,7 @@ public final > NbpObservable Objects.requireNonNull(bufferOpenings, "bufferOpenings is null"); Objects.requireNonNull(bufferClosingSelector, "bufferClosingSelector is null"); Objects.requireNonNull(bufferSupplier, "bufferSupplier is null"); - return lift(new NbpOperatorBufferBoundary(bufferOpenings, bufferClosingSelector, bufferSupplier)); + return lift(new NbpOperatorBufferBoundary<>(bufferOpenings, bufferClosingSelector, bufferSupplier)); } @SchedulerSupport(SchedulerKind.NONE) @@ -1269,39 +1157,24 @@ public final NbpObservable> buffer(NbpObservable boundary) { /* * XXX: javac complains if this is not manually cast, Eclipse is fine */ - return buffer(boundary, new Supplier>() { - @Override - public List get() { - return new ArrayList(); - } - }); + return buffer(boundary, () -> new ArrayList<>()); } @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable> buffer(NbpObservable boundary, final int initialCapacity) { - return buffer(boundary, new Supplier>() { - @Override - public List get() { - return new ArrayList(initialCapacity); - } - }); + return buffer(boundary, () -> new ArrayList<>(initialCapacity)); } @SchedulerSupport(SchedulerKind.NONE) public final > NbpObservable buffer(NbpObservable boundary, Supplier bufferSupplier) { Objects.requireNonNull(boundary, "boundary is null"); Objects.requireNonNull(bufferSupplier, "bufferSupplier is null"); - return lift(new NbpOperatorBufferExactBoundary(boundary, bufferSupplier)); + return lift(new NbpOperatorBufferExactBoundary<>(boundary, bufferSupplier)); } @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable> buffer(Supplier> boundarySupplier) { - return buffer(boundarySupplier, new Supplier>() { - @Override - public List get() { - return new ArrayList(); - } - }); + return buffer(boundarySupplier, ArrayList::new); } @@ -1309,7 +1182,7 @@ public List get() { public final > NbpObservable buffer(Supplier> boundarySupplier, Supplier bufferSupplier) { Objects.requireNonNull(boundarySupplier, "boundarySupplier is null"); Objects.requireNonNull(bufferSupplier, "bufferSupplier is null"); - return lift(new NbpOperatorBufferBoundarySupplier(boundarySupplier, bufferSupplier)); + return lift(new NbpOperatorBufferBoundarySupplier<>(boundarySupplier, bufferSupplier)); } @SchedulerSupport(SchedulerKind.NONE) @@ -1325,30 +1198,20 @@ public final NbpObservable cache(int capacityHint) { @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable cast(final Class clazz) { Objects.requireNonNull(clazz, "clazz is null"); - return map(new Function() { - @Override - public U apply(T v) { - return clazz.cast(v); - } - }); + return map(clazz::cast); } @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable collect(Supplier initialValueSupplier, BiConsumer collector) { Objects.requireNonNull(initialValueSupplier, "initalValueSupplier is null"); Objects.requireNonNull(collector, "collector is null"); - return lift(new NbpOperatorCollect(initialValueSupplier, collector)); + return lift(new NbpOperatorCollect<>(initialValueSupplier, collector)); } @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable collectInto(final U initialValue, BiConsumer collector) { Objects.requireNonNull(initialValue, "initialValue is null"); - return collect(new Supplier() { - @Override - public U get() { - return initialValue; - } - }, collector); + return collect(() -> initialValue, collector); } public final NbpObservable compose(Function, ? extends NbpObservable> convert) { @@ -1366,28 +1229,18 @@ public final NbpObservable concatMap(Function 0 required but it was " + prefetch); } - return lift(new NbpOperatorConcatMap(mapper, prefetch)); + return lift(new NbpOperatorConcatMap<>(mapper, prefetch)); } @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable concatMapIterable(final Function> mapper) { Objects.requireNonNull(mapper, "mapper is null"); - return concatMap(new Function>() { - @Override - public NbpObservable apply(T v) { - return fromIterable(mapper.apply(v)); - } - }); + return concatMap(v -> fromIterable(mapper.apply(v))); } @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable concatMapIterable(final Function> mapper, int prefetch) { - return concatMap(new Function>() { - @Override - public NbpObservable apply(T v) { - return fromIterable(mapper.apply(v)); - } - }, prefetch); + return concatMap(v -> fromIterable(mapper.apply(v)), prefetch); } @SchedulerSupport(SchedulerKind.NONE) @@ -1399,12 +1252,7 @@ public final NbpObservable concatWith(NbpObservable other) { @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable contains(final Object o) { Objects.requireNonNull(o, "o is null"); - return any(new Predicate() { - @Override - public boolean test(T v) { - return Objects.equals(v, o); - } - }); + return any(v -> Objects.equals(v, o)); } @SchedulerSupport(SchedulerKind.NONE) @@ -1415,7 +1263,7 @@ public final NbpObservable count() { @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable debounce(Function> debounceSelector) { Objects.requireNonNull(debounceSelector, "debounceSelector is null"); - return lift(new NbpOperatorDebounce(debounceSelector)); + return lift(new NbpOperatorDebounce<>(debounceSelector)); } @SchedulerSupport(SchedulerKind.COMPUTATION) @@ -1428,7 +1276,7 @@ public final NbpObservable debounce(long timeout, TimeUnit unit) { public final NbpObservable debounce(long timeout, TimeUnit unit, Scheduler scheduler) { Objects.requireNonNull(unit, "unit is null"); Objects.requireNonNull(scheduler, "scheduler is null"); - return lift(new NbpOperatorDebounceTimed(timeout, unit, scheduler)); + return lift(new NbpOperatorDebounceTimed<>(timeout, unit, scheduler)); } @SchedulerSupport(SchedulerKind.NONE) @@ -1441,17 +1289,7 @@ public final NbpObservable defaultIfEmpty(T value) { // TODO a more efficient implementation if necessary public final NbpObservable delay(final Function> itemDelay) { Objects.requireNonNull(itemDelay, "itemDelay is null"); - return flatMap(new Function>() { - @Override - public NbpObservable apply(final T v) { - return itemDelay.apply(v).take(1).map(new Function() { - @Override - public T apply(U u) { - return v; - } - }).defaultIfEmpty(v); - } - }); + return flatMap(v -> itemDelay.apply(v).take(1).map(u -> v).defaultIfEmpty(v)); } @SchedulerSupport(SchedulerKind.COMPUTATION) @@ -1474,7 +1312,7 @@ public final NbpObservable delay(long delay, TimeUnit unit, Scheduler schedul Objects.requireNonNull(unit, "unit is null"); Objects.requireNonNull(scheduler, "scheduler is null"); - return lift(new NbpOperatorDelay(delay, unit, scheduler, delayError)); + return lift(new NbpOperatorDelay<>(delay, unit, scheduler, delayError)); } @SchedulerSupport(SchedulerKind.NONE) @@ -1504,7 +1342,7 @@ public final NbpObservable delay(Supplier> @Experimental public final NbpObservable delaySubscription(NbpObservable other) { Objects.requireNonNull(other, "other is null"); - return create(new NbpOnSubscribeDelaySubscriptionOther(this, other)); + return create(new NbpOnSubscribeDelaySubscriptionOther<>(this, other)); } @SchedulerSupport(SchedulerKind.COMPUTATION) @@ -1518,62 +1356,35 @@ public final NbpObservable delaySubscription(long delay, TimeUnit unit, Sched Objects.requireNonNull(unit, "unit is null"); Objects.requireNonNull(scheduler, "scheduler is null"); - return timer(delay, unit, scheduler).flatMap(new Function>() { - @Override - public NbpObservable apply(Long v) { - return NbpObservable.this; - } - }); + return timer(delay, unit, scheduler).flatMap(v -> NbpObservable.this); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable delaySubscription(final Supplier> delaySupplier) { Objects.requireNonNull(delaySupplier, "delaySupplier is null"); - return fromCallable(new Callable>() { - @Override - public NbpObservable call() throws Exception { - return delaySupplier.get(); - } - }) - .flatMap((Function)Functions.identity()) + return fromCallable(delaySupplier::get) + .flatMap(Functions.identity()) .take(1) .cast(Object.class) .defaultIfEmpty(OBJECT) - .flatMap(new Function>() { - @Override - public NbpObservable apply(Object v) { - return NbpObservable.this; - } - }); + .flatMap(v -> NbpObservable.this); } + @SuppressWarnings("unchecked") @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable dematerialize() { - @SuppressWarnings("unchecked") NbpObservable>> m = (NbpObservable>>)this; - return m.lift(NbpOperatorDematerialize.instance()); + return m.lift(NbpOperatorDematerialize.instance()); } - - @SuppressWarnings({ "rawtypes", "unchecked" }) + @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable distinct() { - return distinct((Function)Functions.identity(), new Supplier>() { - @Override - public Collection get() { - return new HashSet(); - } - }); + return distinct(Functions.identity(), HashSet::new); } @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable distinct(Function keySelector) { - return distinct(keySelector, new Supplier>() { - @Override - public Collection get() { - return new HashSet(); - } - }); + return distinct(keySelector, HashSet::new); } @SchedulerSupport(SchedulerKind.NONE) @@ -1585,7 +1396,7 @@ public final NbpObservable distinct(Function keySelector, S @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable distinctUntilChanged() { - return lift(NbpOperatorDistinct.untilChanged()); + return lift(NbpOperatorDistinct.untilChanged()); } @SchedulerSupport(SchedulerKind.NONE) @@ -1610,54 +1421,22 @@ private NbpObservable doOnEach(Consumer onNext, Consumer(onNext, onError, onComplete, onAfterTerminate)); + return lift(new NbpOperatorDoOnEach<>(onNext, onError, onComplete, onAfterTerminate)); } @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable doOnEach(final Consumer>> consumer) { Objects.requireNonNull(consumer, "consumer is null"); return doOnEach( - new Consumer() { - @Override - public void accept(T v) { - consumer.accept(Try.ofValue(Optional.of(v))); - } - }, - new Consumer() { - @Override - public void accept(Throwable e) { - consumer.accept(Try.>ofError(e)); - } - }, - new Runnable() { - @Override - public void run() { - consumer.accept(Try.ofValue(Optional.empty())); - } - }, - Functions.emptyRunnable() - ); + v -> consumer.accept(Try.ofValue(Optional.of(v))), + e -> consumer.accept(Try.ofError(e)), + () -> consumer.accept(Try.ofValue(Optional.empty())), Functions.emptyRunnable()); } @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable doOnEach(final NbpSubscriber observer) { Objects.requireNonNull(observer, "observer is null"); - return doOnEach(new Consumer() { - @Override - public void accept(T v) { - observer.onNext(v); - } - }, new Consumer() { - @Override - public void accept(Throwable e) { - observer.onError(e); - } - }, new Runnable() { - @Override - public void run() { - observer.onComplete(); - } - }, Functions.emptyRunnable()); + return doOnEach(observer::onNext, observer::onError, observer::onComplete, Functions.emptyRunnable()); } @SchedulerSupport(SchedulerKind.NONE) @@ -1672,7 +1451,7 @@ public final NbpObservable doOnLifecycle(final Consumer o return lift(new NbpOperator() { @Override public NbpSubscriber apply(NbpSubscriber s) { - return new NbpSubscriptionLambdaSubscriber(s, onSubscribe, onCancel); + return new NbpSubscriptionLambdaSubscriber<>(s, onSubscribe, onCancel); } }); } @@ -1689,12 +1468,7 @@ public final NbpObservable doOnSubscribe(Consumer onSubsc @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable doOnTerminate(final Runnable onTerminate) { - return doOnEach(Functions.emptyConsumer(), new Consumer() { - @Override - public void accept(Throwable e) { - onTerminate.run(); - } - }, onTerminate, Functions.emptyRunnable()); + return doOnEach(Functions.emptyConsumer(), e -> onTerminate.run(), onTerminate, Functions.emptyRunnable()); } @SchedulerSupport(SchedulerKind.NONE) @@ -1702,7 +1476,7 @@ public final NbpObservable elementAt(long index) { if (index < 0) { throw new IndexOutOfBoundsException("index >= 0 required but it was " + index); } - return lift(new NbpOperatorElementAt(index, null)); + return lift(new NbpOperatorElementAt<>(index, null)); } @SchedulerSupport(SchedulerKind.NONE) @@ -1711,7 +1485,7 @@ public final NbpObservable elementAt(long index, T defaultValue) { throw new IndexOutOfBoundsException("index >= 0 required but it was " + index); } Objects.requireNonNull(defaultValue, "defaultValue is null"); - return lift(new NbpOperatorElementAt(index, defaultValue)); + return lift(new NbpOperatorElementAt<>(index, defaultValue)); } @SuppressWarnings("unchecked") @@ -1747,7 +1521,7 @@ public final NbpObservable endWithArray(T... values) { @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable filter(Predicate predicate) { Objects.requireNonNull(predicate, "predicate is null"); - return lift(new NbpOperatorFilter(predicate)); + return lift(new NbpOperatorFilter<>(predicate)); } @SchedulerSupport(SchedulerKind.NONE) @@ -1791,7 +1565,7 @@ public final NbpObservable flatMap(Function scalar = (NbpObservableScalarSource) this; return create(scalar.scalarFlatMap(mapper)); } - return lift(new NbpOperatorFlatMap(mapper, delayErrors, maxConcurrency, bufferSize)); + return lift(new NbpOperatorFlatMap<>(mapper, delayErrors, maxConcurrency, bufferSize)); } @SchedulerSupport(SchedulerKind.NONE) @@ -1802,7 +1576,7 @@ public final NbpObservable flatMap( Objects.requireNonNull(onNextMapper, "onNextMapper is null"); Objects.requireNonNull(onErrorMapper, "onErrorMapper is null"); Objects.requireNonNull(onCompleteSupplier, "onCompleteSupplier is null"); - return merge(lift(new NbpOperatorMapNotification(onNextMapper, onErrorMapper, onCompleteSupplier))); + return merge(lift(new NbpOperatorMapNotification<>(onNextMapper, onErrorMapper, onCompleteSupplier))); } @SchedulerSupport(SchedulerKind.NONE) @@ -1814,7 +1588,7 @@ public final NbpObservable flatMap( Objects.requireNonNull(onNextMapper, "onNextMapper is null"); Objects.requireNonNull(onErrorMapper, "onErrorMapper is null"); Objects.requireNonNull(onCompleteSupplier, "onCompleteSupplier is null"); - return merge(lift(new NbpOperatorMapNotification(onNextMapper, onErrorMapper, onCompleteSupplier)), maxConcurrency); + return merge(lift(new NbpOperatorMapNotification<>(onNextMapper, onErrorMapper, onCompleteSupplier)), maxConcurrency); } @SchedulerSupport(SchedulerKind.NONE) @@ -1841,19 +1615,7 @@ public final NbpObservable flatMap(Function NbpObservable flatMap(final Function> mapper, final BiFunction combiner, boolean delayError, int maxConcurrency, int bufferSize) { Objects.requireNonNull(mapper, "mapper is null"); Objects.requireNonNull(combiner, "combiner is null"); - return flatMap(new Function>() { - @Override - public NbpObservable apply(final T t) { - @SuppressWarnings("unchecked") - NbpObservable u = (NbpObservable)mapper.apply(t); - return u.map(new Function() { - @Override - public R apply(U w) { - return combiner.apply(t, w); - } - }); - } - }, delayError, maxConcurrency, bufferSize); + return flatMap(t -> mapper.apply(t).map(w -> combiner.apply(t, w)), delayError, maxConcurrency, bufferSize); } @SchedulerSupport(SchedulerKind.NONE) @@ -1864,32 +1626,17 @@ public final NbpObservable flatMap(Function NbpObservable flatMapIterable(final Function> mapper) { Objects.requireNonNull(mapper, "mapper is null"); - return flatMap(new Function>() { - @Override - public NbpObservable apply(T v) { - return fromIterable(mapper.apply(v)); - } - }); + return flatMap(v -> fromIterable(mapper.apply(v))); } @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable flatMapIterable(final Function> mapper, BiFunction resultSelector) { - return flatMap(new Function>() { - @Override - public NbpObservable apply(T t) { - return fromIterable(mapper.apply(t)); - } - }, resultSelector, false, bufferSize(), bufferSize()); + return flatMap(t -> fromIterable(mapper.apply(t)), resultSelector, false, bufferSize(), bufferSize()); } @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable flatMapIterable(final Function> mapper, int bufferSize) { - return flatMap(new Function>() { - @Override - public NbpObservable apply(T v) { - return fromIterable(mapper.apply(v)); - } - }, false, bufferSize); + return flatMap(v -> fromIterable(mapper.apply(v)), false, bufferSize); } @SchedulerSupport(SchedulerKind.NONE) @@ -1914,26 +1661,18 @@ public final Disposable forEachWhile(final Predicate onNext, Consumer Objects.requireNonNull(onError, "onError is null"); Objects.requireNonNull(onComplete, "onComplete is null"); - final AtomicReference subscription = new AtomicReference(); - return subscribe(new Consumer() { - @Override - public void accept(T v) { - if (!onNext.test(v)) { - subscription.get().dispose(); - onComplete.run(); - } + final AtomicReference subscription = new AtomicReference<>(); + return subscribe(v -> { + if (!onNext.test(v)) { + subscription.get().dispose(); + onComplete.run(); } - }, onError, onComplete, new Consumer() { - @Override - public void accept(Disposable s) { - subscription.lazySet(s); - } - }); + }, onError, onComplete, subscription::lazySet); } @SchedulerSupport(SchedulerKind.NONE) public final List getList() { - final List result = new ArrayList(); + final List result = new ArrayList<>(); final Throwable[] error = { null }; final CountDownLatch cdl = new CountDownLatch(1); @@ -1973,16 +1712,14 @@ public void onSubscribe(Disposable d) { return result; } - @SuppressWarnings({ "unchecked", "rawtypes" }) @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable> groupBy(Function keySelector) { - return groupBy(keySelector, (Function)Functions.identity(), false, bufferSize()); + return groupBy(keySelector, Functions.identity(), false, bufferSize()); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable> groupBy(Function keySelector, boolean delayError) { - return groupBy(keySelector, (Function)Functions.identity(), delayError, bufferSize()); + return groupBy(keySelector, Functions.identity(), delayError, bufferSize()); } @SchedulerSupport(SchedulerKind.NONE) @@ -2005,22 +1742,17 @@ public final NbpObservable> groupBy(Function(keySelector, valueSelector, bufferSize, delayError)); + return lift(new NbpOperatorGroupBy<>(keySelector, valueSelector, bufferSize, delayError)); } @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable ignoreElements() { - return lift(NbpOperatorIgnoreElements.instance()); + return lift(NbpOperatorIgnoreElements.instance()); } @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable isEmpty() { - return all(new Predicate() { - @Override - public boolean test(T v) { - return false; - } - }); + return all(v -> false); } @SchedulerSupport(SchedulerKind.NONE) @@ -2035,17 +1767,17 @@ public final NbpObservable last(T defaultValue) { public final NbpObservable lift(NbpOperator onLift) { Objects.requireNonNull(onLift, "onLift is null"); - return create(new NbpOnSubscribeLift(this, onLift)); + return create(new NbpOnSubscribeLift<>(this, onLift)); } public final NbpObservable map(Function mapper) { Objects.requireNonNull(mapper, "mapper is null"); - return lift(new NbpOperatorMap(mapper)); + return lift(new NbpOperatorMap<>(mapper)); } @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable>> materialize() { - return lift(NbpOperatorMaterialize.instance()); + return lift(NbpOperatorMaterialize.instance()); } @SchedulerSupport(SchedulerKind.NONE) @@ -2074,64 +1806,44 @@ public final NbpObservable observeOn(Scheduler scheduler, boolean delayError) public final NbpObservable observeOn(Scheduler scheduler, boolean delayError, int bufferSize) { Objects.requireNonNull(scheduler, "scheduler is null"); validateBufferSize(bufferSize); - return lift(new NbpOperatorObserveOn(scheduler, delayError, bufferSize)); + return lift(new NbpOperatorObserveOn<>(scheduler, delayError, bufferSize)); } @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable ofType(final Class clazz) { Objects.requireNonNull(clazz, "clazz is null"); - return filter(new Predicate() { - @Override - public boolean test(T v) { - return clazz.isInstance(v); - } - }).cast(clazz); + return filter(clazz::isInstance).cast(clazz); } @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable onErrorResumeNext(Function> resumeFunction) { Objects.requireNonNull(resumeFunction, "resumeFunction is null"); - return lift(new NbpOperatorOnErrorNext(resumeFunction, false)); + return lift(new NbpOperatorOnErrorNext<>(resumeFunction, false)); } @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable onErrorResumeNext(final NbpObservable next) { Objects.requireNonNull(next, "next is null"); - return onErrorResumeNext(new Function>() { - @Override - public NbpObservable apply(Throwable e) { - return next; - } - }); + return onErrorResumeNext(e -> next); } @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable onErrorReturn(Function valueSupplier) { Objects.requireNonNull(valueSupplier, "valueSupplier is null"); - return lift(new NbpOperatorOnErrorReturn(valueSupplier)); + return lift(new NbpOperatorOnErrorReturn<>(valueSupplier)); } // TODO would result in ambiguity with onErrorReturn(Function) @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable onErrorReturnValue(final T value) { Objects.requireNonNull(value, "value is null"); - return onErrorReturn(new Function() { - @Override - public T apply(Throwable e) { - return value; - } - }); + return onErrorReturn(e -> value); } @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable onExceptionResumeNext(final NbpObservable next) { Objects.requireNonNull(next, "next is null"); - return lift(new NbpOperatorOnErrorNext(new Function>() { - @Override - public NbpObservable apply(Throwable e) { - return next; - } - }, true)); + return lift(new NbpOperatorOnErrorNext<>(e -> next, true)); } @SchedulerSupport(SchedulerKind.NONE) @@ -2186,33 +1898,19 @@ public final NbpObservable repeat(long times) { if (times == 0) { return empty(); } - return create(new NbpOnSubscribeRepeat(this, times)); + return create(new NbpOnSubscribeRepeat<>(this, times)); } @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable repeatUntil(BooleanSupplier stop) { Objects.requireNonNull(stop, "stop is null"); - return create(new NbpOnSubscribeRepeatUntil(this, stop)); + return create(new NbpOnSubscribeRepeatUntil<>(this, stop)); } @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable repeatWhen(final Function, ? extends NbpObservable> handler) { Objects.requireNonNull(handler, "handler is null"); - - Function>>, NbpObservable> f = new Function>>, NbpObservable>() { - @Override - public NbpObservable apply(NbpObservable>> no) { - return handler.apply(no.map(new Function>, Object>() { - @Override - public Object apply(Try> v) { - return 0; - } - })); - } - } - ; - - return create(new NbpOnSubscribeRedo(this, f)); + return create(new NbpOnSubscribeRedo<>(this, no -> handler.apply(no.map(v -> 0)))); } @SchedulerSupport(SchedulerKind.NONE) @@ -2223,23 +1921,13 @@ public final NbpConnectableObservable replay() { @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable replay(Function, ? extends NbpObservable> selector) { Objects.requireNonNull(selector, "selector is null"); - return NbpOperatorReplay.multicastSelector(new Supplier>() { - @Override - public NbpConnectableObservable get() { - return replay(); - } - }, selector); + return NbpOperatorReplay.multicastSelector(this::replay, selector); } @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable replay(Function, ? extends NbpObservable> selector, final int bufferSize) { Objects.requireNonNull(selector, "selector is null"); - return NbpOperatorReplay.multicastSelector(new Supplier>() { - @Override - public NbpConnectableObservable get() { - return replay(bufferSize); - } - }, selector); + return NbpOperatorReplay.multicastSelector(() -> replay(bufferSize), selector); } @SchedulerSupport(SchedulerKind.COMPUTATION) @@ -2253,28 +1941,13 @@ public final NbpObservable replay(Function, ? ex throw new IllegalArgumentException("bufferSize < 0"); } Objects.requireNonNull(selector, "selector is null"); - return NbpOperatorReplay.multicastSelector(new Supplier>() { - @Override - public NbpConnectableObservable get() { - return replay(bufferSize, time, unit, scheduler); - } - }, selector); + return NbpOperatorReplay.multicastSelector(() -> replay(bufferSize, time, unit, scheduler), selector); } @SchedulerSupport(SchedulerKind.CUSTOM) public final NbpObservable replay(final Function, ? extends NbpObservable> selector, final int bufferSize, final Scheduler scheduler) { - return NbpOperatorReplay.multicastSelector(new Supplier>() { - @Override - public NbpConnectableObservable get() { - return replay(bufferSize); - } - }, - new Function, NbpObservable>() { - @Override - public NbpObservable apply(NbpObservable t) { - return selector.apply(t).observeOn(scheduler); - } - }); + return NbpOperatorReplay.multicastSelector(() -> replay(bufferSize), + t -> selector.apply(t).observeOn(scheduler)); } @SchedulerSupport(SchedulerKind.COMPUTATION) @@ -2287,30 +1960,14 @@ public final NbpObservable replay(Function, ? ex Objects.requireNonNull(selector, "selector is null"); Objects.requireNonNull(unit, "unit is null"); Objects.requireNonNull(scheduler, "scheduler is null"); - return NbpOperatorReplay.multicastSelector(new Supplier>() { - @Override - public NbpConnectableObservable get() { - return replay(time, unit, scheduler); - } - }, selector); + return NbpOperatorReplay.multicastSelector(() -> replay(time, unit, scheduler), selector); } @SchedulerSupport(SchedulerKind.CUSTOM) public final NbpObservable replay(final Function, ? extends NbpObservable> selector, final Scheduler scheduler) { Objects.requireNonNull(selector, "selector is null"); Objects.requireNonNull(scheduler, "scheduler is null"); - return NbpOperatorReplay.multicastSelector(new Supplier>() { - @Override - public NbpConnectableObservable get() { - return replay(); - } - }, - new Function, NbpObservable>() { - @Override - public NbpObservable apply(NbpObservable t) { - return selector.apply(t).observeOn(scheduler); - } - }); + return NbpOperatorReplay.multicastSelector(this::replay, t -> selector.apply(t).observeOn(scheduler)); } @SchedulerSupport(SchedulerKind.NONE) @@ -2365,7 +2022,7 @@ public final NbpObservable retry() { public final NbpObservable retry(BiPredicate predicate) { Objects.requireNonNull(predicate, "predicate is null"); - return create(new NbpOnSubscribeRetryBiPredicate(this, predicate)); + return create(new NbpOnSubscribeRetryBiPredicate<>(this, predicate)); } @SchedulerSupport(SchedulerKind.NONE) @@ -2381,7 +2038,7 @@ public final NbpObservable retry(long times, Predicate pre } Objects.requireNonNull(predicate, "predicate is null"); - return create(new NbpOnSubscribeRetryPredicate(this, times, predicate)); + return create(new NbpOnSubscribeRetryPredicate<>(this, times, predicate)); } @SchedulerSupport(SchedulerKind.NONE) @@ -2392,41 +2049,14 @@ public final NbpObservable retry(Predicate predicate) { @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable retryUntil(final BooleanSupplier stop) { Objects.requireNonNull(stop, "stop is null"); - return retry(Long.MAX_VALUE, new Predicate() { - @Override - public boolean test(Throwable e) { - return !stop.getAsBoolean(); - } - }); + return retry(Long.MAX_VALUE, e -> !stop.getAsBoolean()); } @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable retryWhen( final Function, ? extends NbpObservable> handler) { Objects.requireNonNull(handler, "handler is null"); - - Function>>, NbpObservable> f = new Function>>, NbpObservable>() { - @Override - public NbpObservable apply(NbpObservable>> no) { - return handler.apply(no - .takeWhile(new Predicate>>() { - @Override - public boolean test(Try> e) { - return e.hasError(); - } - }) - .map(new Function>, Throwable>() { - @Override - public Throwable apply(Try> t) { - return t.error(); - } - }) - ); - } - } - ; - - return create(new NbpOnSubscribeRedo(this, f)); + return create(new NbpOnSubscribeRedo<>(this, no -> handler.apply(no.takeWhile(Try::hasError).map(Try::error)))); } // TODO decide if safe subscription or unsafe should be the default @@ -2436,7 +2066,7 @@ public final void safeSubscribe(NbpSubscriber s) { if (s instanceof NbpSafeSubscriber) { subscribe(s); } else { - subscribe(new NbpSafeSubscriber(s)); + subscribe(new NbpSafeSubscriber<>(s)); } } @@ -2449,30 +2079,25 @@ public final NbpObservable sample(long period, TimeUnit unit) { public final NbpObservable sample(long period, TimeUnit unit, Scheduler scheduler) { Objects.requireNonNull(unit, "unit is null"); Objects.requireNonNull(scheduler, "scheduler is null"); - return lift(new NbpOperatorSampleTimed(period, unit, scheduler)); + return lift(new NbpOperatorSampleTimed<>(period, unit, scheduler)); } @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable sample(NbpObservable sampler) { Objects.requireNonNull(sampler, "sampler is null"); - return lift(new NbpOperatorSampleWithObservable(sampler)); + return lift(new NbpOperatorSampleWithObservable<>(sampler)); } @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable scan(BiFunction accumulator) { Objects.requireNonNull(accumulator, "accumulator is null"); - return lift(new NbpOperatorScan(accumulator)); + return lift(new NbpOperatorScan<>(accumulator)); } @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable scan(final R seed, BiFunction accumulator) { Objects.requireNonNull(seed, "seed is null"); - return scanWith(new Supplier() { - @Override - public R get() { - return seed; - } - }, accumulator); + return scanWith(() -> seed, accumulator); } // Naming note, a plain scan would cause ambiguity with the value-seeded version @@ -2480,7 +2105,7 @@ public R get() { public final NbpObservable scanWith(Supplier seedSupplier, BiFunction accumulator) { Objects.requireNonNull(seedSupplier, "seedSupplier is null"); Objects.requireNonNull(accumulator, "accumulator is null"); - return lift(new NbpOperatorScanSeed(seedSupplier, accumulator)); + return lift(new NbpOperatorScanSeed<>(seedSupplier, accumulator)); } @SchedulerSupport(SchedulerKind.NONE) @@ -2488,7 +2113,7 @@ public final NbpObservable serialize() { return lift(new NbpOperator() { @Override public NbpSubscriber apply(NbpSubscriber s) { - return new NbpSerializedSubscriber(s); + return new NbpSerializedSubscriber<>(s); } }); } @@ -2500,13 +2125,13 @@ public final NbpObservable share() { @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable single() { - return lift(NbpOperatorSingle.instanceNoDefault()); + return lift(NbpOperatorSingle.instanceNoDefault()); } @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable single(T defaultValue) { Objects.requireNonNull(defaultValue, "defaultValue is null"); - return lift(new NbpOperatorSingle(defaultValue)); + return lift(new NbpOperatorSingle<>(defaultValue)); } @SchedulerSupport(SchedulerKind.NONE) @@ -2518,7 +2143,7 @@ public final NbpObservable skip(long n) { if (n <= 0) { return this; } - return lift(new NbpOperatorSkip(n)); + return lift(new NbpOperatorSkip<>(n)); } @SchedulerSupport(SchedulerKind.CUSTOM) @@ -2535,7 +2160,7 @@ public final NbpObservable skipLast(int n) { if (n == 0) { return this; } - return lift(new NbpOperatorSkipLast(n)); + return lift(new NbpOperatorSkipLast<>(n)); } @SchedulerSupport(SchedulerKind.TRAMPOLINE) @@ -2565,19 +2190,19 @@ public final NbpObservable skipLast(long time, TimeUnit unit, Scheduler sched validateBufferSize(bufferSize); // the internal buffer holds pairs of (timestamp, value) so double the default buffer size int s = bufferSize << 1; - return lift(new NbpOperatorSkipLastTimed(time, unit, scheduler, s, delayError)); + return lift(new NbpOperatorSkipLastTimed<>(time, unit, scheduler, s, delayError)); } @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable skipUntil(NbpObservable other) { Objects.requireNonNull(other, "other is null"); - return lift(new NbpOperatorSkipUntil(other)); + return lift(new NbpOperatorSkipUntil<>(other)); } @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable skipWhile(Predicate predicate) { Objects.requireNonNull(predicate, "predicate is null"); - return lift(new NbpOperatorSkipWhile(predicate)); + return lift(new NbpOperatorSkipWhile<>(predicate)); } @SuppressWarnings("unchecked") @@ -2639,7 +2264,7 @@ public final Disposable subscribe(Consumer onNext, Consumer ls = new NbpLambdaSubscriber(onNext, onError, onComplete, onSubscribe); + NbpLambdaSubscriber ls = new NbpLambdaSubscriber<>(onNext, onError, onComplete, onSubscribe); unsafeSubscribe(ls); @@ -2654,13 +2279,13 @@ public final void subscribe(NbpSubscriber subscriber) { @SchedulerSupport(SchedulerKind.CUSTOM) public final NbpObservable subscribeOn(Scheduler scheduler) { Objects.requireNonNull(scheduler, "scheduler is null"); - return create(new NbpOnSubscribeSubscribeOn(this, scheduler)); + return create(new NbpOnSubscribeSubscribeOn<>(this, scheduler)); } @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable switchIfEmpty(NbpObservable other) { Objects.requireNonNull(other, "other is null"); - return lift(new NbpOperatorSwitchIfEmpty(other)); + return lift(new NbpOperatorSwitchIfEmpty<>(other)); } @SchedulerSupport(SchedulerKind.NONE) @@ -2672,7 +2297,7 @@ public final NbpObservable switchMap(Function NbpObservable switchMap(Function> mapper, int bufferSize) { Objects.requireNonNull(mapper, "mapper is null"); validateBufferSize(bufferSize); - return lift(new NbpOperatorSwitchMap(mapper, bufferSize)); + return lift(new NbpOperatorSwitchMap<>(mapper, bufferSize)); } @SchedulerSupport(SchedulerKind.NONE) @@ -2685,7 +2310,7 @@ public final NbpObservable take(long n) { // return lift(s -> CancelledSubscriber.INSTANCE); return empty(); } - return lift(new NbpOperatorTake(n)); + return lift(new NbpOperatorTake<>(n)); } @SchedulerSupport(SchedulerKind.NONE) @@ -2708,9 +2333,9 @@ public final NbpObservable takeLast(int n) { return ignoreElements(); } else if (n == 1) { - return lift(NbpOperatorTakeLastOne.instance()); + return lift(NbpOperatorTakeLastOne.instance()); } - return lift(new NbpOperatorTakeLast(n)); + return lift(new NbpOperatorTakeLast<>(n)); } @SchedulerSupport(SchedulerKind.TRAMPOLINE) @@ -2731,7 +2356,7 @@ public final NbpObservable takeLast(long count, long time, TimeUnit unit, Sch if (count < 0) { throw new IndexOutOfBoundsException("count >= 0 required but it was " + count); } - return lift(new NbpOperatorTakeLastTimed(count, time, unit, scheduler, bufferSize, delayError)); + return lift(new NbpOperatorTakeLastTimed<>(count, time, unit, scheduler, bufferSize, delayError)); } @SchedulerSupport(SchedulerKind.TRAMPOLINE) @@ -2787,19 +2412,19 @@ public final NbpObservable> takeLastBuffer(long time, TimeUnit unit, Sch @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable takeUntil(NbpObservable other) { Objects.requireNonNull(other, "other is null"); - return lift(new NbpOperatorTakeUntil(other)); + return lift(new NbpOperatorTakeUntil<>(other)); } @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable takeUntil(Predicate predicate) { Objects.requireNonNull(predicate, "predicate is null"); - return lift(new NbpOperatorTakeUntilPredicate(predicate)); + return lift(new NbpOperatorTakeUntilPredicate<>(predicate)); } @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable takeWhile(Predicate predicate) { Objects.requireNonNull(predicate, "predicate is null"); - return lift(new NbpOperatorTakeWhile(predicate)); + return lift(new NbpOperatorTakeWhile<>(predicate)); } @SchedulerSupport(SchedulerKind.COMPUTATION) @@ -2811,7 +2436,7 @@ public final NbpObservable throttleFirst(long windowDuration, TimeUnit unit) public final NbpObservable throttleFirst(long skipDuration, TimeUnit unit, Scheduler scheduler) { Objects.requireNonNull(unit, "unit is null"); Objects.requireNonNull(scheduler, "scheduler is null"); - return lift(new NbpOperatorThrottleFirstTimed(skipDuration, unit, scheduler)); + return lift(new NbpOperatorThrottleFirstTimed<>(skipDuration, unit, scheduler)); } @SchedulerSupport(SchedulerKind.COMPUTATION) @@ -2853,7 +2478,7 @@ public final NbpObservable> timeInterval(TimeUnit unit) { public final NbpObservable> timeInterval(TimeUnit unit, Scheduler scheduler) { Objects.requireNonNull(unit, "unit is null"); Objects.requireNonNull(scheduler, "scheduler is null"); - return lift(new NbpOperatorTimeInterval(unit, scheduler)); + return lift(new NbpOperatorTimeInterval<>(unit, scheduler)); } @SchedulerSupport(SchedulerKind.NONE) @@ -2909,7 +2534,7 @@ private NbpObservable timeout0(long timeout, TimeUnit timeUnit, NbpObservable Scheduler scheduler) { Objects.requireNonNull(timeUnit, "timeUnit is null"); Objects.requireNonNull(scheduler, "scheduler is null"); - return lift(new NbpOperatorTimeoutTimed(timeout, timeUnit, scheduler, other)); + return lift(new NbpOperatorTimeoutTimed<>(timeout, timeUnit, scheduler, other)); } private NbpObservable timeout0( @@ -2917,7 +2542,7 @@ private NbpObservable timeout0( Function> timeoutSelector, NbpObservable other) { Objects.requireNonNull(timeoutSelector, "timeoutSelector is null"); - return lift(new NbpOperatorTimeout(firstTimeoutSelector, timeoutSelector, other)); + return lift(new NbpOperatorTimeout<>(firstTimeoutSelector, timeoutSelector, other)); } @SchedulerSupport(SchedulerKind.TRAMPOLINE) @@ -2939,12 +2564,7 @@ public final NbpObservable> timestamp(TimeUnit unit) { public final NbpObservable> timestamp(final TimeUnit unit, final Scheduler scheduler) { Objects.requireNonNull(unit, "unit is null"); Objects.requireNonNull(scheduler, "scheduler is null"); - return map(new Function>() { - @Override - public Timed apply(T v) { - return new Timed(v, scheduler.now(unit), unit); - } - }); + return map(v -> new Timed<>(v, scheduler.now(unit), unit)); } public final R to(Function, R> convert) { @@ -2958,7 +2578,7 @@ public final NbpBlockingObservable toBlocking() { @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable> toList() { - return lift(NbpOperatorToList.defaultInstance()); + return lift(NbpOperatorToList.defaultInstance()); } @SchedulerSupport(SchedulerKind.NONE) @@ -2966,34 +2586,18 @@ public final NbpObservable> toList(final int capacityHint) { if (capacityHint <= 0) { throw new IllegalArgumentException("capacityHint > 0 required but it was " + capacityHint); } - return lift(new NbpOperatorToList>(new Supplier>() { - @Override - public List get() { - return new ArrayList(capacityHint); - } - })); + return lift(new NbpOperatorToList<>(() -> new ArrayList<>(capacityHint))); } @SchedulerSupport(SchedulerKind.NONE) public final > NbpObservable toList(Supplier collectionSupplier) { Objects.requireNonNull(collectionSupplier, "collectionSupplier is null"); - return lift(new NbpOperatorToList(collectionSupplier)); + return lift(new NbpOperatorToList<>(collectionSupplier)); } @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable> toMap(final Function keySelector) { - return collect(new Supplier>() { - @Override - public Map get() { - return new HashMap(); - } - }, new BiConsumer, T>() { - @Override - public void accept(Map m, T t) { - K key = keySelector.apply(t); - m.put(key, t); - } - }); + return collect(HashMap::new, (m, t) -> m.put(keySelector.apply(t), t)); } @SchedulerSupport(SchedulerKind.NONE) @@ -3002,19 +2606,7 @@ public final NbpObservable> toMap( final Function valueSelector) { Objects.requireNonNull(keySelector, "keySelector is null"); Objects.requireNonNull(valueSelector, "valueSelector is null"); - return collect(new Supplier>() { - @Override - public Map get() { - return new HashMap(); - } - }, new BiConsumer, T>() { - @Override - public void accept(Map m, T t) { - K key = keySelector.apply(t); - V value = valueSelector.apply(t); - m.put(key, value); - } - }); + return collect(HashMap::new, (m, t) -> m.put(keySelector.apply(t), valueSelector.apply(t))); } @SchedulerSupport(SchedulerKind.NONE) @@ -3022,50 +2614,17 @@ public final NbpObservable> toMap( final Function keySelector, final Function valueSelector, Supplier> mapSupplier) { - return collect(mapSupplier, new BiConsumer, T>() { - @Override - public void accept(Map m, T t) { - K key = keySelector.apply(t); - V value = valueSelector.apply(t); - m.put(key, value); - } - }); + return collect(mapSupplier, (m, t) -> m.put(keySelector.apply(t), valueSelector.apply(t))); } @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable>> toMultimap(Function keySelector) { - @SuppressWarnings({ "rawtypes", "unchecked" }) - Function valueSelector = (Function)Functions.identity(); - Supplier>> mapSupplier = new Supplier>>() { - @Override - public Map> get() { - return new HashMap>(); - } - }; - Function> collectionFactory = new Function>() { - @Override - public Collection apply(K k) { - return new ArrayList(); - } - }; - return toMultimap(keySelector, valueSelector, mapSupplier, collectionFactory); + return toMultimap(keySelector, Functions.identity(), () -> new HashMap<>(), k -> new ArrayList<>()); } @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable>> toMultimap(Function keySelector, Function valueSelector) { - Supplier>> mapSupplier = new Supplier>>() { - @Override - public Map> get() { - return new HashMap>(); - } - }; - Function> collectionFactory = new Function>() { - @Override - public Collection apply(K k) { - return new ArrayList(); - } - }; - return toMultimap(keySelector, valueSelector, mapSupplier, collectionFactory); + return toMultimap(keySelector, valueSelector, () -> new HashMap<>(), k -> new ArrayList<>()); } @SchedulerSupport(SchedulerKind.NONE) @@ -3079,21 +2638,18 @@ public final NbpObservable>> toMultimap( Objects.requireNonNull(valueSelector, "valueSelector is null"); Objects.requireNonNull(mapSupplier, "mapSupplier is null"); Objects.requireNonNull(collectionFactory, "collectionFactory is null"); - return collect(mapSupplier, new BiConsumer>, T>() { - @Override - public void accept(Map> m, T t) { - K key = keySelector.apply(t); + return collect(mapSupplier, (m, t) -> { + K key = keySelector.apply(t); - Collection coll = m.get(key); - if (coll == null) { - coll = (Collection)collectionFactory.apply(key); - m.put(key, coll); - } + Collection coll = m.get(key); + if (coll == null) { + coll = (Collection)collectionFactory.apply(key); + m.put(key, coll); + } - V value = valueSelector.apply(t); + V value = valueSelector.apply(t); - coll.add(value); - } + coll.add(value); }); } @@ -3103,18 +2659,11 @@ public final NbpObservable>> toMultimap( Function valueSelector, Supplier>> mapSupplier ) { - return toMultimap(keySelector, valueSelector, mapSupplier, new Function>() { - @Override - public Collection apply(K k) { - return new ArrayList(); - } - }); + return toMultimap(keySelector, valueSelector, mapSupplier, k -> new ArrayList<>()); } public final Observable toObservable(BackpressureStrategy strategy) { - Observable o = Observable.create(new Publisher() { - @Override - public void subscribe(final Subscriber s) { + Observable o = Observable.create(s -> NbpObservable.this.subscribe(new NbpSubscriber() { @Override @@ -3148,10 +2697,8 @@ public void request(long n) { }); } - - }); - } - }); + }) + ); switch (strategy) { case BUFFER: @@ -3167,37 +2714,32 @@ public void request(long n) { @SchedulerSupport(SchedulerKind.NONE) public final Single toSingle() { - return Single.create(new SingleOnSubscribe() { - @Override - public void accept(final SingleSubscriber s) { - NbpObservable.this.subscribe(new NbpSubscriber() { - T last; - @Override - public void onSubscribe(Disposable d) { - s.onSubscribe(d); - } - @Override - public void onNext(T value) { - last = value; - } - @Override - public void onError(Throwable e) { - s.onError(e); - } - @Override - public void onComplete() { - T v = last; - last = null; - if (v != null) { - s.onSuccess(v); - } else { - s.onError(new NoSuchElementException()); - } + return Single.create(s -> { + subscribe(new NbpSubscriber() { + T last; + @Override + public void onSubscribe(Disposable d) { + s.onSubscribe(d); + } + @Override + public void onNext(T value) { + last = value; + } + @Override + public void onError(Throwable e) { + s.onError(e); + } + @Override + public void onComplete() { + T v = last; + last = null; + if (v != null) { + s.onSuccess(v); + } else { + s.onError(new NoSuchElementException()); } - - - }); - } + } + }); }); } @@ -3209,30 +2751,24 @@ public final NbpObservable> toSortedList() { @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable> toSortedList(final Comparator comparator) { Objects.requireNonNull(comparator, "comparator is null"); - return toList().map(new Function, List>() { - @Override - public List apply(List v) { - Collections.sort(v, comparator); - return v; - } + return toList().map(v -> { + Collections.sort(v, comparator); + return v; }); } @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable> toSortedList(final Comparator comparator, int capacityHint) { Objects.requireNonNull(comparator, "comparator is null"); - return toList(capacityHint).map(new Function, List>() { - @Override - public List apply(List v) { - Collections.sort(v, comparator); - return v; - } + return toList(capacityHint).map(v -> { + Collections.sort(v, comparator); + return v; }); } @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable> toSortedList(int capacityHint) { - return toSortedList(Functions.naturalOrder(), capacityHint); + return toSortedList(Functions.naturalOrder(), capacityHint); } @SchedulerSupport(SchedulerKind.NONE) @@ -3245,7 +2781,7 @@ public final void unsafeSubscribe(NbpSubscriber s) { @SchedulerSupport(SchedulerKind.CUSTOM) public final NbpObservable unsubscribeOn(Scheduler scheduler) { Objects.requireNonNull(scheduler, "scheduler is null"); - return lift(new NbpOperatorUnsubscribeOn(scheduler)); + return lift(new NbpOperatorUnsubscribeOn<>(scheduler)); } @SchedulerSupport(SchedulerKind.NONE) @@ -3267,7 +2803,7 @@ public final NbpObservable> window(long count, long skip, int b throw new IllegalArgumentException("count > 0 required but it was " + count); } validateBufferSize(bufferSize); - return lift(new NbpOperatorWindow(count, skip, bufferSize)); + return lift(new NbpOperatorWindow<>(count, skip, bufferSize)); } @SchedulerSupport(SchedulerKind.COMPUTATION) @@ -3285,7 +2821,7 @@ public final NbpObservable> window(long timespan, long timeskip validateBufferSize(bufferSize); Objects.requireNonNull(scheduler, "scheduler is null"); Objects.requireNonNull(unit, "unit is null"); - return lift(new NbpOperatorWindowTimed(timespan, timeskip, unit, scheduler, Long.MAX_VALUE, bufferSize, false)); + return lift(new NbpOperatorWindowTimed<>(timespan, timeskip, unit, scheduler, Long.MAX_VALUE, bufferSize, false)); } @SchedulerSupport(SchedulerKind.COMPUTATION) @@ -3333,7 +2869,7 @@ public final NbpObservable> window( if (count <= 0) { throw new IllegalArgumentException("count > 0 required but it was " + count); } - return lift(new NbpOperatorWindowTimed(timespan, timespan, unit, scheduler, count, bufferSize, restart)); + return lift(new NbpOperatorWindowTimed<>(timespan, timespan, unit, scheduler, count, bufferSize, restart)); } @SchedulerSupport(SchedulerKind.NONE) @@ -3344,7 +2880,7 @@ public final NbpObservable> window(NbpObservable boundar @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable> window(NbpObservable boundary, int bufferSize) { Objects.requireNonNull(boundary, "boundary is null"); - return lift(new NbpOperatorWindowBoundary(boundary, bufferSize)); + return lift(new NbpOperatorWindowBoundary<>(boundary, bufferSize)); } @SchedulerSupport(SchedulerKind.NONE) @@ -3360,7 +2896,7 @@ public final NbpObservable> window( Function> windowClose, int bufferSize) { Objects.requireNonNull(windowOpen, "windowOpen is null"); Objects.requireNonNull(windowClose, "windowClose is null"); - return lift(new NbpOperatorWindowBoundarySelector(windowOpen, windowClose, bufferSize)); + return lift(new NbpOperatorWindowBoundarySelector<>(windowOpen, windowClose, bufferSize)); } @SchedulerSupport(SchedulerKind.NONE) @@ -3371,7 +2907,7 @@ public final NbpObservable> window(Supplier NbpObservable> window(Supplier> boundary, int bufferSize) { Objects.requireNonNull(boundary, "boundary is null"); - return lift(new NbpOperatorWindowBoundarySupplier(boundary, bufferSize)); + return lift(new NbpOperatorWindowBoundarySupplier<>(boundary, bufferSize)); } @SchedulerSupport(SchedulerKind.NONE) @@ -3379,14 +2915,14 @@ public final NbpObservable withLatestFrom(NbpObservable o Objects.requireNonNull(other, "other is null"); Objects.requireNonNull(combiner, "combiner is null"); - return lift(new NbpOperatorWithLatestFrom(combiner, other)); + return lift(new NbpOperatorWithLatestFrom<>(combiner, other)); } @SchedulerSupport(SchedulerKind.NONE) public final NbpObservable zipWith(Iterable other, BiFunction zipper) { Objects.requireNonNull(other, "other is null"); Objects.requireNonNull(zipper, "zipper is null"); - return create(new NbpOnSubscribeZipIterable(this, other, zipper)); + return create(new NbpOnSubscribeZipIterable<>(this, other, zipper)); } @SchedulerSupport(SchedulerKind.NONE) diff --git a/src/main/java/io/reactivex/NbpObserver.java b/rxjava/src/main/java/io/reactivex/NbpObserver.java similarity index 100% rename from src/main/java/io/reactivex/NbpObserver.java rename to rxjava/src/main/java/io/reactivex/NbpObserver.java diff --git a/src/main/java/io/reactivex/Notification.java b/rxjava/src/main/java/io/reactivex/Notification.java similarity index 100% rename from src/main/java/io/reactivex/Notification.java rename to rxjava/src/main/java/io/reactivex/Notification.java diff --git a/src/main/java/io/reactivex/Observable.java b/rxjava/src/main/java/io/reactivex/Observable.java similarity index 80% rename from src/main/java/io/reactivex/Observable.java rename to rxjava/src/main/java/io/reactivex/Observable.java index dee64a7c76..b0aec07b93 100644 --- a/src/main/java/io/reactivex/Observable.java +++ b/rxjava/src/main/java/io/reactivex/Observable.java @@ -63,16 +63,11 @@ public interface Transformer extends Function, Publisher EMPTY = create(PublisherEmptySource.INSTANCE); /** A never observable instance as there is no need to instantiate this more than once. */ - static final Observable NEVER = create(new Publisher() { - @Override - public void subscribe(Subscriber s) { - s.onSubscribe(EmptySubscription.INSTANCE); - } - }); + static final Observable NEVER = create(s -> s.onSubscribe(EmptySubscription.INSTANCE)); public static Observable amb(Iterable> sources) { Objects.requireNonNull(sources, "sources is null"); - return create(new PublisherAmb(null, sources)); + return create(new PublisherAmb<>(null, sources)); } @BackpressureSupport(BackpressureKind.FULL) @@ -86,7 +81,7 @@ public static Observable amb(Publisher... sources) { if (len == 1) { return fromPublisher(sources[0]); } - return create(new PublisherAmb(sources, null)); + return create(new PublisherAmb<>(sources, null)); } public static int bufferSize() { @@ -120,7 +115,7 @@ public static Observable combineLatest(Iterable(null, sources, combiner, s, delayError)); + return create(new PublisherCombineLatest<>(null, sources, combiner, s, delayError)); } @BackpressureSupport(BackpressureKind.FULL) @@ -145,10 +140,9 @@ public static Observable combineLatest(Publisher[] source } // the queue holds a pair of values so we need to double the capacity int s = bufferSize << 1; - return create(new PublisherCombineLatest(sources, null, combiner, s, delayError)); + return create(new PublisherCombineLatest<>(sources, null, combiner, s, delayError)); } - @SuppressWarnings("unchecked") @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable combineLatest( @@ -158,7 +152,6 @@ public static Observable combineLatest( return combineLatest(f, false, bufferSize(), p1, p2); } - @SuppressWarnings("unchecked") @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable combineLatest( @@ -168,7 +161,6 @@ public static Observable combineLatest( return combineLatest(Functions.toFunction(combiner), false, bufferSize(), p1, p2, p3); } - @SuppressWarnings("unchecked") @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable combineLatest( @@ -178,7 +170,6 @@ public static Observable combineLatest( return combineLatest(Functions.toFunction(combiner), false, bufferSize(), p1, p2, p3, p4); } - @SuppressWarnings("unchecked") @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable combineLatest( @@ -189,7 +180,6 @@ public static Observable combineLatest( return combineLatest(Functions.toFunction(combiner), false, bufferSize(), p1, p2, p3, p4, p5); } - @SuppressWarnings("unchecked") @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable combineLatest( @@ -200,7 +190,6 @@ public static Observable combineLatest( return combineLatest(Functions.toFunction(combiner), false, bufferSize(), p1, p2, p3, p4, p5, p6); } - @SuppressWarnings("unchecked") @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable combineLatest( @@ -212,7 +201,6 @@ public static Observable combineLatest( return combineLatest(Functions.toFunction(combiner), false, bufferSize(), p1, p2, p3, p4, p5, p6, p7); } - @SuppressWarnings("unchecked") @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable combineLatest( @@ -224,7 +212,6 @@ public static Observable combineLatest( return combineLatest(Functions.toFunction(combiner), false, bufferSize(), p1, p2, p3, p4, p5, p6, p7, p8); } - @SuppressWarnings("unchecked") @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable combineLatest( @@ -237,33 +224,30 @@ public static Observable combineLates return combineLatest(Functions.toFunction(combiner), false, bufferSize(), p1, p2, p3, p4, p5, p6, p7, p8, p9); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable concat(int prefetch, Iterable> sources) { Objects.requireNonNull(sources, "sources is null"); - return fromIterable(sources).concatMap((Function)Functions.identity(), prefetch); + return fromIterable(sources).concatMap(Functions.identity(), prefetch); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable concat(Iterable> sources) { Objects.requireNonNull(sources, "sources is null"); - return fromIterable(sources).concatMap((Function)Functions.identity()); + return fromIterable(sources).concatMap(Functions.identity()); } @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) - public static final Observable concat(Publisher> sources) { + public static Observable concat(Publisher> sources) { return concat(sources, bufferSize()); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) - public static final Observable concat(Publisher> sources, int bufferSize) { - return fromPublisher(sources).concatMap((Function)Functions.identity()); + public static Observable concat(Publisher> sources, int bufferSize) { + return fromPublisher(sources).concatMap(Functions.identity()); } @SuppressWarnings("unchecked") @@ -350,12 +334,11 @@ public static Observable concat( return concatArray(p1, p2, p3, p4, p5, p6, p7, p8, p9); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable concatArray(int prefetch, Publisher... sources) { Objects.requireNonNull(sources, "sources is null"); - return fromArray(sources).concatMap((Function)Functions.identity(), prefetch); + return fromArray(sources).concatMap(Functions.identity(), prefetch); } /** @@ -367,7 +350,6 @@ public static Observable concatArray(int prefetch, Publisher * @return the new NbpObservable instance * @throws NullPointerException if sources is null */ - @SuppressWarnings({ "unchecked", "rawtypes" }) @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable concatArray(Publisher... sources) { @@ -377,7 +359,7 @@ public static Observable concatArray(Publisher... sources) { if (sources.length == 1) { return fromPublisher(sources[0]); } - return fromArray(sources).concatMap((Function)Functions.identity()); + return fromArray(sources).concatMap(Functions.identity()); } @BackpressureSupport(BackpressureKind.NONE) @@ -385,14 +367,14 @@ public static Observable concatArray(Publisher... sources) { public static Observable create(Publisher onSubscribe) { Objects.requireNonNull(onSubscribe, "onSubscribe is null"); onSubscribe = RxJavaPlugins.onCreate(onSubscribe); - return new Observable(onSubscribe); + return new Observable<>(onSubscribe); } @BackpressureSupport(BackpressureKind.PASS_THROUGH) @SchedulerSupport(SchedulerKind.NONE) public static Observable defer(Supplier> supplier) { Objects.requireNonNull(supplier, "supplier is null"); - return create(new PublisherDefer(supplier)); + return create(new PublisherDefer<>(supplier)); } @BackpressureSupport(BackpressureKind.PASS_THROUGH) @@ -406,19 +388,14 @@ public static Observable empty() { @SchedulerSupport(SchedulerKind.NONE) public static Observable error(Supplier errorSupplier) { Objects.requireNonNull(errorSupplier, "errorSupplier is null"); - return create(new PublisherErrorSource(errorSupplier)); + return create(new PublisherErrorSource<>(errorSupplier)); } @BackpressureSupport(BackpressureKind.PASS_THROUGH) @SchedulerSupport(SchedulerKind.NONE) public static Observable error(final Throwable e) { Objects.requireNonNull(e, "e is null"); - return error(new Supplier() { - @Override - public Throwable get() { - return e; - } - }); + return error(() -> e); } @BackpressureSupport(BackpressureKind.FULL) @@ -431,7 +408,7 @@ public static Observable fromArray(T... values) { if (values.length == 1) { return just(values[0]); } - return create(new PublisherArraySource(values)); + return create(new PublisherArraySource<>(values)); } // TODO match naming with RxJava 1.x @@ -439,7 +416,7 @@ public static Observable fromArray(T... values) { @SchedulerSupport(SchedulerKind.NONE) public static Observable fromCallable(Callable supplier) { Objects.requireNonNull(supplier, "supplier is null"); - return create(new PublisherScalarAsyncSource(supplier)); + return create(new PublisherScalarAsyncSource<>(supplier)); } /* @@ -451,9 +428,7 @@ public static Observable fromCallable(Callable supplier) { @SchedulerSupport(SchedulerKind.NONE) public static Observable fromFuture(Future future) { Objects.requireNonNull(future, "future is null"); - Observable o = create(new PublisherFutureSource(future, 0L, null)); - - return o; + return create(new PublisherFutureSource<>(future, 0L, null)); } @BackpressureSupport(BackpressureKind.FULL) @@ -461,8 +436,7 @@ public static Observable fromFuture(Future future) { public static Observable fromFuture(Future future, long timeout, TimeUnit unit) { Objects.requireNonNull(future, "future is null"); Objects.requireNonNull(unit, "unit is null"); - Observable o = create(new PublisherFutureSource(future, timeout, unit)); - return o; + return create(new PublisherFutureSource<>(future, timeout, unit)); } @BackpressureSupport(BackpressureKind.FULL) @@ -485,7 +459,7 @@ public static Observable fromFuture(Future future, Scheduler @SchedulerSupport(SchedulerKind.NONE) public static Observable fromIterable(Iterable source) { Objects.requireNonNull(source, "source is null"); - return create(new PublisherIterableSource(source)); + return create(new PublisherIterableSource<>(source)); } @BackpressureSupport(BackpressureKind.PASS_THROUGH) @@ -496,26 +470,16 @@ public static Observable fromPublisher(final Publisher publi return (Observable)publisher; } Objects.requireNonNull(publisher, "publisher is null"); - - return create(new Publisher() { - @Override - public void subscribe(Subscriber s) { - publisher.subscribe(s); - } - }); + return create(s -> publisher.subscribe(s)); } @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable generate(final Consumer> generator) { Objects.requireNonNull(generator, "generator is null"); - return generate(Functions.nullSupplier(), - new BiFunction, Object>() { - @Override - public Object apply(Object s, Subscriber o) { - generator.accept(o); - return s; - } + return generate(Functions.nullSupplier(), (s, o) -> { + generator.accept(o); + return s; }, Functions.emptyConsumer()); } @@ -523,12 +487,9 @@ public Object apply(Object s, Subscriber o) { @SchedulerSupport(SchedulerKind.NONE) public static Observable generate(Supplier initialState, final BiConsumer> generator) { Objects.requireNonNull(generator, "generator is null"); - return generate(initialState, new BiFunction, S>() { - @Override - public S apply(S s, Subscriber o) { - generator.accept(s, o); - return s; - } + return generate(initialState, (s, o) -> { + generator.accept(s, o); + return s; }, Functions.emptyConsumer()); } @@ -536,12 +497,9 @@ public S apply(S s, Subscriber o) { @SchedulerSupport(SchedulerKind.NONE) public static Observable generate(Supplier initialState, final BiConsumer> generator, Consumer disposeState) { Objects.requireNonNull(generator, "generator is null"); - return generate(initialState, new BiFunction, S>() { - @Override - public S apply(S s, Subscriber o) { - generator.accept(s, o); - return s; - } + return generate(initialState, (s, o) -> { + generator.accept(s, o); + return s; }, disposeState); } @@ -557,7 +515,7 @@ public static Observable generate(Supplier initialState, BiFunction Objects.requireNonNull(initialState, "initialState is null"); Objects.requireNonNull(generator, "generator is null"); Objects.requireNonNull(disposeState, "disposeState is null"); - return create(new PublisherGenerate(initialState, generator, disposeState)); + return create(new PublisherGenerate<>(initialState, generator, disposeState)); } @BackpressureSupport(BackpressureKind.ERROR) @@ -624,13 +582,13 @@ public static Observable intervalRange(long start, long count, long initia @SchedulerSupport(SchedulerKind.NONE) public static Observable just(T value) { Objects.requireNonNull(value, "value is null"); - return new ObservableScalarSource(value); + return new ObservableScalarSource<>(value); } @SuppressWarnings("unchecked") @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) - public static final Observable just(T v1, T v2) { + public static Observable just(T v1, T v2) { Objects.requireNonNull(v1, "The first value is null"); Objects.requireNonNull(v2, "The second value is null"); @@ -641,7 +599,7 @@ public static final Observable just(T v1, T v2) { @SuppressWarnings("unchecked") @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) - public static final Observable just(T v1, T v2, T v3) { + public static Observable just(T v1, T v2, T v3) { Objects.requireNonNull(v1, "The first value is null"); Objects.requireNonNull(v2, "The second value is null"); Objects.requireNonNull(v3, "The third value is null"); @@ -652,7 +610,7 @@ public static final Observable just(T v1, T v2, T v3) { @SuppressWarnings("unchecked") @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) - public static final Observable just(T v1, T v2, T v3, T v4) { + public static Observable just(T v1, T v2, T v3, T v4) { Objects.requireNonNull(v1, "The first value is null"); Objects.requireNonNull(v2, "The second value is null"); Objects.requireNonNull(v3, "The third value is null"); @@ -664,7 +622,7 @@ public static final Observable just(T v1, T v2, T v3, T v4) { @SuppressWarnings("unchecked") @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) - public static final Observable just(T v1, T v2, T v3, T v4, T v5) { + public static Observable just(T v1, T v2, T v3, T v4, T v5) { Objects.requireNonNull(v1, "The first value is null"); Objects.requireNonNull(v2, "The second value is null"); Objects.requireNonNull(v3, "The third value is null"); @@ -677,7 +635,7 @@ public static final Observable just(T v1, T v2, T v3, T v4, T v5) { @SuppressWarnings("unchecked") @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) - public static final Observable just(T v1, T v2, T v3, T v4, T v5, T v6) { + public static Observable just(T v1, T v2, T v3, T v4, T v5, T v6) { Objects.requireNonNull(v1, "The first value is null"); Objects.requireNonNull(v2, "The second value is null"); Objects.requireNonNull(v3, "The third value is null"); @@ -691,7 +649,7 @@ public static final Observable just(T v1, T v2, T v3, T v4, T v5, T v6) { @SuppressWarnings("unchecked") @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) - public static final Observable just(T v1, T v2, T v3, T v4, T v5, T v6, T v7) { + public static Observable just(T v1, T v2, T v3, T v4, T v5, T v6, T v7) { Objects.requireNonNull(v1, "The first value is null"); Objects.requireNonNull(v2, "The second value is null"); Objects.requireNonNull(v3, "The third value is null"); @@ -706,7 +664,7 @@ public static final Observable just(T v1, T v2, T v3, T v4, T v5, T v6, T @SuppressWarnings("unchecked") @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) - public static final Observable just(T v1, T v2, T v3, T v4, T v5, T v6, T v7, T v8) { + public static Observable just(T v1, T v2, T v3, T v4, T v5, T v6, T v7, T v8) { Objects.requireNonNull(v1, "The first value is null"); Objects.requireNonNull(v2, "The second value is null"); Objects.requireNonNull(v3, "The third value is null"); @@ -722,7 +680,7 @@ public static final Observable just(T v1, T v2, T v3, T v4, T v5, T v6, T @SuppressWarnings("unchecked") @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) - public static final Observable just(T v1, T v2, T v3, T v4, T v5, T v6, T v7, T v8, T v9) { + public static Observable just(T v1, T v2, T v3, T v4, T v5, T v6, T v7, T v8, T v9) { Objects.requireNonNull(v1, "The first value is null"); Objects.requireNonNull(v2, "The second value is null"); Objects.requireNonNull(v3, "The third value is null"); @@ -736,39 +694,34 @@ public static final Observable just(T v1, T v2, T v3, T v4, T v5, T v6, T return fromArray(v1, v2, v3, v4, v5, v6, v7, v8, v9); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable merge(int maxConcurrency, int bufferSize, Iterable> sources) { - return fromIterable(sources).flatMap((Function)Functions.identity(), false, maxConcurrency, bufferSize); + return fromIterable(sources).flatMap(Functions.identity(), false, maxConcurrency, bufferSize); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable merge(int maxConcurrency, int bufferSize, Publisher... sources) { - return fromArray(sources).flatMap((Function)Functions.identity(), false, maxConcurrency, bufferSize); + return fromArray(sources).flatMap(Functions.identity(), false, maxConcurrency, bufferSize); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable merge(int maxConcurrency, Publisher... sources) { - return fromArray(sources).flatMap((Function)Functions.identity(), maxConcurrency); + return fromArray(sources).flatMap(Functions.identity(), maxConcurrency); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable merge(Iterable> sources) { - return fromIterable(sources).flatMap((Function)Functions.identity()); + return fromIterable(sources).flatMap(Functions.identity()); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable merge(Iterable> sources, int maxConcurrency) { - return fromIterable(sources).flatMap((Function)Functions.identity(), maxConcurrency); + return fromIterable(sources).flatMap(Functions.identity(), maxConcurrency); } @BackpressureSupport(BackpressureKind.FULL) @@ -777,40 +730,35 @@ public static Observable merge(Publisher return merge(sources, bufferSize()); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable merge(Publisher> sources, int maxConcurrency) { - return fromPublisher(sources).flatMap((Function)Functions.identity(), maxConcurrency); + return fromPublisher(sources).flatMap(Functions.identity(), maxConcurrency); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable merge(Publisher... sources) { - return fromArray(sources).flatMap((Function)Functions.identity(), sources.length); + return fromArray(sources).flatMap(Functions.identity(), sources.length); } - - @SuppressWarnings({ "unchecked", "rawtypes" }) + @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable merge(Publisher p1, Publisher p2) { Objects.requireNonNull(p1, "p1 is null"); Objects.requireNonNull(p2, "p2 is null"); - return fromArray(p1, p2).flatMap((Function)Functions.identity(), false, 2); + return fromArray(p1, p2).flatMap(Functions.identity(), false, 2); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable merge(Publisher p1, Publisher p2, Publisher p3) { Objects.requireNonNull(p1, "p1 is null"); Objects.requireNonNull(p2, "p2 is null"); Objects.requireNonNull(p3, "p3 is null"); - return fromArray(p1, p2, p3).flatMap((Function)Functions.identity(), false, 3); + return fromArray(p1, p2, p3).flatMap(Functions.identity(), false, 3); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable merge( @@ -820,42 +768,37 @@ public static Observable merge( Objects.requireNonNull(p2, "p2 is null"); Objects.requireNonNull(p3, "p3 is null"); Objects.requireNonNull(p4, "p4 is null"); - return fromArray(p1, p2, p3, p4).flatMap((Function)Functions.identity(), false, 4); + return fromArray(p1, p2, p3, p4).flatMap(Functions.identity(), false, 4); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable mergeDelayError(boolean delayErrors, Iterable> sources) { - return fromIterable(sources).flatMap((Function)Functions.identity(), true); + return fromIterable(sources).flatMap(Functions.identity(), true); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable mergeDelayError(int maxConcurrency, int bufferSize, Iterable> sources) { - return fromIterable(sources).flatMap((Function)Functions.identity(), true, maxConcurrency, bufferSize); + return fromIterable(sources).flatMap(Functions.identity(), true, maxConcurrency, bufferSize); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable mergeDelayError(int maxConcurrency, int bufferSize, Publisher... sources) { - return fromArray(sources).flatMap((Function)Functions.identity(), true, maxConcurrency, bufferSize); + return fromArray(sources).flatMap(Functions.identity(), true, maxConcurrency, bufferSize); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable mergeDelayError(int maxConcurrency, Iterable> sources) { - return fromIterable(sources).flatMap((Function)Functions.identity(), true, maxConcurrency); + return fromIterable(sources).flatMap(Functions.identity(), true, maxConcurrency); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable mergeDelayError(int maxConcurrency, Publisher... sources) { - return fromArray(sources).flatMap((Function)Functions.identity(), true, maxConcurrency); + return fromArray(sources).flatMap(Functions.identity(), true, maxConcurrency); } @BackpressureSupport(BackpressureKind.FULL) @@ -864,40 +807,35 @@ public static Observable mergeDelayError(Publisher Observable mergeDelayError(Publisher> sources, int maxConcurrency) { - return fromPublisher(sources).flatMap((Function)Functions.identity(), true, maxConcurrency); + return fromPublisher(sources).flatMap(Functions.identity(), true, maxConcurrency); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable mergeDelayError(Publisher... sources) { - return fromArray(sources).flatMap((Function)Functions.identity(), true, sources.length); + return fromArray(sources).flatMap(Functions.identity(), true, sources.length); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable mergeDelayError(Publisher p1, Publisher p2) { Objects.requireNonNull(p1, "p1 is null"); Objects.requireNonNull(p2, "p2 is null"); - return fromArray(p1, p2).flatMap((Function)Functions.identity(), true, 2); + return fromArray(p1, p2).flatMap(Functions.identity(), true, 2); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable mergeDelayError(Publisher p1, Publisher p2, Publisher p3) { Objects.requireNonNull(p1, "p1 is null"); Objects.requireNonNull(p2, "p2 is null"); Objects.requireNonNull(p3, "p3 is null"); - return fromArray(p1, p2, p3).flatMap((Function)Functions.identity(), true, 3); + return fromArray(p1, p2, p3).flatMap(Functions.identity(), true, 3); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable mergeDelayError( @@ -907,7 +845,7 @@ public static Observable mergeDelayError( Objects.requireNonNull(p2, "p2 is null"); Objects.requireNonNull(p3, "p3 is null"); Objects.requireNonNull(p4, "p4 is null"); - return fromArray(p1, p2, p3, p4).flatMap((Function)Functions.identity(), true, 4); + return fromArray(p1, p2, p3, p4).flatMap(Functions.identity(), true, 4); } @@ -955,7 +893,7 @@ public static Observable sequenceEqual(Publisher p1, P Objects.requireNonNull(p2, "p2 is null"); Objects.requireNonNull(isEqual, "isEqual is null"); validateBufferSize(bufferSize); - return create(new PublisherSequenceEqual(p1, p2, isEqual, bufferSize)); + return create(new PublisherSequenceEqual<>(p1, p2, isEqual, bufferSize)); } @BackpressureSupport(BackpressureKind.FULL) @@ -964,18 +902,16 @@ public static Observable sequenceEqual(Publisher p1, P return sequenceEqual(p1, p2, Objects.equalsPredicate(), bufferSize); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable switchOnNext(int bufferSize, Publisher> sources) { - return fromPublisher(sources).switchMap((Function)Functions.identity(), bufferSize); + return fromPublisher(sources).switchMap(Functions.identity(), bufferSize); } - @SuppressWarnings({ "unchecked", "rawtypes" }) @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable switchOnNext(Publisher> sources) { - return fromPublisher(sources).switchMap((Function)Functions.identity()); + return fromPublisher(sources).switchMap(Functions.identity()); } @BackpressureSupport(BackpressureKind.ERROR) @@ -1008,7 +944,7 @@ public static Observable using(Supplier resourceSupplier, Objects.requireNonNull(resourceSupplier, "resourceSupplier is null"); Objects.requireNonNull(sourceSupplier, "sourceSupplier is null"); Objects.requireNonNull(disposer, "disposer is null"); - return create(new PublisherUsing(resourceSupplier, sourceSupplier, disposer, eager)); + return create(new PublisherUsing<>(resourceSupplier, sourceSupplier, disposer, eager)); } private static void validateBufferSize(int bufferSize) { @@ -1022,22 +958,16 @@ private static void validateBufferSize(int bufferSize) { public static Observable zip(Iterable> sources, Function zipper) { Objects.requireNonNull(zipper, "zipper is null"); Objects.requireNonNull(sources, "sources is null"); - return create(new PublisherZip(null, sources, zipper, bufferSize(), false)); + return create(new PublisherZip<>(null, sources, zipper, bufferSize(), false)); } @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable zip(Publisher> sources, final Function zipper) { Objects.requireNonNull(zipper, "zipper is null"); - return fromPublisher(sources).toList().flatMap(new Function>, Publisher>() { - @Override - public Publisher apply(List> list) { - return zipIterable(zipper, false, bufferSize(), list); - } - }); + return fromPublisher(sources).toList().flatMap(list -> zipIterable(zipper, false, bufferSize(), list)); } - @SuppressWarnings("unchecked") @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable zip( @@ -1046,7 +976,6 @@ public static Observable zip( return zipArray(Functions.toFunction(zipper), false, bufferSize(), p1, p2); } - @SuppressWarnings("unchecked") @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable zip( @@ -1055,8 +984,6 @@ public static Observable zip( return zipArray(Functions.toFunction(zipper), delayError, bufferSize(), p1, p2); } - - @SuppressWarnings("unchecked") @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable zip( @@ -1065,7 +992,6 @@ public static Observable zip( return zipArray(Functions.toFunction(zipper), delayError, bufferSize, p1, p2); } - @SuppressWarnings("unchecked") @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable zip( @@ -1074,7 +1000,6 @@ public static Observable zip( return zipArray(Functions.toFunction(zipper), false, bufferSize(), p1, p2, p3); } - @SuppressWarnings("unchecked") @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable zip( @@ -1084,7 +1009,6 @@ public static Observable zip( return zipArray(Functions.toFunction(zipper), false, bufferSize(), p1, p2, p3, p4); } - @SuppressWarnings("unchecked") @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable zip( @@ -1094,7 +1018,6 @@ public static Observable zip( return zipArray(Functions.toFunction(zipper), false, bufferSize(), p1, p2, p3, p4, p5); } - @SuppressWarnings("unchecked") @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable zip( @@ -1104,7 +1027,6 @@ public static Observable zip( return zipArray(Functions.toFunction(zipper), false, bufferSize(), p1, p2, p3, p4, p5, p6); } - @SuppressWarnings("unchecked") @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable zip( @@ -1115,7 +1037,6 @@ public static Observable zip( return zipArray(Functions.toFunction(zipper), false, bufferSize(), p1, p2, p3, p4, p5, p6, p7); } - @SuppressWarnings("unchecked") @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable zip( @@ -1126,7 +1047,6 @@ public static Observable zip( return zipArray(Functions.toFunction(zipper), false, bufferSize(), p1, p2, p3, p4, p5, p6, p7, p8); } - @SuppressWarnings("unchecked") @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public static Observable zip( @@ -1146,7 +1066,7 @@ public static Observable zipArray(Function(sources, null, zipper, bufferSize, delayError)); + return create(new PublisherZip<>(sources, null, zipper, bufferSize, delayError)); } @BackpressureSupport(BackpressureKind.FULL) @@ -1157,7 +1077,7 @@ public static Observable zipIterable(Function(null, sources, zipper, bufferSize, delayError)); + return create(new PublisherZip<>(null, sources, zipper, bufferSize, delayError)); } final Publisher onSubscribe; @@ -1170,7 +1090,7 @@ protected Observable(Publisher onSubscribe) { @SchedulerSupport(SchedulerKind.NONE) public final Observable all(Predicate predicate) { Objects.requireNonNull(predicate, "predicate is null"); - return lift(new OperatorAll(predicate)); + return lift(new OperatorAll<>(predicate)); } @SuppressWarnings("unchecked") @@ -1185,18 +1105,13 @@ public final Observable ambWith(Publisher other) { @SchedulerSupport(SchedulerKind.NONE) public final Observable any(Predicate predicate) { Objects.requireNonNull(predicate, "predicate is null"); - return lift(new OperatorAny(predicate)); + return lift(new OperatorAny<>(predicate)); } @BackpressureSupport(BackpressureKind.PASS_THROUGH) @SchedulerSupport(SchedulerKind.NONE) public final Observable asObservable() { - return create(new Publisher() { - @Override - public void subscribe(Subscriber s) { - Observable.this.subscribe(s); - } - }); + return create(Observable.this::subscribe); } @BackpressureSupport(BackpressureKind.FULL) @@ -1208,19 +1123,14 @@ public final Observable> buffer(int count) { @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public final Observable> buffer(int count, int skip) { - return buffer(count, skip, new Supplier>() { - @Override - public List get() { - return new ArrayList(); - } - }); + return buffer(count, skip, ArrayList::new); } @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public final > Observable buffer(int count, int skip, Supplier bufferSupplier) { Objects.requireNonNull(bufferSupplier, "bufferSupplier is null"); - return lift(new OperatorBuffer(count, skip, bufferSupplier)); + return lift(new OperatorBuffer<>(count, skip, bufferSupplier)); } @BackpressureSupport(BackpressureKind.FULL) @@ -1232,23 +1142,13 @@ public final > Observable buffer(int count, S @BackpressureSupport(BackpressureKind.ERROR) @SchedulerSupport(SchedulerKind.COMPUTATION) public final Observable> buffer(long timespan, long timeskip, TimeUnit unit) { - return buffer(timespan, timeskip, unit, Schedulers.computation(), new Supplier>() { - @Override - public List get() { - return new ArrayList(); - } - }); + return buffer(timespan, timeskip, unit, Schedulers.computation(), ArrayList::new); } @BackpressureSupport(BackpressureKind.ERROR) @SchedulerSupport(SchedulerKind.CUSTOM) public final Observable> buffer(long timespan, long timeskip, TimeUnit unit, Scheduler scheduler) { - return buffer(timespan, timeskip, unit, scheduler, new Supplier>() { - @Override - public List get() { - return new ArrayList(); - } - }); + return buffer(timespan, timeskip, unit, scheduler, ArrayList::new); } @BackpressureSupport(BackpressureKind.ERROR) @@ -1257,7 +1157,7 @@ public final > Observable buffer(long timespa Objects.requireNonNull(unit, "unit is null"); Objects.requireNonNull(scheduler, "scheduler is null"); Objects.requireNonNull(bufferSupplier, "bufferSupplier is null"); - return lift(new OperatorBufferTimed(timespan, timeskip, unit, scheduler, bufferSupplier, Integer.MAX_VALUE, false)); + return lift(new OperatorBufferTimed<>(timespan, timeskip, unit, scheduler, bufferSupplier, Integer.MAX_VALUE, false)); } @BackpressureSupport(BackpressureKind.ERROR) @@ -1275,12 +1175,7 @@ public final Observable> buffer(long timespan, TimeUnit unit, int count) @BackpressureSupport(BackpressureKind.ERROR) @SchedulerSupport(SchedulerKind.CUSTOM) public final Observable> buffer(long timespan, TimeUnit unit, int count, Scheduler scheduler) { - return buffer(timespan, unit, count, scheduler, new Supplier>() { - @Override - public List get() { - return new ArrayList(); - } - }, false); + return buffer(timespan, unit, count, scheduler, ArrayList::new, false); } @BackpressureSupport(BackpressureKind.ERROR) @@ -1296,18 +1191,13 @@ public final > Observable buffer( if (count <= 0) { throw new IllegalArgumentException("count > 0 required but it was " + count); } - return lift(new OperatorBufferTimed(timespan, timespan, unit, scheduler, bufferSupplier, count, restartTimerOnMaxSize)); + return lift(new OperatorBufferTimed<>(timespan, timespan, unit, scheduler, bufferSupplier, count, restartTimerOnMaxSize)); } @BackpressureSupport(BackpressureKind.ERROR) @SchedulerSupport(SchedulerKind.CUSTOM) public final Observable> buffer(long timespan, TimeUnit unit, Scheduler scheduler) { - return buffer(timespan, unit, Integer.MAX_VALUE, scheduler, new Supplier>() { - @Override - public List get() { - return new ArrayList(); - } - }, false); + return buffer(timespan, unit, Integer.MAX_VALUE, scheduler, ArrayList::new, false); } @BackpressureSupport(BackpressureKind.ERROR) @@ -1315,12 +1205,7 @@ public List get() { public final Observable> buffer( Observable bufferOpenings, Function> bufferClosingSelector) { - return buffer(bufferOpenings, bufferClosingSelector, new Supplier>() { - @Override - public List get() { - return new ArrayList(); - } - }); + return buffer(bufferOpenings, bufferClosingSelector, ArrayList::new); } @BackpressureSupport(BackpressureKind.ERROR) @@ -1332,7 +1217,7 @@ public final > Observable Objects.requireNonNull(bufferOpenings, "bufferOpenings is null"); Objects.requireNonNull(bufferClosingSelector, "bufferClosingSelector is null"); Objects.requireNonNull(bufferSupplier, "bufferSupplier is null"); - return lift(new OperatorBufferBoundary(bufferOpenings, bufferClosingSelector, bufferSupplier)); + return lift(new OperatorBufferBoundary<>(bufferOpenings, bufferClosingSelector, bufferSupplier)); } @BackpressureSupport(BackpressureKind.ERROR) @@ -1341,23 +1226,13 @@ public final Observable> buffer(Publisher boundary) { /* * XXX: javac complains if this is not manually cast, Eclipse is fine */ - return buffer(boundary, new Supplier>() { - @Override - public List get() { - return new ArrayList(); - } - }); + return buffer(boundary, () -> new ArrayList<>()); } @BackpressureSupport(BackpressureKind.ERROR) @SchedulerSupport(SchedulerKind.NONE) public final Observable> buffer(Publisher boundary, final int initialCapacity) { - return buffer(boundary, new Supplier>() { - @Override - public List get() { - return new ArrayList(initialCapacity); - } - }); + return buffer(boundary, () -> new ArrayList<>(initialCapacity)); } @BackpressureSupport(BackpressureKind.ERROR) @@ -1365,18 +1240,13 @@ public List get() { public final > Observable buffer(Publisher boundary, Supplier bufferSupplier) { Objects.requireNonNull(boundary, "boundary is null"); Objects.requireNonNull(bufferSupplier, "bufferSupplier is null"); - return lift(new OperatorBufferExactBoundary(boundary, bufferSupplier)); + return lift(new OperatorBufferExactBoundary<>(boundary, bufferSupplier)); } @BackpressureSupport(BackpressureKind.ERROR) @SchedulerSupport(SchedulerKind.NONE) public final Observable> buffer(Supplier> boundarySupplier) { - return buffer(boundarySupplier, new Supplier>() { - @Override - public List get() { - return new ArrayList(); - } - }); + return buffer(boundarySupplier, ArrayList::new); } @@ -1385,7 +1255,7 @@ public List get() { public final > Observable buffer(Supplier> boundarySupplier, Supplier bufferSupplier) { Objects.requireNonNull(boundarySupplier, "boundarySupplier is null"); Objects.requireNonNull(bufferSupplier, "bufferSupplier is null"); - return lift(new OperatorBufferBoundarySupplier(boundarySupplier, bufferSupplier)); + return lift(new OperatorBufferBoundarySupplier<>(boundarySupplier, bufferSupplier)); } @BackpressureSupport(BackpressureKind.FULL) @@ -1407,12 +1277,7 @@ public final Observable cache(int capacityHint) { @SchedulerSupport(SchedulerKind.NONE) public final Observable cast(final Class clazz) { Objects.requireNonNull(clazz, "clazz is null"); - return map(new Function() { - @Override - public U apply(T v) { - return clazz.cast(v); - } - }); + return map(clazz::cast); } @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @@ -1420,19 +1285,14 @@ public U apply(T v) { public final Observable collect(Supplier initialValueSupplier, BiConsumer collector) { Objects.requireNonNull(initialValueSupplier, "initialValueSupplier is null"); Objects.requireNonNull(collector, "collectior is null"); - return lift(new OperatorCollect(initialValueSupplier, collector)); + return lift(new OperatorCollect<>(initialValueSupplier, collector)); } @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @SchedulerSupport(SchedulerKind.NONE) public final Observable collectInto(final U initialValue, BiConsumer collector) { Objects.requireNonNull(initialValue, "initialValue is null"); - return collect(new Supplier() { - @Override - public U get() { - return initialValue; - } - }, collector); + return collect(() -> initialValue, collector); } @BackpressureSupport(BackpressureKind.PASS_THROUGH) @@ -1455,7 +1315,7 @@ public final Observable concatMap(Function 0 required but it was " + prefetch); } - return lift(new OperatorConcatMap(mapper, prefetch)); + return lift(new OperatorConcatMap<>(mapper, prefetch)); } @BackpressureSupport(BackpressureKind.FULL) @@ -1468,12 +1328,7 @@ public final Observable concatMapIterable(Function Observable concatMapIterable(final Function> mapper, int prefetch) { Objects.requireNonNull(mapper, "mapper is null"); - return concatMap(new Function>() { - @Override - public Publisher apply(T v) { - return new PublisherIterableSource(mapper.apply(v)); - } - }, prefetch); + return concatMap(v -> new PublisherIterableSource<>(mapper.apply(v)), prefetch); } @BackpressureSupport(BackpressureKind.FULL) @@ -1487,12 +1342,7 @@ public final Observable concatWith(Publisher other) { @SchedulerSupport(SchedulerKind.NONE) public final Observable contains(final Object o) { Objects.requireNonNull(o, "o is null"); - return any(new Predicate() { - @Override - public boolean test(T v) { - return Objects.equals(v, o); - } - }); + return any(v -> Objects.equals(v, o)); } @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @@ -1505,7 +1355,7 @@ public final Observable count() { @SchedulerSupport(SchedulerKind.NONE) public final Observable debounce(Function> debounceSelector) { Objects.requireNonNull(debounceSelector, "debounceSelector is null"); - return lift(new OperatorDebounce(debounceSelector)); + return lift(new OperatorDebounce<>(debounceSelector)); } @BackpressureSupport(BackpressureKind.ERROR) @@ -1519,7 +1369,7 @@ public final Observable debounce(long timeout, TimeUnit unit) { public final Observable debounce(long timeout, TimeUnit unit, Scheduler scheduler) { Objects.requireNonNull(unit, "unit is null"); Objects.requireNonNull(scheduler, "scheduler is null"); - return lift(new OperatorDebounceTimed(timeout, unit, scheduler)); + return lift(new OperatorDebounceTimed<>(timeout, unit, scheduler)); } @BackpressureSupport(BackpressureKind.FULL) @@ -1534,17 +1384,7 @@ public final Observable defaultIfEmpty(T value) { // TODO a more efficient implementation if necessary public final Observable delay(final Function> itemDelay) { Objects.requireNonNull(itemDelay, "itemDelay is null"); - return flatMap(new Function>() { - @Override - public Publisher apply(final T v) { - return fromPublisher(itemDelay.apply(v)).take(1).map(new Function() { - @Override - public T apply(U u) { - return v; - } - }).defaultIfEmpty(v); - } - }); + return flatMap(v -> fromPublisher(itemDelay.apply(v)).take(1).map(u -> v).defaultIfEmpty(v)); } @BackpressureSupport(BackpressureKind.FULL) @@ -1571,7 +1411,7 @@ public final Observable delay(long delay, TimeUnit unit, Scheduler scheduler, Objects.requireNonNull(unit, "unit is null"); Objects.requireNonNull(scheduler, "scheduler is null"); - return lift(new OperatorDelay(delay, unit, scheduler, delayError)); + return lift(new OperatorDelay<>(delay, unit, scheduler, delayError)); } @BackpressureSupport(BackpressureKind.FULL) @@ -1602,7 +1442,7 @@ public final Observable delay(Supplier> delaySu @Experimental public final Observable delaySubscription(Publisher other) { Objects.requireNonNull(other, "other is null"); - return create(new PublisherDelaySubscriptionOther(this, other)); + return create(new PublisherDelaySubscriptionOther<>(this, other)); } @BackpressureSupport(BackpressureKind.FULL) @@ -1618,68 +1458,41 @@ public final Observable delaySubscription(long delay, TimeUnit unit, Schedule Objects.requireNonNull(unit, "unit is null"); Objects.requireNonNull(scheduler, "scheduler is null"); - return timer(delay, unit, scheduler).flatMap(new Function>() { - @Override - public Publisher apply(Long v) { - return Observable.this; - } - }); + return timer(delay, unit, scheduler).flatMap(v -> Observable.this); } private static final Object OBJECT = new Object(); - - @SuppressWarnings({ "rawtypes", "unchecked" }) + @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public final Observable delaySubscription(final Supplier> delaySupplier) { Objects.requireNonNull(delaySupplier, "delaySupplier is null"); - return fromCallable(new Callable() { - @Override - public Object call() throws Exception { - return delaySupplier.get(); - } - }) - .flatMap((Function)Functions.identity()) + return fromCallable(delaySupplier::get) + .flatMap(Functions.identity()) .take(1) - .cast(Object.class) // need a common supertype, the value is not relevant + .cast(Object.class) // need a common supertype, the value is not relevant .defaultIfEmpty(OBJECT) // in case the publisher is empty - .flatMap(new Function() { - @Override - public Object apply(Object v) { - return Observable.this; - } - }); + .flatMap(v -> Observable.this); } + @SuppressWarnings("unchecked") @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public final Observable dematerialize() { - @SuppressWarnings("unchecked") Observable>> m = (Observable>>)this; - return m.lift(OperatorDematerialize.instance()); + return m.lift(OperatorDematerialize.instance()); } - @SuppressWarnings({ "rawtypes", "unchecked" }) @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public final Observable distinct() { - return distinct((Function)Functions.identity(), new Supplier>() { - @Override - public Collection get() { - return new HashSet(); - } - }); + return distinct(Functions.identity(), HashSet::new); } @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public final Observable distinct(Function keySelector) { - return distinct(keySelector, new Supplier>() { - @Override - public Collection get() { - return new HashSet(); - } - }); + return distinct(keySelector, HashSet::new); } @BackpressureSupport(BackpressureKind.FULL) @@ -1693,7 +1506,7 @@ public final Observable distinct(Function keySelector, Supp @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public final Observable distinctUntilChanged() { - return lift(OperatorDistinct.untilChanged()); + return lift(OperatorDistinct.untilChanged()); } @BackpressureSupport(BackpressureKind.FULL) @@ -1722,7 +1535,7 @@ private Observable doOnEach(Consumer onNext, Consumer(onNext, onError, onComplete, onAfterTerminate)); + return lift(new OperatorDoOnEach<>(onNext, onError, onComplete, onAfterTerminate)); } @BackpressureSupport(BackpressureKind.PASS_THROUGH) @@ -1730,48 +1543,18 @@ private Observable doOnEach(Consumer onNext, Consumer doOnEach(final Consumer>> consumer) { Objects.requireNonNull(consumer, "consumer is null"); return doOnEach( - new Consumer() { - @Override - public void accept(T v) { - consumer.accept(Try.ofValue(Optional.of(v))); - } - }, - new Consumer() { - @Override - public void accept(Throwable e) { - consumer.accept(Try.>ofError(e)); - } - }, - new Runnable() { - @Override - public void run() { - consumer.accept(Try.ofValue(Optional.empty())); - } - }, - Functions.emptyRunnable() - ); + v -> consumer.accept(Try.ofValue(Optional.of(v))), + e -> consumer.accept(Try.ofError(e)), + () -> consumer.accept(Try.ofValue(Optional.empty())), + Functions.emptyRunnable() + ); } @BackpressureSupport(BackpressureKind.PASS_THROUGH) @SchedulerSupport(SchedulerKind.NONE) public final Observable doOnEach(final Subscriber observer) { Objects.requireNonNull(observer, "observer is null"); - return doOnEach(new Consumer() { - @Override - public void accept(T v) { - observer.onNext(v); - } - }, new Consumer() { - @Override - public void accept(Throwable e) { - observer.onError(e); - } - }, new Runnable() { - @Override - public void run() { - observer.onComplete(); - } - }, Functions.emptyRunnable()); + return doOnEach(observer::onNext, observer::onError, observer::onComplete, Functions.emptyRunnable()); } @BackpressureSupport(BackpressureKind.PASS_THROUGH) @@ -1786,12 +1569,7 @@ public final Observable doOnLifecycle(final Consumer on Objects.requireNonNull(onSubscribe, "onSubscribe is null"); Objects.requireNonNull(onRequest, "onRequest is null"); Objects.requireNonNull(onCancel, "onCancel is null"); - return lift(new Operator() { - @Override - public Subscriber apply(Subscriber s) { - return new SubscriptionLambdaSubscriber(s, onSubscribe, onRequest, onCancel); - } - }); + return lift(s -> new SubscriptionLambdaSubscriber<>(s, onSubscribe, onRequest, onCancel)); } @BackpressureSupport(BackpressureKind.PASS_THROUGH) @@ -1815,12 +1593,7 @@ public final Observable doOnSubscribe(Consumer onSubscr @BackpressureSupport(BackpressureKind.PASS_THROUGH) @SchedulerSupport(SchedulerKind.NONE) public final Observable doOnTerminate(final Runnable onTerminate) { - return doOnEach(Functions.emptyConsumer(), new Consumer() { - @Override - public void accept(Throwable e) { - onTerminate.run(); - } - }, onTerminate, Functions.emptyRunnable()); + return doOnEach(Functions.emptyConsumer(), e -> onTerminate.run(), onTerminate, Functions.emptyRunnable()); } @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @@ -1829,7 +1602,7 @@ public final Observable elementAt(long index) { if (index < 0) { throw new IndexOutOfBoundsException("index >= 0 required but it was " + index); } - return lift(new OperatorElementAt(index, null)); + return lift(new OperatorElementAt<>(index, null)); } @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @@ -1839,7 +1612,7 @@ public final Observable elementAt(long index, T defaultValue) { throw new IndexOutOfBoundsException("index >= 0 required but it was " + index); } Objects.requireNonNull(defaultValue, "defaultValue is null"); - return lift(new OperatorElementAt(index, defaultValue)); + return lift(new OperatorElementAt<>(index, defaultValue)); } @SuppressWarnings("unchecked") @@ -1881,7 +1654,7 @@ public final Observable endWithArray(T... values) { @SchedulerSupport(SchedulerKind.NONE) public final Observable filter(Predicate predicate) { Objects.requireNonNull(predicate, "predicate is null"); - return lift(new OperatorFilter(predicate)); + return lift(new OperatorFilter<>(predicate)); } @BackpressureSupport(BackpressureKind.PASS_THROUGH) @@ -1933,7 +1706,7 @@ public final Observable flatMap(Function scalar = (ObservableScalarSource) this; return create(scalar.scalarFlatMap(mapper)); } - return lift(new OperatorFlatMap(mapper, delayErrors, maxConcurrency, bufferSize)); + return lift(new OperatorFlatMap<>(mapper, delayErrors, maxConcurrency, bufferSize)); } @BackpressureSupport(BackpressureKind.FULL) @@ -1945,7 +1718,7 @@ public final Observable flatMap( Objects.requireNonNull(onNextMapper, "onNextMapper is null"); Objects.requireNonNull(onErrorMapper, "onErrorMapper is null"); Objects.requireNonNull(onCompleteSupplier, "onCompleteSupplier is null"); - return merge(lift(new OperatorMapNotification(onNextMapper, onErrorMapper, onCompleteSupplier))); + return merge(lift(new OperatorMapNotification<>(onNextMapper, onErrorMapper, onCompleteSupplier))); } @BackpressureSupport(BackpressureKind.FULL) @@ -1958,7 +1731,7 @@ public final Observable flatMap( Objects.requireNonNull(onNextMapper, "onNextMapper is null"); Objects.requireNonNull(onErrorMapper, "onErrorMapper is null"); Objects.requireNonNull(onCompleteSupplier, "onCompleteSupplier is null"); - return merge(lift(new OperatorMapNotification(onNextMapper, onErrorMapper, onCompleteSupplier)), maxConcurrency); + return merge(lift(new OperatorMapNotification<>(onNextMapper, onErrorMapper, onCompleteSupplier)), maxConcurrency); } @BackpressureSupport(BackpressureKind.FULL) @@ -1990,18 +1763,7 @@ public final Observable flatMap(Function Observable flatMap(final Function> mapper, final BiFunction combiner, boolean delayError, int maxConcurrency, int bufferSize) { Objects.requireNonNull(mapper, "mapper is null"); Objects.requireNonNull(combiner, "combiner is null"); - return flatMap(new Function>() { - @Override - public Publisher apply(final T t) { - Observable u = fromPublisher(mapper.apply(t)); - return u.map(new Function() { - @Override - public R apply(U w) { - return combiner.apply(t, w); - } - }); - } - }, delayError, maxConcurrency, bufferSize); + return flatMap(t -> fromPublisher(mapper.apply(t)).map(w -> combiner.apply(t, w)), delayError, maxConcurrency, bufferSize); } @BackpressureSupport(BackpressureKind.FULL) @@ -2014,12 +1776,7 @@ public final Observable flatMap(Function Observable flatMapIterable(final Function> mapper) { Objects.requireNonNull(mapper, "mapper is null"); - return flatMap(new Function>() { - @Override - public Publisher apply(T v) { - return new PublisherIterableSource(mapper.apply(v)); - } - }); + return flatMap(v -> new PublisherIterableSource<>(mapper.apply(v))); } @BackpressureSupport(BackpressureKind.FULL) @@ -2027,23 +1784,13 @@ public Publisher apply(T v) { public final Observable flatMapIterable(final Function> mapper, final BiFunction resultSelector) { Objects.requireNonNull(mapper, "mapper is null"); Objects.requireNonNull(resultSelector, "resultSelector is null"); - return flatMap(new Function>() { - @Override - public Publisher apply(T t) { - return new PublisherIterableSource(mapper.apply(t)); - } - }, resultSelector, false, bufferSize(), bufferSize()); + return flatMap(t -> new PublisherIterableSource<>(mapper.apply(t)), resultSelector, false, bufferSize(), bufferSize()); } @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public final Observable flatMapIterable(final Function> mapper, int bufferSize) { - return flatMap(new Function>() { - @Override - public Publisher apply(T v) { - return new PublisherIterableSource(mapper.apply(v)); - } - }, false, bufferSize); + return flatMap(v -> new PublisherIterableSource<>(mapper.apply(v)), false, bufferSize); } @BackpressureSupport(BackpressureKind.NONE) @@ -2072,34 +1819,28 @@ public final Disposable forEachWhile(final Predicate onNext, final Co Objects.requireNonNull(onError, "onError is null"); Objects.requireNonNull(onComplete, "onComplete is null"); - final AtomicReference subscription = new AtomicReference(); - return subscribe(new Consumer() { - @Override - public void accept(T v) { - if (!onNext.test(v)) { - subscription.get().cancel(); - onComplete.run(); - } - } - }, onError, onComplete, new Consumer() { - @Override - public void accept(Subscription s) { - subscription.lazySet(s); - s.request(Long.MAX_VALUE); + final AtomicReference subscription = new AtomicReference<>(); + return subscribe(v -> { + if (!onNext.test(v)) { + subscription.get().cancel(); + onComplete.run(); } + }, onError, onComplete, s -> { + subscription.lazySet(s); + s.request(Long.MAX_VALUE); }); } @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public final Observable> groupBy(Function keySelector) { - return groupBy(keySelector, Functions.identity(), false, bufferSize()); + return groupBy(keySelector, Functions.identity(), false, bufferSize()); } @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public final Observable> groupBy(Function keySelector, boolean delayError) { - return groupBy(keySelector, Functions.identity(), delayError, bufferSize()); + return groupBy(keySelector, Functions.identity(), delayError, bufferSize()); } @BackpressureSupport(BackpressureKind.FULL) @@ -2125,24 +1866,19 @@ public final Observable> groupBy(Function(keySelector, valueSelector, bufferSize, delayError)); + return lift(new OperatorGroupBy<>(keySelector, valueSelector, bufferSize, delayError)); } @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @SchedulerSupport(SchedulerKind.NONE) public final Observable ignoreElements() { - return lift(OperatorIgnoreElements.instance()); + return lift(OperatorIgnoreElements.instance()); } @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @SchedulerSupport(SchedulerKind.NONE) public final Observable isEmpty() { - return all(new Predicate() { - @Override - public boolean test(T v) { - return false; - } - }); + return all(v -> false); } @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @@ -2162,20 +1898,20 @@ public final Observable last(T defaultValue) { public final Observable lift(Operator lifter) { Objects.requireNonNull(lifter, "lifter is null"); // using onSubscribe so the fusing has access to the underlying raw Publisher - return create(new PublisherLift(onSubscribe, lifter)); + return create(new PublisherLift<>(onSubscribe, lifter)); } @BackpressureSupport(BackpressureKind.PASS_THROUGH) @SchedulerSupport(SchedulerKind.NONE) public final Observable map(Function mapper) { Objects.requireNonNull(mapper, "mapper is null"); - return lift(new OperatorMap(mapper)); + return lift(new OperatorMap<>(mapper)); } @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public final Observable>> materialize() { - return lift(OperatorMaterialize.instance()); + return lift(OperatorMaterialize.instance()); } @BackpressureSupport(BackpressureKind.FULL) @@ -2209,19 +1945,14 @@ public final Observable observeOn(Scheduler scheduler, boolean delayError) { public final Observable observeOn(Scheduler scheduler, boolean delayError, int bufferSize) { Objects.requireNonNull(scheduler, "scheduler is null"); validateBufferSize(bufferSize); - return lift(new OperatorObserveOn(scheduler, delayError, bufferSize)); + return lift(new OperatorObserveOn<>(scheduler, delayError, bufferSize)); } @BackpressureSupport(BackpressureKind.PASS_THROUGH) @SchedulerSupport(SchedulerKind.NONE) public final Observable ofType(final Class clazz) { Objects.requireNonNull(clazz, "clazz is null"); - return filter(new Predicate() { - @Override - public boolean test(T c) { - return clazz.isInstance(c); - } - }).cast(clazz); + return filter(clazz::isInstance).cast(clazz); } @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @@ -2252,14 +1983,14 @@ public final Observable onBackpressureBuffer(int bufferSize, boolean delayErr @SchedulerSupport(SchedulerKind.NONE) public final Observable onBackpressureBuffer(int bufferSize, boolean delayError, boolean unbounded) { validateBufferSize(bufferSize); - return lift(new OperatorOnBackpressureBuffer(bufferSize, unbounded, delayError, Functions.emptyRunnable())); + return lift(new OperatorOnBackpressureBuffer<>(bufferSize, unbounded, delayError, Functions.emptyRunnable())); } @BackpressureSupport(BackpressureKind.SPECIAL) @SchedulerSupport(SchedulerKind.NONE) public final Observable onBackpressureBuffer(int bufferSize, boolean delayError, boolean unbounded, Runnable onOverflow) { Objects.requireNonNull(onOverflow, "onOverflow is null"); - return lift(new OperatorOnBackpressureBuffer(bufferSize, unbounded, delayError, onOverflow)); + return lift(new OperatorOnBackpressureBuffer<>(bufferSize, unbounded, delayError, onOverflow)); } @BackpressureSupport(BackpressureKind.ERROR) @@ -2271,46 +2002,41 @@ public final Observable onBackpressureBuffer(int bufferSize, Runnable onOverf @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @SchedulerSupport(SchedulerKind.NONE) public final Observable onBackpressureDrop() { - return lift(OperatorOnBackpressureDrop.instance()); + return lift(OperatorOnBackpressureDrop.instance()); } @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @SchedulerSupport(SchedulerKind.NONE) public final Observable onBackpressureDrop(Consumer onDrop) { Objects.requireNonNull(onDrop, "onDrop is null"); - return lift(new OperatorOnBackpressureDrop(onDrop)); + return lift(new OperatorOnBackpressureDrop<>(onDrop)); } @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @SchedulerSupport(SchedulerKind.NONE) public final Observable onBackpressureLatest() { - return lift(OperatorOnBackpressureLatest.instance()); + return lift(OperatorOnBackpressureLatest.instance()); } @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public final Observable onErrorResumeNext(Function> resumeFunction) { Objects.requireNonNull(resumeFunction, "resumeFunction is null"); - return lift(new OperatorOnErrorNext(resumeFunction, false)); + return lift(new OperatorOnErrorNext<>(resumeFunction, false)); } @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public final Observable onErrorResumeNext(final Publisher next) { Objects.requireNonNull(next, "next is null"); - return onErrorResumeNext(new Function>() { - @Override - public Publisher apply(Throwable e) { - return next; - } - }); + return onErrorResumeNext(e -> next); } @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public final Observable onErrorReturn(Function valueSupplier) { Objects.requireNonNull(valueSupplier, "valueSupplier is null"); - return lift(new OperatorOnErrorReturn(valueSupplier)); + return lift(new OperatorOnErrorReturn<>(valueSupplier)); } // TODO would result in ambiguity with onErrorReturn(Function) @@ -2318,24 +2044,14 @@ public final Observable onErrorReturn(Function onErrorReturnValue(final T value) { Objects.requireNonNull(value, "value is null"); - return onErrorReturn(new Function() { - @Override - public T apply(Throwable e) { - return value; - } - }); + return onErrorReturn(e -> value); } @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public final Observable onExceptionResumeNext(final Publisher next) { Objects.requireNonNull(next, "next is null"); - return lift(new OperatorOnErrorNext(new Function>() { - @Override - public Publisher apply(Throwable e) { - return next; - } - }, true)); + return lift(new OperatorOnErrorNext<>(e -> next, true)); } @BackpressureSupport(BackpressureKind.FULL) @@ -2399,35 +2115,21 @@ public final Observable repeat(long times) { if (times == 0) { return empty(); } - return create(new PublisherRepeat(this, times)); + return create(new PublisherRepeat<>(this, times)); } @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public final Observable repeatUntil(BooleanSupplier stop) { Objects.requireNonNull(stop, "stop is null"); - return create(new PublisherRepeatUntil(this, stop)); + return create(new PublisherRepeatUntil<>(this, stop)); } @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public final Observable repeatWhen(final Function, ? extends Publisher> handler) { Objects.requireNonNull(handler, "handler is null"); - - Function>>, Publisher> f = new Function>>, Publisher>() { - @Override - public Publisher apply(Observable>> no) { - return handler.apply(no.map(new Function>, Object>() { - @Override - public Object apply(Try> v) { - return 0; - } - })); - } - } - ; - - return create(new PublisherRedo(this, f)); + return create(new PublisherRedo<>(this, no -> handler.apply(no.map(v -> 0)))); } @BackpressureSupport(BackpressureKind.FULL) @@ -2440,24 +2142,14 @@ public final ConnectableObservable replay() { @SchedulerSupport(SchedulerKind.NONE) public final Observable replay(Function, ? extends Publisher> selector) { Objects.requireNonNull(selector, "selector is null"); - return OperatorReplay.multicastSelector(new Supplier>() { - @Override - public ConnectableObservable get() { - return replay(); - } - }, selector); + return OperatorReplay.multicastSelector(() -> replay(), selector); } @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public final Observable replay(Function, ? extends Publisher> selector, final int bufferSize) { Objects.requireNonNull(selector, "selector is null"); - return OperatorReplay.multicastSelector(new Supplier>() { - @Override - public ConnectableObservable get() { - return replay(bufferSize); - } - }, selector); + return OperatorReplay.multicastSelector(() -> replay(bufferSize), selector); } @BackpressureSupport(BackpressureKind.FULL) @@ -2473,29 +2165,14 @@ public final Observable replay(Function, ? extends throw new IllegalArgumentException("bufferSize < 0"); } Objects.requireNonNull(selector, "selector is null"); - return OperatorReplay.multicastSelector(new Supplier>() { - @Override - public ConnectableObservable get() { - return replay(bufferSize, time, unit, scheduler); - } - }, selector); + return OperatorReplay.multicastSelector(() -> replay(bufferSize, time, unit, scheduler), selector); } @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.CUSTOM) public final Observable replay(final Function, ? extends Publisher> selector, final int bufferSize, final Scheduler scheduler) { - return OperatorReplay.multicastSelector(new Supplier>() { - @Override - public ConnectableObservable get() { - return replay(bufferSize); - } - }, - new Function, Publisher>() { - @Override - public Publisher apply(Observable t) { - return fromPublisher(selector.apply(t)).observeOn(scheduler); - } - }); + return OperatorReplay.multicastSelector(() -> replay(bufferSize), + t -> fromPublisher(selector.apply(t)).observeOn(scheduler)); } @BackpressureSupport(BackpressureKind.FULL) @@ -2510,12 +2187,7 @@ public final Observable replay(Function, ? extends Objects.requireNonNull(selector, "selector is null"); Objects.requireNonNull(unit, "unit is null"); Objects.requireNonNull(scheduler, "scheduler is null"); - return OperatorReplay.multicastSelector(new Supplier>() { - @Override - public ConnectableObservable get() { - return replay(time, unit, scheduler); - } - }, selector); + return OperatorReplay.multicastSelector(() -> replay(time, unit, scheduler), selector); } @BackpressureSupport(BackpressureKind.FULL) @@ -2523,18 +2195,7 @@ public ConnectableObservable get() { public final Observable replay(final Function, ? extends Publisher> selector, final Scheduler scheduler) { Objects.requireNonNull(selector, "selector is null"); Objects.requireNonNull(scheduler, "scheduler is null"); - return OperatorReplay.multicastSelector(new Supplier>() { - @Override - public ConnectableObservable get() { - return replay(); - } - }, - new Function, Publisher>() { - @Override - public Publisher apply(Observable t) { - return fromPublisher(selector.apply(t)).observeOn(scheduler); - } - }); + return OperatorReplay.multicastSelector(this::replay, t -> fromPublisher(selector.apply(t)).observeOn(scheduler)); } @BackpressureSupport(BackpressureKind.FULL) @@ -2599,7 +2260,7 @@ public final Observable retry() { public final Observable retry(BiPredicate predicate) { Objects.requireNonNull(predicate, "predicate is null"); - return create(new PublisherRetryBiPredicate(this, predicate)); + return create(new PublisherRetryBiPredicate<>(this, predicate)); } @BackpressureSupport(BackpressureKind.FULL) @@ -2617,7 +2278,7 @@ public final Observable retry(long times, Predicate predic } Objects.requireNonNull(predicate, "predicate is null"); - return create(new PublisherRetryPredicate(this, times, predicate)); + return create(new PublisherRetryPredicate<>(this, times, predicate)); } @BackpressureSupport(BackpressureKind.FULL) @@ -2630,12 +2291,7 @@ public final Observable retry(Predicate predicate) { @SchedulerSupport(SchedulerKind.NONE) public final Observable retryUntil(final BooleanSupplier stop) { Objects.requireNonNull(stop, "stop is null"); - return retry(Long.MAX_VALUE, new Predicate() { - @Override - public boolean test(Throwable e) { - return !stop.getAsBoolean(); - } - }); + return retry(Long.MAX_VALUE, e -> !stop.getAsBoolean()); } @BackpressureSupport(BackpressureKind.FULL) @@ -2643,27 +2299,7 @@ public boolean test(Throwable e) { public final Observable retryWhen( final Function, ? extends Publisher> handler) { Objects.requireNonNull(handler, "handler is null"); - - Function>>, Publisher> f = new Function>>, Publisher>() { - @Override - public Publisher apply(Observable>> no) { - Observable map = no.takeWhile(new Predicate>>() { - @Override - public boolean test(Try> e) { - return e.hasError(); - } - }).map(new Function>, Throwable>() { - @Override - public Throwable apply(Try> t) { - return t.error(); - } - }); - return handler.apply(map); - } - } - ; - - return create(new PublisherRedo(this, f)); + return create(new PublisherRedo<>(this, no -> handler.apply(no.takeWhile(Try::hasError).map(Try::error)))); } // TODO decide if safe subscription or unsafe should be the default @@ -2674,7 +2310,7 @@ public final void safeSubscribe(Subscriber s) { if (s instanceof SafeSubscriber) { subscribeActual(s); } else { - subscribeActual(new SafeSubscriber(s)); + subscribeActual(new SafeSubscriber<>(s)); } } @@ -2689,33 +2325,28 @@ public final Observable sample(long period, TimeUnit unit) { public final Observable sample(long period, TimeUnit unit, Scheduler scheduler) { Objects.requireNonNull(unit, "unit is null"); Objects.requireNonNull(scheduler, "scheduler is null"); - return lift(new OperatorSampleTimed(period, unit, scheduler)); + return lift(new OperatorSampleTimed<>(period, unit, scheduler)); } @BackpressureSupport(BackpressureKind.ERROR) @SchedulerSupport(SchedulerKind.NONE) public final Observable sample(Publisher sampler) { Objects.requireNonNull(sampler, "sampler is null"); - return lift(new OperatorSamplePublisher(sampler)); + return lift(new OperatorSamplePublisher<>(sampler)); } @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public final Observable scan(BiFunction accumulator) { Objects.requireNonNull(accumulator, "accumulator is null"); - return lift(new OperatorScan(accumulator)); + return lift(new OperatorScan<>(accumulator)); } @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public final Observable scan(final R seed, BiFunction accumulator) { Objects.requireNonNull(seed, "seed is null"); - return scanWith(new Supplier() { - @Override - public R get() { - return seed; - } - }, accumulator); + return scanWith(() -> seed, accumulator); } // Naming note, a plain scan would cause ambiguity with the value-seeded version @@ -2724,18 +2355,13 @@ public R get() { public final Observable scanWith(Supplier seedSupplier, BiFunction accumulator) { Objects.requireNonNull(seedSupplier, "seedSupplier is null"); Objects.requireNonNull(accumulator, "accumulator is null"); - return lift(new OperatorScanSeed(seedSupplier, accumulator)); + return lift(new OperatorScanSeed<>(seedSupplier, accumulator)); } @BackpressureSupport(BackpressureKind.PASS_THROUGH) @SchedulerSupport(SchedulerKind.NONE) public final Observable serialize() { - return lift(new Operator() { - @Override - public Subscriber apply(Subscriber s) { - return new SerializedSubscriber(s); - } - }); + return lift(SerializedSubscriber::new); } @BackpressureSupport(BackpressureKind.FULL) @@ -2747,14 +2373,14 @@ public final Observable share() { @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @SchedulerSupport(SchedulerKind.NONE) public final Observable single() { - return lift(OperatorSingle.instanceNoDefault()); + return lift(OperatorSingle.instanceNoDefault()); } @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @SchedulerSupport(SchedulerKind.NONE) public final Observable single(T defaultValue) { Objects.requireNonNull(defaultValue, "defaultValue is null"); - return lift(new OperatorSingle(defaultValue)); + return lift(new OperatorSingle<>(defaultValue)); } @BackpressureSupport(BackpressureKind.FULL) @@ -2767,7 +2393,7 @@ public final Observable skip(long n) { if (n <= 0) { return this; } - return lift(new OperatorSkip(n)); + return lift(new OperatorSkip<>(n)); } @BackpressureSupport(BackpressureKind.FULL) @@ -2786,7 +2412,7 @@ public final Observable skipLast(int n) { if (n == 0) { return this; } - return lift(new OperatorSkipLast(n)); + return lift(new OperatorSkipLast<>(n)); } @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @@ -2821,21 +2447,21 @@ public final Observable skipLast(long time, TimeUnit unit, Scheduler schedule validateBufferSize(bufferSize); // the internal buffer holds pairs of (timestamp, value) so double the default buffer size int s = bufferSize << 1; - return lift(new OperatorSkipLastTimed(time, unit, scheduler, s, delayError)); + return lift(new OperatorSkipLastTimed<>(time, unit, scheduler, s, delayError)); } @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public final Observable skipUntil(Publisher other) { Objects.requireNonNull(other, "other is null"); - return lift(new OperatorSkipUntil(other)); + return lift(new OperatorSkipUntil<>(other)); } @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public final Observable skipWhile(Predicate predicate) { Objects.requireNonNull(predicate, "predicate is null"); - return lift(new OperatorSkipWhile(predicate)); + return lift(new OperatorSkipWhile<>(predicate)); } @SuppressWarnings("unchecked") @@ -2872,49 +2498,31 @@ public final Observable startWithArray(T... values) { return concatArray(fromArray, this); } + static final Consumer REQUEST_ALL = t -> t.request(Long.MAX_VALUE); + @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @SchedulerSupport(SchedulerKind.NONE) public final Disposable subscribe() { - return subscribe(Functions.emptyConsumer(), RxJavaPlugins.errorConsumer(), Functions.emptyRunnable(), new Consumer() { - @Override - public void accept(Subscription s) { - s.request(Long.MAX_VALUE); - } - }); + return subscribe(Functions.emptyConsumer(), RxJavaPlugins.errorConsumer(), Functions.emptyRunnable(), REQUEST_ALL); } @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @SchedulerSupport(SchedulerKind.NONE) public final Disposable subscribe(Consumer onNext) { - return subscribe(onNext, RxJavaPlugins.errorConsumer(), Functions.emptyRunnable(), new Consumer() { - @Override - public void accept(Subscription s) { - s.request(Long.MAX_VALUE); - } - }); + return subscribe(onNext, RxJavaPlugins.errorConsumer(), Functions.emptyRunnable(), REQUEST_ALL); } @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @SchedulerSupport(SchedulerKind.NONE) public final Disposable subscribe(Consumer onNext, Consumer onError) { - return subscribe(onNext, onError, Functions.emptyRunnable(), new Consumer() { - @Override - public void accept(Subscription s) { - s.request(Long.MAX_VALUE); - } - }); + return subscribe(onNext, onError, Functions.emptyRunnable(), REQUEST_ALL); } @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @SchedulerSupport(SchedulerKind.NONE) public final Disposable subscribe(Consumer onNext, Consumer onError, Runnable onComplete) { - return subscribe(onNext, onError, onComplete, new Consumer() { - @Override - public void accept(Subscription s) { - s.request(Long.MAX_VALUE); - } - }); + return subscribe(onNext, onError, onComplete, REQUEST_ALL); } @BackpressureSupport(BackpressureKind.SPECIAL) @@ -2926,7 +2534,7 @@ public final Disposable subscribe(Consumer onNext, Consumer ls = new LambdaSubscriber(onNext, onError, onComplete, onSubscribe); + LambdaSubscriber ls = new LambdaSubscriber<>(onNext, onError, onComplete, onSubscribe); unsafeSubscribe(ls); @@ -2975,14 +2583,14 @@ public final Observable subscribeOn(Scheduler scheduler) { @SchedulerSupport(SchedulerKind.CUSTOM) public final Observable subscribeOn(Scheduler scheduler, boolean requestOn) { Objects.requireNonNull(scheduler, "scheduler is null"); - return create(new PublisherSubscribeOn(this, scheduler, requestOn)); + return create(new PublisherSubscribeOn<>(this, scheduler, requestOn)); } @BackpressureSupport(BackpressureKind.FULL) @SchedulerSupport(SchedulerKind.NONE) public final Observable switchIfEmpty(Publisher other) { Objects.requireNonNull(other, "other is null"); - return lift(new OperatorSwitchIfEmpty(other)); + return lift(new OperatorSwitchIfEmpty<>(other)); } @BackpressureSupport(BackpressureKind.FULL) @@ -2996,7 +2604,7 @@ public final Observable switchMap(Function Observable switchMap(Function> mapper, int bufferSize) { Objects.requireNonNull(mapper, "mapper is null"); validateBufferSize(bufferSize); - return lift(new OperatorSwitchMap(mapper, bufferSize)); + return lift(new OperatorSwitchMap<>(mapper, bufferSize)); } @BackpressureSupport(BackpressureKind.SPECIAL) // may trigger UNBOUNDED_IN @@ -3010,7 +2618,7 @@ public final Observable take(long n) { // return lift(s -> CancelledSubscriber.INSTANCE); return empty(); } - return lift(new OperatorTake(n)); + return lift(new OperatorTake<>(n)); } @BackpressureSupport(BackpressureKind.PASS_THROUGH) @@ -3036,9 +2644,9 @@ public final Observable takeLast(int n) { return ignoreElements(); } else if (n == 1) { - return lift(OperatorTakeLastOne.instance()); + return lift(OperatorTakeLastOne.instance()); } - return lift(new OperatorTakeLast(n)); + return lift(new OperatorTakeLast<>(n)); } @BackpressureSupport(BackpressureKind.FULL) @@ -3062,7 +2670,7 @@ public final Observable takeLast(long count, long time, TimeUnit unit, Schedu if (count < 0) { throw new IndexOutOfBoundsException("count >= 0 required but it was " + count); } - return lift(new OperatorTakeLastTimed(count, time, unit, scheduler, bufferSize, delayError)); + return lift(new OperatorTakeLastTimed<>(count, time, unit, scheduler, bufferSize, delayError)); } @BackpressureSupport(BackpressureKind.FULL) @@ -3129,21 +2737,21 @@ public final Observable> takeLastBuffer(long time, TimeUnit unit, Schedu @SchedulerSupport(SchedulerKind.NONE) public final Observable takeUntil(Predicate predicate) { Objects.requireNonNull(predicate, "predicate is null"); - return lift(new OperatorTakeUntilPredicate(predicate)); + return lift(new OperatorTakeUntilPredicate<>(predicate)); } @BackpressureSupport(BackpressureKind.PASS_THROUGH) @SchedulerSupport(SchedulerKind.NONE) public final Observable takeUntil(Publisher other) { Objects.requireNonNull(other, "other is null"); - return lift(new OperatorTakeUntil(other)); + return lift(new OperatorTakeUntil<>(other)); } @BackpressureSupport(BackpressureKind.PASS_THROUGH) @SchedulerSupport(SchedulerKind.NONE) public final Observable takeWhile(Predicate predicate) { Objects.requireNonNull(predicate, "predicate is null"); - return lift(new OperatorTakeWhile(predicate)); + return lift(new OperatorTakeWhile<>(predicate)); } @BackpressureSupport(BackpressureKind.ERROR) @@ -3157,7 +2765,7 @@ public final Observable throttleFirst(long windowDuration, TimeUnit unit) { public final Observable throttleFirst(long skipDuration, TimeUnit unit, Scheduler scheduler) { Objects.requireNonNull(unit, "unit is null"); Objects.requireNonNull(scheduler, "scheduler is null"); - return lift(new OperatorThrottleFirstTimed(skipDuration, unit, scheduler)); + return lift(new OperatorThrottleFirstTimed<>(skipDuration, unit, scheduler)); } @BackpressureSupport(BackpressureKind.ERROR) @@ -3207,7 +2815,7 @@ public final Observable> timeInterval(TimeUnit unit) { public final Observable> timeInterval(TimeUnit unit, Scheduler scheduler) { Objects.requireNonNull(unit, "unit is null"); Objects.requireNonNull(scheduler, "scheduler is null"); - return lift(new OperatorTimeInterval(unit, scheduler)); + return lift(new OperatorTimeInterval<>(unit, scheduler)); } @BackpressureSupport(BackpressureKind.PASS_THROUGH) @@ -3270,7 +2878,7 @@ private Observable timeout0(long timeout, TimeUnit timeUnit, Observable(timeout, timeUnit, scheduler, other)); + return lift(new OperatorTimeoutTimed<>(timeout, timeUnit, scheduler, other)); } private Observable timeout0( @@ -3278,7 +2886,7 @@ private Observable timeout0( Function> timeoutSelector, Publisher other) { Objects.requireNonNull(timeoutSelector, "timeoutSelector is null"); - return lift(new OperatorTimeout(firstTimeoutSelector, timeoutSelector, other)); + return lift(new OperatorTimeout<>(firstTimeoutSelector, timeoutSelector, other)); } @BackpressureSupport(BackpressureKind.PASS_THROUGH) @@ -3304,12 +2912,7 @@ public final Observable> timestamp(TimeUnit unit) { public final Observable> timestamp(final TimeUnit unit, final Scheduler scheduler) { Objects.requireNonNull(unit, "unit is null"); Objects.requireNonNull(scheduler, "scheduler is null"); - return map(new Function>() { - @Override - public Timed apply(T v) { - return new Timed(v, scheduler.now(unit), unit); - } - }); + return map(v -> new Timed<>(v, scheduler.now(unit), unit)); } // TODO generics @@ -3328,7 +2931,7 @@ public final BlockingObservable toBlocking() { @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @SchedulerSupport(SchedulerKind.NONE) public final Observable> toList() { - return lift(OperatorToList.defaultInstance()); + return lift(OperatorToList.defaultInstance()); } @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @@ -3337,37 +2940,21 @@ public final Observable> toList(final int capacityHint) { if (capacityHint <= 0) { throw new IllegalArgumentException("capacityHint > 0 required but it was " + capacityHint); } - return lift(new OperatorToList>(new Supplier>() { - @Override - public List get() { - return new ArrayList(capacityHint); - } - })); + return lift(new OperatorToList<>(() -> new ArrayList<>(capacityHint))); } @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @SchedulerSupport(SchedulerKind.NONE) public final > Observable toList(Supplier collectionSupplier) { Objects.requireNonNull(collectionSupplier, "collectionSupplier is null"); - return lift(new OperatorToList(collectionSupplier)); + return lift(new OperatorToList<>(collectionSupplier)); } @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @SchedulerSupport(SchedulerKind.NONE) public final Observable> toMap(final Function keySelector) { Objects.requireNonNull(keySelector, "keySelector is null"); - return collect(new Supplier>() { - @Override - public Map get() { - return new HashMap(); - } - }, new BiConsumer, T>() { - @Override - public void accept(Map m, T t) { - K key = keySelector.apply(t); - m.put(key, t); - } - }); + return collect(HashMap::new, (m, t) -> m.put(keySelector.apply(t), t)); } @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @@ -3375,19 +2962,7 @@ public void accept(Map m, T t) { public final Observable> toMap(final Function keySelector, final Function valueSelector) { Objects.requireNonNull(keySelector, "keySelector is null"); Objects.requireNonNull(valueSelector, "valueSelector is null"); - return collect(new Supplier>() { - @Override - public Map get() { - return new HashMap(); - } - }, new BiConsumer, T>() { - @Override - public void accept(Map m, T t) { - K key = keySelector.apply(t); - V value = valueSelector.apply(t); - m.put(key, value); - } - }); + return collect(HashMap::new, (m, t) -> m.put(keySelector.apply(t), valueSelector.apply(t))); } @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @@ -3397,56 +2972,23 @@ public final Observable> toMap(final Function> mapSupplier) { Objects.requireNonNull(keySelector, "keySelector is null"); Objects.requireNonNull(valueSelector, "valueSelector is null"); - return collect(mapSupplier, new BiConsumer, T>() { - @Override - public void accept(Map m, T t) { - K key = keySelector.apply(t); - V value = valueSelector.apply(t); - m.put(key, value); - } - }); + return collect(mapSupplier, (m, t) -> m.put(keySelector.apply(t), valueSelector.apply(t))); } @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @SchedulerSupport(SchedulerKind.NONE) public final Observable>> toMultimap(Function keySelector) { - Function valueSelector = Functions.identity(); - Supplier>> mapSupplier = new Supplier>>() { - @Override - public Map> get() { - return new HashMap>(); - } - }; - Function> collectionFactory = new Function>() { - @Override - public Collection apply(K k) { - return new ArrayList(); - } - }; - return toMultimap(keySelector, valueSelector, mapSupplier, collectionFactory); + return toMultimap(keySelector, Functions.identity(), () -> new HashMap<>(), k -> new ArrayList<>()); } @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @SchedulerSupport(SchedulerKind.NONE) public final Observable>> toMultimap(Function keySelector, Function valueSelector) { - Supplier>> mapSupplier = new Supplier>>() { - @Override - public Map> get() { - return new HashMap>(); - } - }; - Function> collectionFactory = new Function>() { - @Override - public Collection apply(K k) { - return new ArrayList(); - } - }; - return toMultimap(keySelector, valueSelector, mapSupplier, collectionFactory); + return toMultimap(keySelector, valueSelector, () -> new HashMap<>(), k -> new ArrayList<>()); } @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @SchedulerSupport(SchedulerKind.NONE) - @SuppressWarnings("unchecked") public final Observable>> toMultimap( final Function keySelector, final Function valueSelector, @@ -3456,21 +2998,18 @@ public final Observable>> toMultimap( Objects.requireNonNull(valueSelector, "valueSelector is null"); Objects.requireNonNull(mapSupplier, "mapSupplier is null"); Objects.requireNonNull(collectionFactory, "collectionFactory is null"); - return collect(mapSupplier, new BiConsumer>, T>() { - @Override - public void accept(Map> m, T t) { - K key = keySelector.apply(t); + return collect(mapSupplier, (m, t) -> { + K key = keySelector.apply(t); - Collection coll = m.get(key); - if (coll == null) { - coll = (Collection)collectionFactory.apply(key); - m.put(key, coll); - } + Collection coll = m.get(key); + if (coll == null) { + coll = (Collection)collectionFactory.apply(key); + m.put(key, coll); + } - V value = valueSelector.apply(t); + V value = valueSelector.apply(t); - coll.add(value); - } + coll.add(value); }); } @@ -3481,12 +3020,7 @@ public final Observable>> toMultimap( Function valueSelector, Supplier>> mapSupplier ) { - return toMultimap(keySelector, valueSelector, mapSupplier, new Function>() { - @Override - public Collection apply(K k) { - return new ArrayList(); - } - }); + return toMultimap(keySelector, valueSelector, mapSupplier, k -> new ArrayList<>()); } @BackpressureSupport(BackpressureKind.NONE) @@ -3503,26 +3037,17 @@ public final Single toSingle() { @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @SchedulerSupport(SchedulerKind.NONE) - @SuppressWarnings({ "unchecked", "rawtypes"}) public final Observable> toSortedList() { - return toSortedList(new Comparator() { - @Override - public int compare(T o1, T o2) { - return ((Comparable)o1).compareTo(o2); - } - }); + return toSortedList(Functions.naturalOrder()); } @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @SchedulerSupport(SchedulerKind.NONE) public final Observable> toSortedList(final Comparator comparator) { Objects.requireNonNull(comparator, "comparator is null"); - return toList().map(new Function, List>() { - @Override - public List apply(List v) { - Collections.sort(v, comparator); - return v; - } + return toList().map(v -> { + Collections.sort(v, comparator); + return v; }); } @@ -3530,25 +3055,16 @@ public List apply(List v) { @SchedulerSupport(SchedulerKind.NONE) public final Observable> toSortedList(final Comparator comparator, int capacityHint) { Objects.requireNonNull(comparator, "comparator is null"); - return toList(capacityHint).map(new Function, List>() { - @Override - public List apply(List v) { - Collections.sort(v, comparator); - return v; - } + return toList(capacityHint).map(v -> { + Collections.sort(v, comparator); + return v; }); } @BackpressureSupport(BackpressureKind.UNBOUNDED_IN) @SchedulerSupport(SchedulerKind.NONE) - @SuppressWarnings({ "unchecked", "rawtypes"}) public final Observable> toSortedList(int capacityHint) { - return toSortedList(new Comparator() { - @Override - public int compare(T o1, T o2) { - return ((Comparable)o1).compareTo(o2); - } - }, capacityHint); + return toSortedList(Functions.naturalOrder(), capacityHint); } @BackpressureSupport(BackpressureKind.SPECIAL) @@ -3563,7 +3079,7 @@ public final void unsafeSubscribe(Subscriber s) { @SchedulerSupport(SchedulerKind.CUSTOM) public final Observable unsubscribeOn(Scheduler scheduler) { Objects.requireNonNull(scheduler, "scheduler is null"); - return lift(new OperatorUnsubscribeOn(scheduler)); + return lift(new OperatorUnsubscribeOn<>(scheduler)); } @BackpressureSupport(BackpressureKind.FULL) @@ -3588,7 +3104,7 @@ public final Observable> window(long count, long skip, int bufferS throw new IllegalArgumentException("count > 0 required but it was " + count); } validateBufferSize(bufferSize); - return lift(new OperatorWindow(count, skip, bufferSize)); + return lift(new OperatorWindow<>(count, skip, bufferSize)); } @BackpressureSupport(BackpressureKind.ERROR) @@ -3609,7 +3125,7 @@ public final Observable> window(long timespan, long timeskip, Time validateBufferSize(bufferSize); Objects.requireNonNull(scheduler, "scheduler is null"); Objects.requireNonNull(unit, "unit is null"); - return lift(new OperatorWindowTimed(timespan, timeskip, unit, scheduler, Long.MAX_VALUE, bufferSize, false)); + return lift(new OperatorWindowTimed<>(timespan, timeskip, unit, scheduler, Long.MAX_VALUE, bufferSize, false)); } @BackpressureSupport(BackpressureKind.ERROR) @@ -3664,7 +3180,7 @@ public final Observable> window( if (count <= 0) { throw new IllegalArgumentException("count > 0 required but it was " + count); } - return lift(new OperatorWindowTimed(timespan, timespan, unit, scheduler, count, bufferSize, restart)); + return lift(new OperatorWindowTimed<>(timespan, timespan, unit, scheduler, count, bufferSize, restart)); } @BackpressureSupport(BackpressureKind.ERROR) @@ -3677,7 +3193,7 @@ public final Observable> window(Publisher boundary) { @SchedulerSupport(SchedulerKind.NONE) public final Observable> window(Publisher boundary, int bufferSize) { Objects.requireNonNull(boundary, "boundary is null"); - return lift(new OperatorWindowBoundary(boundary, bufferSize)); + return lift(new OperatorWindowBoundary<>(boundary, bufferSize)); } @BackpressureSupport(BackpressureKind.ERROR) @@ -3695,7 +3211,7 @@ public final Observable> window( Function> windowClose, int bufferSize) { Objects.requireNonNull(windowOpen, "windowOpen is null"); Objects.requireNonNull(windowClose, "windowClose is null"); - return lift(new OperatorWindowBoundarySelector(windowOpen, windowClose, bufferSize)); + return lift(new OperatorWindowBoundarySelector<>(windowOpen, windowClose, bufferSize)); } @BackpressureSupport(BackpressureKind.ERROR) @@ -3708,7 +3224,7 @@ public final Observable> window(Supplier Observable> window(Supplier> boundary, int bufferSize) { Objects.requireNonNull(boundary, "boundary is null"); - return lift(new OperatorWindowBoundarySupplier(boundary, bufferSize)); + return lift(new OperatorWindowBoundarySupplier<>(boundary, bufferSize)); } @BackpressureSupport(BackpressureKind.PASS_THROUGH) @@ -3717,7 +3233,7 @@ public final Observable withLatestFrom(Publisher other, B Objects.requireNonNull(other, "other is null"); Objects.requireNonNull(combiner, "combiner is null"); - return lift(new OperatorWithLatestFrom(combiner, other)); + return lift(new OperatorWithLatestFrom<>(combiner, other)); } @BackpressureSupport(BackpressureKind.FULL) @@ -3725,7 +3241,7 @@ public final Observable withLatestFrom(Publisher other, B public final Observable zipWith(Iterable other, BiFunction zipper) { Objects.requireNonNull(other, "other is null"); Objects.requireNonNull(zipper, "zipper is null"); - return create(new PublisherZipIterable(this, other, zipper)); + return create(new PublisherZipIterable<>(this, other, zipper)); } @BackpressureSupport(BackpressureKind.FULL) diff --git a/src/main/java/io/reactivex/Observer.java b/rxjava/src/main/java/io/reactivex/Observer.java similarity index 100% rename from src/main/java/io/reactivex/Observer.java rename to rxjava/src/main/java/io/reactivex/Observer.java diff --git a/src/main/java/io/reactivex/Optional.java b/rxjava/src/main/java/io/reactivex/Optional.java similarity index 94% rename from src/main/java/io/reactivex/Optional.java rename to rxjava/src/main/java/io/reactivex/Optional.java index b8d0565bf0..57a6fdcb7e 100644 --- a/src/main/java/io/reactivex/Optional.java +++ b/rxjava/src/main/java/io/reactivex/Optional.java @@ -26,7 +26,7 @@ protected Optional(T value) { this.value = value; } - static final Optional EMPTY = new Optional(null); + static final Optional EMPTY = new Optional<>(null); @SuppressWarnings("unchecked") public static Optional empty() { @@ -35,7 +35,7 @@ public static Optional empty() { public static Optional of(T value) { Objects.requireNonNull(value, "value is null"); - return new Optional(value); + return new Optional<>(value); } public boolean isPresent() { diff --git a/src/main/java/io/reactivex/Scheduler.java b/rxjava/src/main/java/io/reactivex/Scheduler.java similarity index 86% rename from src/main/java/io/reactivex/Scheduler.java rename to rxjava/src/main/java/io/reactivex/Scheduler.java index e2af0ef33d..fafaf4b465 100644 --- a/src/main/java/io/reactivex/Scheduler.java +++ b/rxjava/src/main/java/io/reactivex/Scheduler.java @@ -72,14 +72,11 @@ public Disposable scheduleDirect(Runnable run, long delay, TimeUnit unit) { final Runnable decoratedRun = RxJavaPlugins.onSchedule(run); - w.schedule(new Runnable() { - @Override - public void run() { - try { - decoratedRun.run(); - } finally { - w.dispose(); - } + w.schedule(() -> { + try { + decoratedRun.run(); + } finally { + w.dispose(); } }, delay, unit); @@ -87,22 +84,19 @@ public void run() { } public Disposable schedulePeriodicallyDirect(Runnable run, long initialDelay, long period, TimeUnit unit) { - final ArrayCompositeResource acr = new ArrayCompositeResource(2, Disposables.consumeAndDispose()); + final ArrayCompositeResource acr = new ArrayCompositeResource<>(2, Disposables.consumeAndDispose()); final Worker w = createWorker(); acr.lazySet(0, w); final Runnable decoratedRun = RxJavaPlugins.onSchedule(run); - acr.setResource(1, w.schedulePeriodically(new Runnable() { - @Override - public void run() { - try { - decoratedRun.run(); - } catch (Throwable e) { - // make sure the worker is released if the run crashes - acr.dispose(); - throw Exceptions.propagate(e); - } + acr.setResource(1, w.schedulePeriodically(() -> { + try { + decoratedRun.run(); + } catch (Throwable e) { + // make sure the worker is released if the run crashes + acr.dispose(); + throw Exceptions.propagate(e); } }, initialDelay, period, unit)); @@ -118,9 +112,9 @@ public Disposable schedule(Runnable run) { } public Disposable schedulePeriodically(Runnable run, final long initialDelay, final long period, final TimeUnit unit) { - final MultipleAssignmentResource first = new MultipleAssignmentResource(Disposables.consumeAndDispose()); + final MultipleAssignmentResource first = new MultipleAssignmentResource<>(Disposables.consumeAndDispose()); - final MultipleAssignmentResource mar = new MultipleAssignmentResource(Disposables.consumeAndDispose(), first); + final MultipleAssignmentResource mar = new MultipleAssignmentResource<>(Disposables.consumeAndDispose(), first); final Runnable decoratedRun = RxJavaPlugins.onSchedule(run); diff --git a/src/main/java/io/reactivex/Single.java b/rxjava/src/main/java/io/reactivex/Single.java similarity index 58% rename from src/main/java/io/reactivex/Single.java rename to rxjava/src/main/java/io/reactivex/Single.java index 617d0505ec..eab287a50c 100644 --- a/src/main/java/io/reactivex/Single.java +++ b/rxjava/src/main/java/io/reactivex/Single.java @@ -62,99 +62,96 @@ public interface SingleTransformer extends Function Single amb(final Iterable> sources) { Objects.requireNonNull(sources, "sources is null"); - return create(new SingleOnSubscribe() { - @Override - public void accept(final SingleSubscriber s) { - final AtomicBoolean once = new AtomicBoolean(); - final CompositeDisposable set = new CompositeDisposable(); - s.onSubscribe(set); - - int c = 0; - Iterator> iterator; - + return create(s -> { + final AtomicBoolean once = new AtomicBoolean(); + final CompositeDisposable set = new CompositeDisposable(); + s.onSubscribe(set); + + int c = 0; + Iterator> iterator; + + try { + iterator = sources.iterator(); + } catch (Throwable e) { + s.onError(e); + return; + } + + if (iterator == null) { + s.onError(new NullPointerException("The iterator returned is null")); + return; + } + for (;;) { + if (once.get()) { + return; + } + + boolean b; + try { - iterator = sources.iterator(); + b = iterator.hasNext(); } catch (Throwable e) { s.onError(e); return; } - - if (iterator == null) { - s.onError(new NullPointerException("The iterator returned is null")); + + if (once.get()) { return; } - for (;;) { - if (once.get()) { - return; - } - - boolean b; - - try { - b = iterator.hasNext(); - } catch (Throwable e) { - s.onError(e); - return; - } - - if (once.get()) { - return; - } - if (!b) { - break; - } - - Single s1; + if (!b) { + break; + } - if (once.get()) { - return; - } + Single s1; - try { - s1 = iterator.next(); - } catch (Throwable e) { - set.dispose(); - s.onError(e); - return; - } - - if (s1 == null) { - set.dispose(); - s.onError(new NullPointerException("The single source returned by the iterator is null")); - return; + if (once.get()) { + return; + } + + try { + s1 = iterator.next(); + } catch (Throwable e) { + set.dispose(); + s.onError(e); + return; + } + + if (s1 == null) { + set.dispose(); + s.onError(new NullPointerException("The single source returned by the iterator is null")); + return; + } + + s1.subscribe(new SingleSubscriber() { + + @Override + public void onSubscribe(Disposable d) { + set.add(d); } - - s1.subscribe(new SingleSubscriber() { - @Override - public void onSubscribe(Disposable d) { - set.add(d); + @Override + public void onSuccess(T value) { + if (once.compareAndSet(false, true)) { + s.onSuccess(value); } + } - @Override - public void onSuccess(T value) { - if (once.compareAndSet(false, true)) { - s.onSuccess(value); - } + @Override + public void onError(Throwable e) { + if (once.compareAndSet(false, true)) { + s.onError(e); + } else { + RxJavaPlugins.onError(e); } + } - @Override - public void onError(Throwable e) { - if (once.compareAndSet(false, true)) { - s.onError(e); - } else { - RxJavaPlugins.onError(e); - } - } - - }); - c++; - } - - if (c == 0 && !set.isDisposed()) { - s.onError(new NoSuchElementException()); - } + }); + c++; + } + + if (c == 0 && !set.isDisposed()) { + s.onError(new NoSuchElementException()); } }); } @@ -162,64 +159,56 @@ public void onError(Throwable e) { @SuppressWarnings("unchecked") public static Single amb(final Single... sources) { if (sources.length == 0) { - return error(new Supplier() { - @Override - public Throwable get() { - return new NoSuchElementException(); - } - }); + return error(NoSuchElementException::new); } if (sources.length == 1) { return (Single)sources[0]; } - return create(new SingleOnSubscribe() { - @Override - public void accept(final SingleSubscriber s) { - final AtomicBoolean once = new AtomicBoolean(); - final CompositeDisposable set = new CompositeDisposable(); - s.onSubscribe(set); - - for (Single s1 : sources) { - if (once.get()) { - return; + return create(s -> { + final AtomicBoolean once = new AtomicBoolean(); + final CompositeDisposable set = new CompositeDisposable(); + s.onSubscribe(set); + + for (Single s1 : sources) { + if (once.get()) { + return; + } + + if (s1 == null) { + set.dispose(); + Throwable e = new NullPointerException("One of the sources is null"); + if (once.compareAndSet(false, true)) { + s.onError(e); + } else { + RxJavaPlugins.onError(e); } - - if (s1 == null) { - set.dispose(); - Throwable e = new NullPointerException("One of the sources is null"); + return; + } + + s1.subscribe(new SingleSubscriber() { + + @Override + public void onSubscribe(Disposable d) { + set.add(d); + } + + @Override + public void onSuccess(T value) { + if (once.compareAndSet(false, true)) { + s.onSuccess(value); + } + } + + @Override + public void onError(Throwable e) { if (once.compareAndSet(false, true)) { s.onError(e); } else { RxJavaPlugins.onError(e); } - return; } - - s1.subscribe(new SingleSubscriber() { - - @Override - public void onSubscribe(Disposable d) { - set.add(d); - } - - @Override - public void onSuccess(T value) { - if (once.compareAndSet(false, true)) { - s.onSuccess(value); - } - } - @Override - public void onError(Throwable e) { - if (once.compareAndSet(false, true)) { - s.onError(e); - } else { - RxJavaPlugins.onError(e); - } - } - - }); - } + }); } }); } @@ -356,84 +345,70 @@ public static Observable concat( public static Single create(SingleOnSubscribe onSubscribe) { Objects.requireNonNull(onSubscribe, "onSubscribe is null"); // TODO plugin wrapper - return new Single(onSubscribe); + return new Single<>(onSubscribe); } public static Single defer(final Supplier> singleSupplier) { Objects.requireNonNull(singleSupplier, "singleSupplier is null"); - return create(new SingleOnSubscribe() { - @Override - public void accept(SingleSubscriber s) { - Single next; - - try { - next = singleSupplier.get(); - } catch (Throwable e) { - s.onSubscribe(EmptyDisposable.INSTANCE); - s.onError(e); - return; - } - - if (next == null) { - s.onSubscribe(EmptyDisposable.INSTANCE); - s.onError(new NullPointerException("The Single supplied was null")); - return; - } - - next.subscribe(s); + return create(s -> { + Single next; + + try { + next = singleSupplier.get(); + } catch (Throwable e) { + s.onSubscribe(EmptyDisposable.INSTANCE); + s.onError(e); + return; + } + + if (next == null) { + s.onSubscribe(EmptyDisposable.INSTANCE); + s.onError(new NullPointerException("The Single supplied was null")); + return; } + + next.subscribe(s); }); } public static Single error(final Supplier errorSupplier) { Objects.requireNonNull(errorSupplier, "errorSupplier is null"); - return create(new SingleOnSubscribe() { - @Override - public void accept(SingleSubscriber s) { - Throwable error; - - try { - error = errorSupplier.get(); - } catch (Throwable e) { - error = e; - } - - if (error == null) { - error = new NullPointerException(); - } - - s.onSubscribe(EmptyDisposable.INSTANCE); - s.onError(error); + return create(s -> { + Throwable error; + + try { + error = errorSupplier.get(); + } catch (Throwable e) { + error = e; + } + + if (error == null) { + error = new NullPointerException(); } + + s.onSubscribe(EmptyDisposable.INSTANCE); + s.onError(error); }); } public static Single error(final Throwable error) { Objects.requireNonNull(error, "error is null"); - return error(new Supplier() { - @Override - public Throwable get() { - return error; - } - }); + return error(() -> error); } public static Single fromCallable(final Callable callable) { Objects.requireNonNull(callable, "callable is null"); - return create(new SingleOnSubscribe() { - @Override - public void accept(SingleSubscriber s) { - s.onSubscribe(EmptyDisposable.INSTANCE); - try { - T v = callable.call(); - if (v != null) { - s.onSuccess(v); - } else { - s.onError(new NullPointerException()); - } - } catch (Throwable e) { - s.onError(e); + return create(s -> { + s.onSubscribe(EmptyDisposable.INSTANCE); + try { + T v = callable.call(); + if (v != null) { + s.onSuccess(v); + } else { + s.onError(new NullPointerException()); } + } catch (Throwable e) { + s.onError(e); } }); } @@ -456,52 +431,46 @@ public static Single fromFuture(Future future, Scheduler sch public static Single fromPublisher(final Publisher publisher) { Objects.requireNonNull(publisher, "publisher is null"); - return create(new SingleOnSubscribe() { - @Override - public void accept(final SingleSubscriber s) { - publisher.subscribe(new Subscriber() { - T value; - @Override - public void onComplete() { - T v = value; - value = null; - if (v != null) { - s.onSuccess(v); - } else { - s.onError(new NoSuchElementException()); - } + return create(s -> { + publisher.subscribe(new Subscriber() { + T value; + @Override + public void onComplete() { + T v = value; + value = null; + if (v != null) { + s.onSuccess(v); + } else { + s.onError(new NoSuchElementException()); } + } - @Override - public void onError(Throwable t) { - value = null; - s.onError(t); - } + @Override + public void onError(Throwable t) { + value = null; + s.onError(t); + } - @Override - public void onNext(T t) { - value = t; - } + @Override + public void onNext(T t) { + value = t; + } - @Override - public void onSubscribe(Subscription inner) { - s.onSubscribe(Disposables.from(inner)); - inner.request(Long.MAX_VALUE); - } - - }); - } + @Override + public void onSubscribe(Subscription inner) { + s.onSubscribe(Disposables.from(inner)); + inner.request(Long.MAX_VALUE); + } + + }); }); } public static Single just(final T value) { Objects.requireNonNull(value, "value is null"); - return create(new SingleOnSubscribe() { - @Override - public void accept(SingleSubscriber s) { - s.onSubscribe(EmptyDisposable.INSTANCE); - s.onSuccess(value); - } + return create(s -> { + s.onSubscribe(EmptyDisposable.INSTANCE); + s.onSuccess(value); }); } @@ -639,12 +608,7 @@ public static Observable merge( return merge(Observable.fromArray(s1, s2, s3, s4, s5, s6, s7, s8, s9)); } - static final Single NEVER = create(new SingleOnSubscribe() { - @Override - public void accept(SingleSubscriber s) { - s.onSubscribe(EmptyDisposable.INSTANCE); - } - }); + static final Single NEVER = create(s -> s.onSubscribe(EmptyDisposable.INSTANCE)); @SuppressWarnings("unchecked") public static Single never() { @@ -658,74 +622,63 @@ public static Single timer(long delay, TimeUnit unit) { public static Single timer(final long delay, final TimeUnit unit, final Scheduler scheduler) { Objects.requireNonNull(unit, "unit is null"); Objects.requireNonNull(scheduler, "scheduler is null"); - return create(new SingleOnSubscribe() { - @Override - public void accept(final SingleSubscriber s) { - MultipleAssignmentDisposable mad = new MultipleAssignmentDisposable(); - - s.onSubscribe(mad); - - mad.set(scheduler.scheduleDirect(new Runnable() { - @Override - public void run() { - s.onSuccess(0L); - } - }, delay, unit)); - } + return create(s -> { + MultipleAssignmentDisposable mad = new MultipleAssignmentDisposable(); + + s.onSubscribe(mad); + + mad.set(scheduler.scheduleDirect(() -> s.onSuccess(0L), delay, unit)); }); } public static Single equals(final Single first, final Single second) { Objects.requireNonNull(first, "first is null"); Objects.requireNonNull(second, "second is null"); - return create(new SingleOnSubscribe() { - @Override - public void accept(final SingleSubscriber s) { - final AtomicInteger count = new AtomicInteger(); - final Object[] values = { null, null }; - - final CompositeDisposable set = new CompositeDisposable(); - s.onSubscribe(set); - - class InnerSubscriber implements SingleSubscriber { - final int index; - public InnerSubscriber(int index) { - this.index = index; - } - @Override - public void onSubscribe(Disposable d) { - set.add(d); - } + return create(s -> { + final AtomicInteger count = new AtomicInteger(); + final Object[] values = { null, null }; - @Override - public void onSuccess(T value) { - values[index] = value; - - if (count.incrementAndGet() == 2) { - s.onSuccess(Objects.equals(values[0], values[1])); - } - } + final CompositeDisposable set = new CompositeDisposable(); + s.onSubscribe(set); - @Override - public void onError(Throwable e) { - for (;;) { - int state = count.get(); - if (state >= 2) { - RxJavaPlugins.onError(e); - return; - } - if (count.compareAndSet(state, 2)) { - s.onError(e); - return; - } - } - } - + class InnerSubscriber implements SingleSubscriber { + final int index; + public InnerSubscriber(int index) { + this.index = index; } - - first.subscribe(new InnerSubscriber(0)); - second.subscribe(new InnerSubscriber(1)); - } + @Override + public void onSubscribe(Disposable d) { + set.add(d); + } + + @Override + public void onSuccess(T value) { + values[index] = value; + + if (count.incrementAndGet() == 2) { + s.onSuccess(Objects.equals(values[0], values[1])); + } + } + + @Override + public void onError(Throwable e) { + for (;;) { + int state = count.get(); + if (state >= 2) { + RxJavaPlugins.onError(e); + return; + } + if (count.compareAndSet(state, 2)) { + s.onError(e); + return; + } + } + } + + } + + first.subscribe(new InnerSubscriber(0)); + second.subscribe(new InnerSubscriber(1)); }); } @@ -743,98 +696,92 @@ public static Single using( Objects.requireNonNull(singleFunction, "singleFunction is null"); Objects.requireNonNull(disposer, "disposer is null"); - return create(new SingleOnSubscribe() { - @Override - public void accept(final SingleSubscriber s) { - final U resource; - - try { - resource = resourceSupplier.get(); - } catch (Throwable ex) { - s.onSubscribe(EmptyDisposable.INSTANCE); - s.onError(ex); - return; - } - - Single s1; - - try { - s1 = singleFunction.apply(resource); - } catch (Throwable ex) { - s.onSubscribe(EmptyDisposable.INSTANCE); - s.onError(ex); - return; - } - - if (s1 == null) { - s.onSubscribe(EmptyDisposable.INSTANCE); - s.onError(new NullPointerException("The Single supplied by the function was null")); - return; - } - - s1.subscribe(new SingleSubscriber() { + return create(s -> { + final U resource; - @Override - public void onSubscribe(Disposable d) { - if (eager) { - CompositeDisposable set = new CompositeDisposable(); - set.add(d); - set.add(new Disposable() { - @Override - public void dispose() { - try { - disposer.accept(resource); - } catch (Throwable e) { - RxJavaPlugins.onError(e); - } - } - }); - } else { - s.onSubscribe(d); - } - } + try { + resource = resourceSupplier.get(); + } catch (Throwable ex) { + s.onSubscribe(EmptyDisposable.INSTANCE); + s.onError(ex); + return; + } - @Override - public void onSuccess(T value) { - if (eager) { - try { - disposer.accept(resource); - } catch (Throwable e) { - s.onError(e); - return; - } - } - s.onSuccess(value); - if (!eager) { + Single s1; + + try { + s1 = singleFunction.apply(resource); + } catch (Throwable ex) { + s.onSubscribe(EmptyDisposable.INSTANCE); + s.onError(ex); + return; + } + + if (s1 == null) { + s.onSubscribe(EmptyDisposable.INSTANCE); + s.onError(new NullPointerException("The Single supplied by the function was null")); + return; + } + + s1.subscribe(new SingleSubscriber() { + + @Override + public void onSubscribe(Disposable d) { + if (eager) { + CompositeDisposable set = new CompositeDisposable(); + set.add(d); + set.add(() -> { try { disposer.accept(resource); } catch (Throwable e) { RxJavaPlugins.onError(e); } + }); + } else { + s.onSubscribe(d); + } + } + + @Override + public void onSuccess(T value) { + if (eager) { + try { + disposer.accept(resource); + } catch (Throwable e) { + s.onError(e); + return; + } + } + s.onSuccess(value); + if (!eager) { + try { + disposer.accept(resource); + } catch (Throwable e) { + RxJavaPlugins.onError(e); } } + } - @Override - public void onError(Throwable e) { - if (eager) { - try { - disposer.accept(resource); - } catch (Throwable ex) { - e = new CompositeException(ex, e); - } + @Override + public void onError(Throwable e) { + if (eager) { + try { + disposer.accept(resource); + } catch (Throwable ex) { + e = new CompositeException(ex, e); } - s.onError(e); - if (!eager) { - try { - disposer.accept(resource); - } catch (Throwable ex) { - RxJavaPlugins.onError(ex); - } + } + s.onError(e); + if (!eager) { + try { + disposer.accept(resource); + } catch (Throwable ex) { + RxJavaPlugins.onError(ex); } } - - }); - } + } + + }); }); } @@ -842,28 +789,25 @@ public void onError(Throwable e) { public static Single zip(final Iterable> sources, Function zipper) { Objects.requireNonNull(sources, "sources is null"); - Iterable> it = new Iterable>() { - @Override - public Iterator> iterator() { - final Iterator> sit = sources.iterator(); - return new Iterator>() { + Iterable> it = () -> { + final Iterator> sit = sources.iterator(); + return new Iterator>() { - @Override - public boolean hasNext() { - return sit.hasNext(); - } + @Override + public boolean hasNext() { + return sit.hasNext(); + } - @Override - public Observable next() { - return ((Observable)sit.next().toFlowable()); - } - - @Override - public void remove() { - throw new UnsupportedOperationException(); - } - }; - } + @Override + public Observable next() { + return ((Observable)sit.next().toFlowable()); + } + + @Override + public void remove() { + throw new UnsupportedOperationException(); + } + }; }; return Observable.zipIterable(zipper, false, 1, it).toSingle(); } @@ -1016,12 +960,7 @@ public final Single ambWith(Single other) { } public final Single asSingle() { - return create(new SingleOnSubscribe() { - @Override - public void accept(SingleSubscriber s) { - subscribe(s); - } - }); + return create(this::subscribe); } public final Single compose(Function, ? extends Single> convert) { @@ -1030,113 +969,103 @@ public final Single compose(Function, ? extends Single< public final Single cache() { final AtomicInteger wip = new AtomicInteger(); - final AtomicReference notification = new AtomicReference(); - final List> subscribers = new ArrayList>(); + final AtomicReference notification = new AtomicReference<>(); + final List> subscribers = new ArrayList<>(); - return create(new SingleOnSubscribe() { - @Override - public void accept(SingleSubscriber s) { - Object o = notification.get(); - if (o != null) { - s.onSubscribe(EmptyDisposable.INSTANCE); - if (NotificationLite.isError(o)) { - s.onError(NotificationLite.getError(o)); - } else { - s.onSuccess(NotificationLite.getValue(o)); - } - return; + return create(s -> { + Object o = notification.get(); + if (o != null) { + s.onSubscribe(EmptyDisposable.INSTANCE); + if (NotificationLite.isError(o)) { + s.onError(NotificationLite.getError(o)); + } else { + s.onSuccess(NotificationLite.getValue(o)); } - - synchronized (subscribers) { - o = notification.get(); - if (o == null) { - subscribers.add(s); - } + return; + } + + synchronized (subscribers) { + o = notification.get(); + if (o == null) { + subscribers.add(s); } - if (o != null) { - s.onSubscribe(EmptyDisposable.INSTANCE); - if (NotificationLite.isError(o)) { - s.onError(NotificationLite.getError(o)); - } else { - s.onSuccess(NotificationLite.getValue(o)); - } - return; + } + if (o != null) { + s.onSubscribe(EmptyDisposable.INSTANCE); + if (NotificationLite.isError(o)) { + s.onError(NotificationLite.getError(o)); + } else { + s.onSuccess(NotificationLite.getValue(o)); } - - if (wip.getAndIncrement() != 0) { - return; + return; + } + + if (wip.getAndIncrement() != 0) { + return; + } + + subscribe(new SingleSubscriber() { + + @Override + public void onSubscribe(Disposable d) { + } - - subscribe(new SingleSubscriber() { - @Override - public void onSubscribe(Disposable d) { - + @Override + public void onSuccess(T value) { + notification.set(NotificationLite.next(value)); + List> list; + synchronized (subscribers) { + list = new ArrayList<>(subscribers); + subscribers.clear(); } - - @Override - public void onSuccess(T value) { - notification.set(NotificationLite.next(value)); - List> list; - synchronized (subscribers) { - list = new ArrayList>(subscribers); - subscribers.clear(); - } - for (SingleSubscriber s1 : list) { - s1.onSuccess(value); - } + for (SingleSubscriber s1 : list) { + s1.onSuccess(value); } + } - @Override - public void onError(Throwable e) { - notification.set(NotificationLite.error(e)); - List> list; - synchronized (subscribers) { - list = new ArrayList>(subscribers); - subscribers.clear(); - } - for (SingleSubscriber s1 : list) { - s1.onError(e); - } + @Override + public void onError(Throwable e) { + notification.set(NotificationLite.error(e)); + List> list; + synchronized (subscribers) { + list = new ArrayList<>(subscribers); + subscribers.clear(); } - - }); - } + for (SingleSubscriber s1 : list) { + s1.onError(e); + } + } + + }); }); } public final Single cast(final Class clazz) { Objects.requireNonNull(clazz, "clazz is null"); - return create(new SingleOnSubscribe() { + return create(s -> subscribe(new SingleSubscriber() { @Override - public void accept(final SingleSubscriber s) { - subscribe(new SingleSubscriber() { - - @Override - public void onSubscribe(Disposable d) { - s.onSubscribe(d); - } + public void onSubscribe(Disposable d) { + s.onSubscribe(d); + } - @Override - public void onSuccess(T value) { - U v; - try { - v = clazz.cast(value); - } catch (ClassCastException ex) { - s.onError(ex); - return; - } - s.onSuccess(v); - } + @Override + public void onSuccess(T value) { + U v; + try { + v = clazz.cast(value); + } catch (ClassCastException ex) { + s.onError(ex); + return; + } + s.onSuccess(v); + } - @Override - public void onError(Throwable e) { - s.onError(e); - } - - }); + @Override + public void onError(Throwable e) { + s.onError(e); } - }); + })); } public final Observable concatWith(Single other) { @@ -1150,176 +1079,156 @@ public final Single delay(long time, TimeUnit unit) { public final Single delay(final long time, final TimeUnit unit, final Scheduler scheduler) { Objects.requireNonNull(unit, "unit is null"); Objects.requireNonNull(scheduler, "scheduler is null"); - return create(new SingleOnSubscribe() { - @Override - public void accept(final SingleSubscriber s) { - final MultipleAssignmentDisposable mad = new MultipleAssignmentDisposable(); - s.onSubscribe(mad); - subscribe(new SingleSubscriber() { - @Override - public void onSubscribe(Disposable d) { - mad.set(d); - } + return create(s -> { + final MultipleAssignmentDisposable mad = new MultipleAssignmentDisposable(); + s.onSubscribe(mad); + subscribe(new SingleSubscriber() { + @Override + public void onSubscribe(Disposable d) { + mad.set(d); + } - @Override - public void onSuccess(final T value) { - mad.set(scheduler.scheduleDirect(new Runnable() { - @Override - public void run() { - s.onSuccess(value); - } - }, time, unit)); - } + @Override + public void onSuccess(final T value) { + mad.set(scheduler.scheduleDirect(() -> s.onSuccess(value), time, unit)); + } - @Override - public void onError(Throwable e) { - s.onError(e); - } - - }); - } + @Override + public void onError(Throwable e) { + s.onError(e); + } + + }); }); } public final Single doOnSubscribe(final Consumer onSubscribe) { Objects.requireNonNull(onSubscribe, "onSubscribe is null"); - return create(new SingleOnSubscribe() { - @Override - public void accept(final SingleSubscriber s) { - subscribe(new SingleSubscriber() { - boolean done; - @Override - public void onSubscribe(Disposable d) { - try { - onSubscribe.accept(d); - } catch (Throwable ex) { - done = true; - d.dispose(); - s.onSubscribe(EmptyDisposable.INSTANCE); - s.onError(ex); - return; - } - - s.onSubscribe(d); + return create(s -> { + subscribe(new SingleSubscriber() { + boolean done; + @Override + public void onSubscribe(Disposable d) { + try { + onSubscribe.accept(d); + } catch (Throwable ex) { + done = true; + d.dispose(); + s.onSubscribe(EmptyDisposable.INSTANCE); + s.onError(ex); + return; } - @Override - public void onSuccess(T value) { - if (done) { - return; - } - s.onSuccess(value); + s.onSubscribe(d); + } + + @Override + public void onSuccess(T value) { + if (done) { + return; } + s.onSuccess(value); + } - @Override - public void onError(Throwable e) { - if (done) { - RxJavaPlugins.onError(e); - return; - } - s.onError(e); + @Override + public void onError(Throwable e) { + if (done) { + RxJavaPlugins.onError(e); + return; } - - }); - } + s.onError(e); + } + + }); }); } public final Single doOnSuccess(final Consumer onSuccess) { Objects.requireNonNull(onSuccess, "onSuccess is null"); - return create(new SingleOnSubscribe() { - @Override - public void accept(final SingleSubscriber s) { - subscribe(new SingleSubscriber() { - @Override - public void onSubscribe(Disposable d) { - s.onSubscribe(d); - } + return create(s -> { + subscribe(new SingleSubscriber() { + @Override + public void onSubscribe(Disposable d) { + s.onSubscribe(d); + } - @Override - public void onSuccess(T value) { - try { - onSuccess.accept(value); - } catch (Throwable ex) { - s.onError(ex); - return; - } - s.onSuccess(value); + @Override + public void onSuccess(T value) { + try { + onSuccess.accept(value); + } catch (Throwable ex) { + s.onError(ex); + return; } + s.onSuccess(value); + } - @Override - public void onError(Throwable e) { - s.onError(e); - } - - }); - } + @Override + public void onError(Throwable e) { + s.onError(e); + } + + }); }); } public final Single doOnError(final Consumer onError) { Objects.requireNonNull(onError, "onError is null"); - return create(new SingleOnSubscribe() { - @Override - public void accept(final SingleSubscriber s) { - subscribe(new SingleSubscriber() { - @Override - public void onSubscribe(Disposable d) { - s.onSubscribe(d); - } - - @Override - public void onSuccess(T value) { - s.onSuccess(value); - } - - @Override - public void onError(Throwable e) { - try { - onError.accept(e); - } catch (Throwable ex) { - e = new CompositeException(ex, e); - } - s.onError(e); + return create(s -> { + subscribe(new SingleSubscriber() { + @Override + public void onSubscribe(Disposable d) { + s.onSubscribe(d); + } + + @Override + public void onSuccess(T value) { + s.onSuccess(value); + } + + @Override + public void onError(Throwable e) { + try { + onError.accept(e); + } catch (Throwable ex) { + e = new CompositeException(ex, e); } - - }); - } + s.onError(e); + } + + }); }); } public final Single doOnCancel(final Runnable onCancel) { Objects.requireNonNull(onCancel, "onCancel is null"); - return create(new SingleOnSubscribe() { - @Override - public void accept(final SingleSubscriber s) { - subscribe(new SingleSubscriber() { - @Override - public void onSubscribe(Disposable d) { - CompositeDisposable set = new CompositeDisposable(); - set.add(Disposables.from(onCancel)); - set.add(d); - s.onSubscribe(set); - } + return create(s -> { + subscribe(new SingleSubscriber() { + @Override + public void onSubscribe(Disposable d) { + CompositeDisposable set = new CompositeDisposable(); + set.add(Disposables.from(onCancel)); + set.add(d); + s.onSubscribe(set); + } - @Override - public void onSuccess(T value) { - s.onSuccess(value); - } + @Override + public void onSuccess(T value) { + s.onSuccess(value); + } - @Override - public void onError(Throwable e) { - s.onError(e); - } - - }); - } + @Override + public void onError(Throwable e) { + s.onError(e); + } + + }); }); } public final Single flatMap(Function> mapper) { Objects.requireNonNull(mapper, "mapper is null"); - return lift(new SingleOperatorFlatMap(mapper)); + return lift(new SingleOperatorFlatMap<>(mapper)); } public final Observable flatMapPublisher(Function> mapper) { @@ -1327,8 +1236,8 @@ public final Observable flatMapPublisher(Function valueRef = new AtomicReference(); - final AtomicReference errorRef = new AtomicReference(); + final AtomicReference valueRef = new AtomicReference<>(); + final AtomicReference errorRef = new AtomicReference<>(); final CountDownLatch cdl = new CountDownLatch(1); subscribe(new SingleSubscriber() { @@ -1364,31 +1273,28 @@ public void onSuccess(T value) { public final Single lift(final SingleOperator onLift) { Objects.requireNonNull(onLift, "onLift is null"); - return create(new SingleOnSubscribe() { - @Override - public void accept(SingleSubscriber s) { - try { - SingleSubscriber sr = onLift.apply(s); - - if (sr == null) { - throw new NullPointerException("The onLift returned a null subscriber"); - } - // TODO plugin wrapper - onSubscribe.accept(sr); - } catch (NullPointerException ex) { - throw ex; - } catch (Throwable ex) { - RxJavaPlugins.onError(ex); - NullPointerException npe = new NullPointerException("Not really but can't throw other than NPE"); - npe.initCause(ex); - throw npe; + return create(s -> { + try { + SingleSubscriber sr = onLift.apply(s); + + if (sr == null) { + throw new NullPointerException("The onLift returned a null subscriber"); } + // TODO plugin wrapper + onSubscribe.accept(sr); + } catch (NullPointerException ex) { + throw ex; + } catch (Throwable ex) { + RxJavaPlugins.onError(ex); + NullPointerException npe = new NullPointerException("Not really but can't throw other than NPE"); + npe.initCause(ex); + throw npe; } }); } public final Single map(Function mapper) { - return lift(new SingleOperatorMap(mapper)); + return lift(new SingleOperatorMap<>(mapper)); } public final Single contains(Object value) { @@ -1398,29 +1304,22 @@ public final Single contains(Object value) { public final Single contains(final Object value, final BiPredicate comparer) { Objects.requireNonNull(value, "value is null"); Objects.requireNonNull(comparer, "comparer is null"); - return create(new SingleOnSubscribe() { + return create(s -> subscribe(new SingleSubscriber() { @Override - public void accept(final SingleSubscriber s) { - subscribe(new SingleSubscriber() { - - @Override - public void onSubscribe(Disposable d) { - s.onSubscribe(d); - } + public void onSubscribe(Disposable d) { + s.onSubscribe(d); + } - @Override - public void onSuccess(T v) { - s.onSuccess(comparer.test(v, value)); - } + @Override + public void onSuccess(T v) { + s.onSuccess(comparer.test(v, value)); + } - @Override - public void onError(Throwable e) { - s.onError(e); - } - - }); + @Override + public void onError(Throwable e) { + s.onError(e); } - }); + })); } public final Observable mergeWith(Single other) { @@ -1433,158 +1332,130 @@ public final Single> nest() { public final Single observeOn(final Scheduler scheduler) { Objects.requireNonNull(scheduler, "scheduler is null"); - return create(new SingleOnSubscribe() { - @Override - public void accept(final SingleSubscriber s) { - final CompositeDisposable mad = new CompositeDisposable(); - s.onSubscribe(mad); - - subscribe(new SingleSubscriber() { + return create(s -> { + final CompositeDisposable mad = new CompositeDisposable(); + s.onSubscribe(mad); - @Override - public void onError(final Throwable e) { - mad.add(scheduler.scheduleDirect(new Runnable() { - @Override - public void run() { - s.onError(e); - } - })); - } + subscribe(new SingleSubscriber() { - @Override - public void onSubscribe(Disposable d) { - mad.add(d); - } + @Override + public void onError(final Throwable e) { + mad.add(scheduler.scheduleDirect(() -> s.onError(e))); + } - @Override - public void onSuccess(final T value) { - mad.add(scheduler.scheduleDirect(new Runnable() { - @Override - public void run() { - s.onSuccess(value); - } - })); - } - - }); - } + @Override + public void onSubscribe(Disposable d) { + mad.add(d); + } + + @Override + public void onSuccess(final T value) { + mad.add(scheduler.scheduleDirect(() -> s.onSuccess(value))); + } + + }); }); } public final Single onErrorReturn(final Supplier valueSupplier) { Objects.requireNonNull(valueSupplier, "valueSupplier is null"); - return create(new SingleOnSubscribe() { + return create(s -> subscribe(new SingleSubscriber() { @Override - public void accept(final SingleSubscriber s) { - subscribe(new SingleSubscriber() { + public void onError(Throwable e) { + T v; - @Override - public void onError(Throwable e) { - T v; - - try { - v = valueSupplier.get(); - } catch (Throwable ex) { - s.onError(new CompositeException(ex, e)); - return; - } - - if (v == null) { - NullPointerException npe = new NullPointerException("Value supplied was null"); - npe.initCause(e); - s.onError(npe); - return; - } - - s.onSuccess(v); - } + try { + v = valueSupplier.get(); + } catch (Throwable ex) { + s.onError(new CompositeException(ex, e)); + return; + } - @Override - public void onSubscribe(Disposable d) { - s.onSubscribe(d); - } + if (v == null) { + NullPointerException npe = new NullPointerException("Value supplied was null"); + npe.initCause(e); + s.onError(npe); + return; + } - @Override - public void onSuccess(T value) { - s.onSuccess(value); - } - - }); + s.onSuccess(v); } - }); + + @Override + public void onSubscribe(Disposable d) { + s.onSubscribe(d); + } + + @Override + public void onSuccess(T value) { + s.onSuccess(value); + } + })); } public final Single onErrorReturn(final T value) { Objects.requireNonNull(value, "value is null"); - return onErrorReturn(new Supplier() { - @Override - public T get() { - return value; - } - }); + return onErrorReturn(() -> value); } public final Single onErrorResumeNext( final Function> nextFunction) { Objects.requireNonNull(nextFunction, "nextFunction is null"); - return create(new SingleOnSubscribe() { - @Override - public void accept(final SingleSubscriber s) { - final MultipleAssignmentDisposable mad = new MultipleAssignmentDisposable(); - s.onSubscribe(mad); - - subscribe(new SingleSubscriber() { + return create(s -> { + final MultipleAssignmentDisposable mad = new MultipleAssignmentDisposable(); + s.onSubscribe(mad); - @Override - public void onSubscribe(Disposable d) { - mad.set(d); + subscribe(new SingleSubscriber() { + + @Override + public void onSubscribe(Disposable d) { + mad.set(d); + } + + @Override + public void onSuccess(T value) { + s.onSuccess(value); + } + + @Override + public void onError(Throwable e) { + Single next; + + try { + next = nextFunction.apply(e); + } catch (Throwable ex) { + s.onError(new CompositeException(ex, e)); + return; } - @Override - public void onSuccess(T value) { - s.onSuccess(value); + if (next == null) { + NullPointerException npe = new NullPointerException("The next Single supplied was null"); + npe.initCause(e); + s.onError(npe); + return; } - @Override - public void onError(Throwable e) { - Single next; - - try { - next = nextFunction.apply(e); - } catch (Throwable ex) { - s.onError(new CompositeException(ex, e)); - return; + next.subscribe(new SingleSubscriber() { + + @Override + public void onSubscribe(Disposable d) { + mad.set(d); } - - if (next == null) { - NullPointerException npe = new NullPointerException("The next Single supplied was null"); - npe.initCause(e); - s.onError(npe); - return; + + @Override + public void onSuccess(T value) { + s.onSuccess(value); } - - next.subscribe(new SingleSubscriber() { - @Override - public void onSubscribe(Disposable d) { - mad.set(d); - } + @Override + public void onError(Throwable e) { + s.onError(e); + } - @Override - public void onSuccess(T value) { - s.onSuccess(value); - } + }); + } - @Override - public void onError(Throwable e) { - s.onError(e); - } - - }); - } - - }); - } + }); }); } @@ -1699,17 +1570,7 @@ public final void subscribe(Subscriber s) { public final Single subscribeOn(final Scheduler scheduler) { Objects.requireNonNull(scheduler, "scheduler is null"); - return create(new SingleOnSubscribe() { - @Override - public void accept(final SingleSubscriber s) { - scheduler.scheduleDirect(new Runnable() { - @Override - public void run() { - subscribe(s); - } - }); - } - }); + return create(s -> scheduler.scheduleDirect(() -> subscribe(s))); } public final Single timeout(long timeout, TimeUnit unit) { @@ -1733,75 +1594,69 @@ public final Single timeout(long timeout, TimeUnit unit, Single private Single timeout0(final long timeout, final TimeUnit unit, final Scheduler scheduler, final Single other) { Objects.requireNonNull(unit, "unit is null"); Objects.requireNonNull(scheduler, "scheduler is null"); - return create(new SingleOnSubscribe() { - @Override - public void accept(final SingleSubscriber s) { - final CompositeDisposable set = new CompositeDisposable(); - s.onSubscribe(set); - - final AtomicBoolean once = new AtomicBoolean(); - - Disposable timer = scheduler.scheduleDirect(new Runnable() { - @Override - public void run() { - if (once.compareAndSet(false, true)) { - if (other != null) { - set.clear(); - other.subscribe(new SingleSubscriber() { - - @Override - public void onError(Throwable e) { - set.dispose(); - s.onError(e); - } - - @Override - public void onSubscribe(Disposable d) { - set.add(d); - } - - @Override - public void onSuccess(T value) { - set.dispose(); - s.onSuccess(value); - } - - }); - } else { + return create(s -> { + final CompositeDisposable set = new CompositeDisposable(); + s.onSubscribe(set); + + final AtomicBoolean once = new AtomicBoolean(); + + Disposable timer = scheduler.scheduleDirect(() -> { + if (once.compareAndSet(false, true)) { + if (other != null) { + set.clear(); + other.subscribe(new SingleSubscriber() { + + @Override + public void onError(Throwable e) { set.dispose(); - s.onError(new TimeoutException()); + s.onError(e); } - } - } - }, timeout, unit); - - set.add(timer); - - subscribe(new SingleSubscriber() { - @Override - public void onError(Throwable e) { - if (once.compareAndSet(false, true)) { - set.dispose(); - s.onError(e); - } + @Override + public void onSubscribe(Disposable d) { + set.add(d); + } + + @Override + public void onSuccess(T value) { + set.dispose(); + s.onSuccess(value); + } + + }); + } else { + set.dispose(); + s.onError(new TimeoutException()); } + } + }, timeout, unit); - @Override - public void onSubscribe(Disposable d) { - set.add(d); + set.add(timer); + + subscribe(new SingleSubscriber() { + + @Override + public void onError(Throwable e) { + if (once.compareAndSet(false, true)) { + set.dispose(); + s.onError(e); } + } - @Override - public void onSuccess(T value) { - if (once.compareAndSet(false, true)) { - set.dispose(); - s.onSuccess(value); - } + @Override + public void onSubscribe(Disposable d) { + set.add(d); + } + + @Override + public void onSuccess(T value) { + if (once.compareAndSet(false, true)) { + set.dispose(); + s.onSuccess(value); } - - }); - } + } + + }); }); } @@ -1810,10 +1665,8 @@ public final R to(Function, R> convert) { } public final Observable toFlowable() { - return Observable.create(new Publisher() { - @Override - public void subscribe(final Subscriber s) { - final ScalarAsyncSubscription sas = new ScalarAsyncSubscription(s); + return Observable.create(s -> { + final ScalarAsyncSubscription sas = new ScalarAsyncSubscription<>(s); final AsyncSubscription as = new AsyncSubscription(); as.setSubscription(sas); s.onSubscribe(as); @@ -1836,7 +1689,7 @@ public void onSuccess(T value) { }); } - }); + ); } public final void unsafeSubscribe(Subscriber s) { diff --git a/src/main/java/io/reactivex/Try.java b/rxjava/src/main/java/io/reactivex/Try.java similarity index 96% rename from src/main/java/io/reactivex/Try.java rename to rxjava/src/main/java/io/reactivex/Try.java index c069826685..ac8df38ab5 100644 --- a/src/main/java/io/reactivex/Try.java +++ b/rxjava/src/main/java/io/reactivex/Try.java @@ -40,7 +40,7 @@ private Try(T value, Throwable error) { */ public static Try ofValue(T value) { // TODO ? Objects.requireNonNull(value); - return new Try(value, null); + return new Try<>(value, null); } /** @@ -53,7 +53,7 @@ public static Try ofValue(T value) { * @return the new Try instance holding the exception */ public static Try ofError(Throwable e) { - return new Try(null, e != null ? e : new NullPointerException()); + return new Try<>(null, e != null ? e : new NullPointerException()); } /** diff --git a/src/main/java/io/reactivex/annotations/BackpressureKind.java b/rxjava/src/main/java/io/reactivex/annotations/BackpressureKind.java similarity index 100% rename from src/main/java/io/reactivex/annotations/BackpressureKind.java rename to rxjava/src/main/java/io/reactivex/annotations/BackpressureKind.java diff --git a/src/main/java/io/reactivex/annotations/BackpressureSupport.java b/rxjava/src/main/java/io/reactivex/annotations/BackpressureSupport.java similarity index 100% rename from src/main/java/io/reactivex/annotations/BackpressureSupport.java rename to rxjava/src/main/java/io/reactivex/annotations/BackpressureSupport.java diff --git a/src/main/java/io/reactivex/annotations/Beta.java b/rxjava/src/main/java/io/reactivex/annotations/Beta.java similarity index 100% rename from src/main/java/io/reactivex/annotations/Beta.java rename to rxjava/src/main/java/io/reactivex/annotations/Beta.java diff --git a/src/main/java/io/reactivex/annotations/Experimental.java b/rxjava/src/main/java/io/reactivex/annotations/Experimental.java similarity index 100% rename from src/main/java/io/reactivex/annotations/Experimental.java rename to rxjava/src/main/java/io/reactivex/annotations/Experimental.java diff --git a/src/main/java/io/reactivex/annotations/SchedulerKind.java b/rxjava/src/main/java/io/reactivex/annotations/SchedulerKind.java similarity index 100% rename from src/main/java/io/reactivex/annotations/SchedulerKind.java rename to rxjava/src/main/java/io/reactivex/annotations/SchedulerKind.java diff --git a/src/main/java/io/reactivex/annotations/SchedulerSupport.java b/rxjava/src/main/java/io/reactivex/annotations/SchedulerSupport.java similarity index 100% rename from src/main/java/io/reactivex/annotations/SchedulerSupport.java rename to rxjava/src/main/java/io/reactivex/annotations/SchedulerSupport.java diff --git a/src/main/java/io/reactivex/disposables/BooleanDisposable.java b/rxjava/src/main/java/io/reactivex/disposables/BooleanDisposable.java similarity index 80% rename from src/main/java/io/reactivex/disposables/BooleanDisposable.java rename to rxjava/src/main/java/io/reactivex/disposables/BooleanDisposable.java index 2593a2b564..173c877418 100644 --- a/src/main/java/io/reactivex/disposables/BooleanDisposable.java +++ b/rxjava/src/main/java/io/reactivex/disposables/BooleanDisposable.java @@ -16,18 +16,12 @@ import java.util.concurrent.atomic.AtomicReference; public final class BooleanDisposable implements Disposable { - final AtomicReference run = new AtomicReference(); + final AtomicReference run = new AtomicReference<>(); - static final Runnable DISPOSED = new Runnable() { - @Override - public void run() { } - }; + static final Runnable DISPOSED = () -> { }; public BooleanDisposable() { - this(new Runnable() { - @Override - public void run() { } - }); + this(() -> { }); } public BooleanDisposable(Runnable run) { diff --git a/src/main/java/io/reactivex/disposables/CompositeDisposable.java b/rxjava/src/main/java/io/reactivex/disposables/CompositeDisposable.java similarity index 84% rename from src/main/java/io/reactivex/disposables/CompositeDisposable.java rename to rxjava/src/main/java/io/reactivex/disposables/CompositeDisposable.java index 6551b6c85b..e68fe064e3 100644 --- a/src/main/java/io/reactivex/disposables/CompositeDisposable.java +++ b/rxjava/src/main/java/io/reactivex/disposables/CompositeDisposable.java @@ -23,17 +23,17 @@ public final class CompositeDisposable implements Disposable { final SetCompositeResource resources; public CompositeDisposable() { - resources = new SetCompositeResource(Disposables.consumeAndDispose()); + resources = new SetCompositeResource<>(Disposables.consumeAndDispose()); } public CompositeDisposable(Disposable... resources) { Objects.requireNonNull(resources, "resources is null"); - this.resources = new SetCompositeResource(Disposables.consumeAndDispose(), resources); + this.resources = new SetCompositeResource<>(Disposables.consumeAndDispose(), resources); } public CompositeDisposable(Iterable resources) { Objects.requireNonNull(resources, "resources is null"); - this.resources = new SetCompositeResource(Disposables.consumeAndDispose(), resources); + this.resources = new SetCompositeResource<>(Disposables.consumeAndDispose(), resources); } @Override diff --git a/src/main/java/io/reactivex/disposables/Disposable.java b/rxjava/src/main/java/io/reactivex/disposables/Disposable.java similarity index 100% rename from src/main/java/io/reactivex/disposables/Disposable.java rename to rxjava/src/main/java/io/reactivex/disposables/Disposable.java diff --git a/src/main/java/io/reactivex/disposables/Disposables.java b/rxjava/src/main/java/io/reactivex/disposables/Disposables.java similarity index 86% rename from src/main/java/io/reactivex/disposables/Disposables.java rename to rxjava/src/main/java/io/reactivex/disposables/Disposables.java index 894d2f745f..76cb60e13f 100644 --- a/src/main/java/io/reactivex/disposables/Disposables.java +++ b/rxjava/src/main/java/io/reactivex/disposables/Disposables.java @@ -43,12 +43,7 @@ public static Disposable from(Future future) { public static Disposable from(final Subscription subscription) { Objects.requireNonNull(subscription, "subscription is null"); - return new Disposable() { - @Override - public void dispose() { - subscription.cancel(); - } - }; + return subscription::cancel; } public static Disposable from(Future future, boolean allowInterrupt) { @@ -56,20 +51,14 @@ public static Disposable from(Future future, boolean allowInterrupt) { return new FutureDisposable(future, allowInterrupt); } - static final Disposable EMPTY = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable EMPTY = () -> { }; public static Disposable empty() { return EMPTY; } // TODO there is no way to distinguish a disposed and non-disposed resource - static final Disposable DISPOSED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable DISPOSED = () -> { }; public static Disposable disposed() { return DISPOSED; @@ -87,10 +76,7 @@ static final class RunnableDisposable /** */ private static final long serialVersionUID = 4892876354773733738L; - static final Runnable DISPOSED = new Runnable() { - @Override - public void run() { } - }; + static final Runnable DISPOSED = () -> { }; public RunnableDisposable(Runnable run) { super(run); @@ -165,12 +151,7 @@ public Object get(long timeout, TimeUnit unit) } } - static final Consumer DISPOSER = new Consumer() { - @Override - public void accept(Disposable d) { - d.dispose(); - } - }; + static final Consumer DISPOSER = Disposable::dispose; /** * Returns a consumer that calls dispose on the received Disposable. diff --git a/src/main/java/io/reactivex/disposables/MultipleAssignmentDisposable.java b/rxjava/src/main/java/io/reactivex/disposables/MultipleAssignmentDisposable.java similarity index 86% rename from src/main/java/io/reactivex/disposables/MultipleAssignmentDisposable.java rename to rxjava/src/main/java/io/reactivex/disposables/MultipleAssignmentDisposable.java index c243901d82..e32e907109 100644 --- a/src/main/java/io/reactivex/disposables/MultipleAssignmentDisposable.java +++ b/rxjava/src/main/java/io/reactivex/disposables/MultipleAssignmentDisposable.java @@ -19,11 +19,11 @@ public final class MultipleAssignmentDisposable implements Disposable { final MultipleAssignmentResource resource; public MultipleAssignmentDisposable() { - this.resource = new MultipleAssignmentResource(Disposables.consumeAndDispose()); + this.resource = new MultipleAssignmentResource<>(Disposables.consumeAndDispose()); } public MultipleAssignmentDisposable(Disposable initialDisposable) { - this.resource = new MultipleAssignmentResource(Disposables.consumeAndDispose(), initialDisposable); + this.resource = new MultipleAssignmentResource<>(Disposables.consumeAndDispose(), initialDisposable); } public void set(Disposable d) { diff --git a/src/main/java/io/reactivex/disposables/RefCountDisposable.java b/rxjava/src/main/java/io/reactivex/disposables/RefCountDisposable.java similarity index 94% rename from src/main/java/io/reactivex/disposables/RefCountDisposable.java rename to rxjava/src/main/java/io/reactivex/disposables/RefCountDisposable.java index b3fd87daa4..81c74690a8 100644 --- a/src/main/java/io/reactivex/disposables/RefCountDisposable.java +++ b/rxjava/src/main/java/io/reactivex/disposables/RefCountDisposable.java @@ -19,12 +19,9 @@ public final class RefCountDisposable implements Disposable { - final AtomicReference resource = new AtomicReference(); + final AtomicReference resource = new AtomicReference<>(); - static final Disposable DISPOSED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable DISPOSED = () -> { }; final AtomicInteger count = new AtomicInteger(); diff --git a/src/main/java/io/reactivex/disposables/SerialDisposable.java b/rxjava/src/main/java/io/reactivex/disposables/SerialDisposable.java similarity index 87% rename from src/main/java/io/reactivex/disposables/SerialDisposable.java rename to rxjava/src/main/java/io/reactivex/disposables/SerialDisposable.java index f7968b84d7..81a82d9ab0 100644 --- a/src/main/java/io/reactivex/disposables/SerialDisposable.java +++ b/rxjava/src/main/java/io/reactivex/disposables/SerialDisposable.java @@ -19,11 +19,11 @@ public final class SerialDisposable implements Disposable { final SerialResource resource; public SerialDisposable() { - this.resource = new SerialResource(Disposables.consumeAndDispose()); + this.resource = new SerialResource<>(Disposables.consumeAndDispose()); } public SerialDisposable(Disposable initialDisposable) { - this.resource = new SerialResource(Disposables.consumeAndDispose(), initialDisposable); + this.resource = new SerialResource<>(Disposables.consumeAndDispose(), initialDisposable); } diff --git a/src/main/java/io/reactivex/exceptions/CompositeException.java b/rxjava/src/main/java/io/reactivex/exceptions/CompositeException.java similarity index 96% rename from src/main/java/io/reactivex/exceptions/CompositeException.java rename to rxjava/src/main/java/io/reactivex/exceptions/CompositeException.java index d689797ae7..849557bb47 100644 --- a/src/main/java/io/reactivex/exceptions/CompositeException.java +++ b/rxjava/src/main/java/io/reactivex/exceptions/CompositeException.java @@ -47,12 +47,12 @@ public final class CompositeException extends RuntimeException { private final String message; public CompositeException() { - this.exceptions = new ArrayList(); + this.exceptions = new ArrayList<>(); this.message = null; } public CompositeException(Throwable... exceptions) { - this.exceptions = new ArrayList(); + this.exceptions = new ArrayList<>(); this.message = null; if (exceptions == null) { this.exceptions.add(new NullPointerException("exceptions is null")); @@ -65,8 +65,8 @@ public CompositeException(Throwable... exceptions) { public CompositeException(String messagePrefix, Collection errors) { - Set deDupedExceptions = new LinkedHashSet(); - List _exceptions = new ArrayList(); + Set deDupedExceptions = new LinkedHashSet<>(); + List _exceptions = new ArrayList<>(); if (errors != null) { for (Throwable ex : errors) { if (ex instanceof CompositeException) { @@ -123,7 +123,7 @@ public synchronized Throwable getCause() { if (cause == null) { // we lazily generate this causal chain if this is called CompositeExceptionCausalChain _cause = new CompositeExceptionCausalChain(); - Set seenCauses = new HashSet(); + Set seenCauses = new HashSet<>(); Throwable chain = _cause; for (Throwable e : exceptions) { @@ -277,7 +277,7 @@ public String getMessage() { } private List getListOfCauses(Throwable ex) { - List list = new ArrayList(); + List list = new ArrayList<>(); Throwable root = ex.getCause(); if (root == null) { return list; diff --git a/src/main/java/io/reactivex/exceptions/MissingBackpressureException.java b/rxjava/src/main/java/io/reactivex/exceptions/MissingBackpressureException.java similarity index 100% rename from src/main/java/io/reactivex/exceptions/MissingBackpressureException.java rename to rxjava/src/main/java/io/reactivex/exceptions/MissingBackpressureException.java diff --git a/src/main/java/io/reactivex/exceptions/OnCompleteFailedException.java b/rxjava/src/main/java/io/reactivex/exceptions/OnCompleteFailedException.java similarity index 100% rename from src/main/java/io/reactivex/exceptions/OnCompleteFailedException.java rename to rxjava/src/main/java/io/reactivex/exceptions/OnCompleteFailedException.java diff --git a/src/main/java/io/reactivex/exceptions/OnErrorFailedException.java b/rxjava/src/main/java/io/reactivex/exceptions/OnErrorFailedException.java similarity index 100% rename from src/main/java/io/reactivex/exceptions/OnErrorFailedException.java rename to rxjava/src/main/java/io/reactivex/exceptions/OnErrorFailedException.java diff --git a/src/main/java/io/reactivex/exceptions/OnErrorNotImplementedException.java b/rxjava/src/main/java/io/reactivex/exceptions/OnErrorNotImplementedException.java similarity index 100% rename from src/main/java/io/reactivex/exceptions/OnErrorNotImplementedException.java rename to rxjava/src/main/java/io/reactivex/exceptions/OnErrorNotImplementedException.java diff --git a/src/main/java/io/reactivex/exceptions/UnsubscribeFailedException.java b/rxjava/src/main/java/io/reactivex/exceptions/UnsubscribeFailedException.java similarity index 100% rename from src/main/java/io/reactivex/exceptions/UnsubscribeFailedException.java rename to rxjava/src/main/java/io/reactivex/exceptions/UnsubscribeFailedException.java diff --git a/src/main/java/io/reactivex/internal/disposables/ArrayCompositeResource.java b/rxjava/src/main/java/io/reactivex/internal/disposables/ArrayCompositeResource.java similarity index 100% rename from src/main/java/io/reactivex/internal/disposables/ArrayCompositeResource.java rename to rxjava/src/main/java/io/reactivex/internal/disposables/ArrayCompositeResource.java diff --git a/src/main/java/io/reactivex/internal/disposables/CompositeResource.java b/rxjava/src/main/java/io/reactivex/internal/disposables/CompositeResource.java similarity index 100% rename from src/main/java/io/reactivex/internal/disposables/CompositeResource.java rename to rxjava/src/main/java/io/reactivex/internal/disposables/CompositeResource.java diff --git a/src/main/java/io/reactivex/internal/disposables/EmptyDisposable.java b/rxjava/src/main/java/io/reactivex/internal/disposables/EmptyDisposable.java similarity index 100% rename from src/main/java/io/reactivex/internal/disposables/EmptyDisposable.java rename to rxjava/src/main/java/io/reactivex/internal/disposables/EmptyDisposable.java diff --git a/src/main/java/io/reactivex/internal/disposables/ListCompositeResource.java b/rxjava/src/main/java/io/reactivex/internal/disposables/ListCompositeResource.java similarity index 97% rename from src/main/java/io/reactivex/internal/disposables/ListCompositeResource.java rename to rxjava/src/main/java/io/reactivex/internal/disposables/ListCompositeResource.java index 1b1a28042a..6d5a819a52 100644 --- a/src/main/java/io/reactivex/internal/disposables/ListCompositeResource.java +++ b/rxjava/src/main/java/io/reactivex/internal/disposables/ListCompositeResource.java @@ -40,7 +40,7 @@ public ListCompositeResource(Consumer disposer, T... initialResources this(disposer); int n = initialResources.length; if (n != 0) { - list = new LinkedList(); + list = new LinkedList<>(); for (T r : initialResources) { list.add(r); } @@ -49,7 +49,7 @@ public ListCompositeResource(Consumer disposer, T... initialResources public ListCompositeResource(Consumer disposer, Iterable initialResources) { this(disposer); - list = new LinkedList(); + list = new LinkedList<>(); for (T r : initialResources) { list.add(r); } @@ -67,7 +67,7 @@ public boolean add(T newResource) { if (!disposed) { LinkedList a = list; if (a == null) { - a = new LinkedList(); + a = new LinkedList<>(); list = a; } a.add(newResource); diff --git a/src/main/java/io/reactivex/internal/disposables/MultipleAssignmentResource.java b/rxjava/src/main/java/io/reactivex/internal/disposables/MultipleAssignmentResource.java similarity index 100% rename from src/main/java/io/reactivex/internal/disposables/MultipleAssignmentResource.java rename to rxjava/src/main/java/io/reactivex/internal/disposables/MultipleAssignmentResource.java diff --git a/src/main/java/io/reactivex/internal/disposables/NbpFullArbiter.java b/rxjava/src/main/java/io/reactivex/internal/disposables/NbpFullArbiter.java similarity index 96% rename from src/main/java/io/reactivex/internal/disposables/NbpFullArbiter.java rename to rxjava/src/main/java/io/reactivex/internal/disposables/NbpFullArbiter.java index f33eb5a59b..605dc8f5a0 100644 --- a/src/main/java/io/reactivex/internal/disposables/NbpFullArbiter.java +++ b/rxjava/src/main/java/io/reactivex/internal/disposables/NbpFullArbiter.java @@ -32,10 +32,7 @@ public final class NbpFullArbiter extends FullArbiterPad1 implements Disposab final SpscLinkedArrayQueue queue; volatile Disposable s; - static final Disposable INITIAL = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable INITIAL = () -> { }; Disposable resource; @@ -45,7 +42,7 @@ public void dispose() { } public NbpFullArbiter(NbpSubscriber actual, Disposable resource, int capacity) { this.actual = actual; this.resource = resource; - this.queue = new SpscLinkedArrayQueue(capacity); + this.queue = new SpscLinkedArrayQueue<>(capacity); this.s = INITIAL; } diff --git a/src/main/java/io/reactivex/internal/disposables/SerialResource.java b/rxjava/src/main/java/io/reactivex/internal/disposables/SerialResource.java similarity index 100% rename from src/main/java/io/reactivex/internal/disposables/SerialResource.java rename to rxjava/src/main/java/io/reactivex/internal/disposables/SerialResource.java diff --git a/src/main/java/io/reactivex/internal/disposables/SetCompositeResource.java b/rxjava/src/main/java/io/reactivex/internal/disposables/SetCompositeResource.java similarity index 94% rename from src/main/java/io/reactivex/internal/disposables/SetCompositeResource.java rename to rxjava/src/main/java/io/reactivex/internal/disposables/SetCompositeResource.java index 35e07d57ec..33f4d836bc 100644 --- a/src/main/java/io/reactivex/internal/disposables/SetCompositeResource.java +++ b/rxjava/src/main/java/io/reactivex/internal/disposables/SetCompositeResource.java @@ -39,7 +39,7 @@ public SetCompositeResource(Consumer disposer, T... initialResources) this(disposer); int n = initialResources.length; if (n != 0) { - set = new OpenHashSet(n); + set = new OpenHashSet<>(n); for (T r : initialResources) { set.add(r); } @@ -48,7 +48,7 @@ public SetCompositeResource(Consumer disposer, T... initialResources) public SetCompositeResource(Consumer disposer, Iterable initialResources) { this(disposer); - set = new OpenHashSet(); + set = new OpenHashSet<>(); for (T r : initialResources) { set.add(r); } @@ -66,7 +66,7 @@ public boolean add(T newResource) { if (!disposed) { OpenHashSet a = set; if (a == null) { - a = new OpenHashSet(4); + a = new OpenHashSet<>(4); set = a; } a.add(newResource); @@ -123,12 +123,7 @@ public int size() { return 0; } final int[] c = new int[1]; - a.forEach(new Consumer() { - @Override - public void accept(T v) { - c[0]++; - } - }); + a.forEach(v -> c[0]++); return c[0]; } } diff --git a/rxjava/src/main/java/io/reactivex/internal/functions/Functions.java b/rxjava/src/main/java/io/reactivex/internal/functions/Functions.java new file mode 100644 index 0000000000..9e76e2123d --- /dev/null +++ b/rxjava/src/main/java/io/reactivex/internal/functions/Functions.java @@ -0,0 +1,195 @@ +/** + * Copyright 2016 Netflix, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is + * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See + * the License for the specific language governing permissions and limitations under the License. + */ +package io.reactivex.internal.functions; + +import java.util.Comparator; + +import io.reactivex.functions.*; + +/** + * Utility methods to convert the Function3..Function9 instances to Function of Object array. + */ +public enum Functions { + ; + + @SuppressWarnings("unchecked") + public static Function toFunction(final BiFunction biFunction) { + Objects.requireNonNull(biFunction, "biFunction is null"); + return a -> { + if (a.length != 2) { + throw new IllegalArgumentException("Array of size 2 expected but got " + a.length); + } + return biFunction.apply((T1)a[0], (T2)a[1]); + }; + } + + @SuppressWarnings("unchecked") + public static Function toFunction(final Function3 f) { + Objects.requireNonNull(f, "f is null"); + return a -> { + if (a.length != 3) { + throw new IllegalArgumentException("Array of size 3 expected but got " + a.length); + } + return f.apply((T1)a[0], (T2)a[1], (T3)a[2]); + }; + } + + @SuppressWarnings("unchecked") + public static Function toFunction(final Function4 f) { + Objects.requireNonNull(f, "f is null"); + return a -> { + if (a.length != 4) { + throw new IllegalArgumentException("Array of size 4 expected but got " + a.length); + } + return f.apply((T1)a[0], (T2)a[1], (T3)a[2], (T4)a[3]); + }; + } + + @SuppressWarnings("unchecked") + public static Function toFunction(final Function5 f) { + Objects.requireNonNull(f, "f is null"); + return a -> { + if (a.length != 5) { + throw new IllegalArgumentException("Array of size 5 expected but got " + a.length); + } + return f.apply((T1)a[0], (T2)a[1], (T3)a[2], (T4)a[3], (T5)a[4]); + }; + } + + @SuppressWarnings("unchecked") + public static Function toFunction( + final Function6 f) { + Objects.requireNonNull(f, "f is null"); + return a -> { + if (a.length != 6) { + throw new IllegalArgumentException("Array of size 6 expected but got " + a.length); + } + return f.apply((T1)a[0], (T2)a[1], (T3)a[2], (T4)a[3], (T5)a[4], (T6)a[5]); + }; + } + + @SuppressWarnings("unchecked") + public static Function toFunction( + final Function7 f) { + Objects.requireNonNull(f, "f is null"); + return a -> { + if (a.length != 7) { + throw new IllegalArgumentException("Array of size 7 expected but got " + a.length); + } + return f.apply((T1)a[0], (T2)a[1], (T3)a[2], (T4)a[3], (T5)a[4], (T6)a[5], (T7)a[6]); + }; + } + + @SuppressWarnings("unchecked") + public static Function toFunction( + final Function8 f) { + Objects.requireNonNull(f, "f is null"); + return a -> { + if (a.length != 8) { + throw new IllegalArgumentException("Array of size 8 expected but got " + a.length); + } + return f.apply((T1)a[0], (T2)a[1], (T3)a[2], (T4)a[3], (T5)a[4], (T6)a[5], (T7)a[6], (T8)a[7]); + }; + } + + @SuppressWarnings("unchecked") + public static Function toFunction( + final Function9 f) { + Objects.requireNonNull(f, "f is null"); + return a -> { + if (a.length != 9) { + throw new IllegalArgumentException("Array of size 9 expected but got " + a.length); + } + return f.apply((T1)a[0], (T2)a[1], (T3)a[2], (T4)a[3], (T5)a[4], (T6)a[5], (T7)a[6], (T8)a[7], (T9)a[8]); + }; + } + + /** A singleton identity function. */ + static final Function IDENTITY = v -> v; + + /** + * Returns an identity function that simply returns its argument. + * @param the input and output value type + * @return the identity function + */ + @SuppressWarnings("unchecked") + public static Function identity() { + return (Function)IDENTITY; + } + + static final Runnable EMPTY = () -> { }; + + /** + * Returns an empty runnable that does nothing. + * @return an empty runnable that does nothing + */ + public static Runnable emptyRunnable() { + return EMPTY; + } + + static final Consumer EMPTY_CONSUMER = v -> { }; + + /** + * Returns an empty consumer that does nothing. + * @param the consumed value type, the value is ignored + * @return an empty consumer that does nothing. + */ + @SuppressWarnings("unchecked") + public static Consumer emptyConsumer() { + return (Consumer)EMPTY_CONSUMER; + } + + static final LongConsumer EMPTY_LONGCONSUMER = v -> { }; + + /** + * Returns an empty long consumer that does nothing. + * @return an empty long consumer that does nothing. + */ + public static LongConsumer emptyLongConsumer() { + return EMPTY_LONGCONSUMER; + } + + static final Predicate ALWAYS_TRUE = o -> true; + + static final Predicate ALWAYS_FALSE = o -> true; + + static final Supplier NULL_SUPPLIER = () -> null; + + @SuppressWarnings({ "unchecked", "rawtypes" }) + static final Comparator NATURAL_COMPARATOR = (a, b) -> ((Comparable)a).compareTo(b); + + @SuppressWarnings("unchecked") + public static Predicate alwaysTrue() { + return (Predicate)ALWAYS_TRUE; + } + + @SuppressWarnings("unchecked") + public static Predicate alwaysFalse() { + return (Predicate)ALWAYS_FALSE; + } + + @SuppressWarnings("unchecked") + public static Supplier nullSupplier() { + return (Supplier)NULL_SUPPLIER; + } + + /** + * Returns a natural order comparator which casts the parameters to Comparable. + * @param the value type + * @return a natural order comparator which casts the parameters to Comparable + */ + @SuppressWarnings("unchecked") + public static Comparator naturalOrder() { + return (Comparator)NATURAL_COMPARATOR; + } +} diff --git a/src/main/java/io/reactivex/internal/functions/Objects.java b/rxjava/src/main/java/io/reactivex/internal/functions/Objects.java similarity index 92% rename from src/main/java/io/reactivex/internal/functions/Objects.java rename to rxjava/src/main/java/io/reactivex/internal/functions/Objects.java index 5f44695420..bb1bcdb2b5 100644 --- a/src/main/java/io/reactivex/internal/functions/Objects.java +++ b/rxjava/src/main/java/io/reactivex/internal/functions/Objects.java @@ -75,12 +75,7 @@ public static int compare(long v1, long v2) { return v1 < v2 ? -1 : (v1 > v2 ? 1 : 0); } - static final BiPredicate EQUALS = new BiPredicate() { - @Override - public boolean test(Object o1, Object o2) { - return Objects.equals(o1, o2); - } - }; + static final BiPredicate EQUALS = Objects::equals; /** * Returns a BiPredicate that compares its parameters via Objects.equals(). diff --git a/src/main/java/io/reactivex/internal/operators/BlockingOperatorLatest.java b/rxjava/src/main/java/io/reactivex/internal/operators/BlockingOperatorLatest.java similarity index 92% rename from src/main/java/io/reactivex/internal/operators/BlockingOperatorLatest.java rename to rxjava/src/main/java/io/reactivex/internal/operators/BlockingOperatorLatest.java index 28e4265ee9..30078f2177 100644 --- a/src/main/java/io/reactivex/internal/operators/BlockingOperatorLatest.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/BlockingOperatorLatest.java @@ -43,13 +43,10 @@ public enum BlockingOperatorLatest { * been returned by the {@code Iterable}, then returns that item */ public static Iterable latest(final Publisher source) { - return new Iterable() { - @Override - public Iterator iterator() { - LatestObserverIterator lio = new LatestObserverIterator(); - Observable.fromPublisher(source).materialize().subscribe(lio); - return lio; - } + return () -> { + LatestObserverIterator lio = new LatestObserverIterator<>(); + Observable.fromPublisher(source).materialize().subscribe(lio); + return lio; }; } @@ -57,7 +54,7 @@ public Iterator iterator() { static final class LatestObserverIterator extends DisposableSubscriber>> implements Iterator { final Semaphore notify = new Semaphore(0); // observer's notification - final AtomicReference>> value = new AtomicReference>>(); + final AtomicReference>> value = new AtomicReference<>(); @Override public void onNext(Try> args) { diff --git a/src/main/java/io/reactivex/internal/operators/BlockingOperatorMostRecent.java b/rxjava/src/main/java/io/reactivex/internal/operators/BlockingOperatorMostRecent.java similarity index 88% rename from src/main/java/io/reactivex/internal/operators/BlockingOperatorMostRecent.java rename to rxjava/src/main/java/io/reactivex/internal/operators/BlockingOperatorMostRecent.java index f2164f80ad..8832d75d1f 100644 --- a/src/main/java/io/reactivex/internal/operators/BlockingOperatorMostRecent.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/BlockingOperatorMostRecent.java @@ -41,19 +41,16 @@ public enum BlockingOperatorMostRecent { * {@code initialValue} if {@code source} has not yet emitted any items */ public static Iterable mostRecent(final Publisher source, final T initialValue) { - return new Iterable() { - @Override - public Iterator iterator() { - MostRecentObserver mostRecentObserver = new MostRecentObserver(initialValue); + return () -> { + MostRecentObserver mostRecentObserver = new MostRecentObserver<>(initialValue); - /** - * Subscribe instead of unsafeSubscribe since this is the final subscribe in the chain - * since it is for BlockingObservable. - */ - source.subscribe(mostRecentObserver); + /** + * Subscribe instead of unsafeSubscribe since this is the final subscribe in the chain + * since it is for BlockingObservable. + */ + source.subscribe(mostRecentObserver); - return mostRecentObserver.getIterable(); - } + return mostRecentObserver.getIterable(); }; } diff --git a/src/main/java/io/reactivex/internal/operators/BlockingOperatorNext.java b/rxjava/src/main/java/io/reactivex/internal/operators/BlockingOperatorNext.java similarity index 95% rename from src/main/java/io/reactivex/internal/operators/BlockingOperatorNext.java rename to rxjava/src/main/java/io/reactivex/internal/operators/BlockingOperatorNext.java index b3bf45c5af..ad8a592989 100644 --- a/src/main/java/io/reactivex/internal/operators/BlockingOperatorNext.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/BlockingOperatorNext.java @@ -42,12 +42,9 @@ public enum BlockingOperatorNext { * @return an {@code Iterable} that behaves like a blocking version of {@code items} */ public static Iterable next(final Publisher items) { - return new Iterable() { - @Override - public Iterator iterator() { - NextObserver nextObserver = new NextObserver(); - return new NextIterator(items, nextObserver); - } + return () -> { + NextObserver nextObserver = new NextObserver<>(); + return new NextIterator<>(items, nextObserver); }; } @@ -144,7 +141,7 @@ public void remove() { } private static class NextObserver extends DisposableSubscriber>> { - private final BlockingQueue>> buf = new ArrayBlockingQueue>>(1); + private final BlockingQueue>> buf = new ArrayBlockingQueue<>(1); final AtomicInteger waiting = new AtomicInteger(); @Override diff --git a/src/main/java/io/reactivex/internal/operators/CachedObservable.java b/rxjava/src/main/java/io/reactivex/internal/operators/CachedObservable.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/CachedObservable.java rename to rxjava/src/main/java/io/reactivex/internal/operators/CachedObservable.java index 88b3824361..af82d5fb04 100644 --- a/src/main/java/io/reactivex/internal/operators/CachedObservable.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/CachedObservable.java @@ -54,9 +54,9 @@ public static CachedObservable from(Observable source, int c if (capacityHint < 1) { throw new IllegalArgumentException("capacityHint > 0 required"); } - CacheState state = new CacheState(source, capacityHint); - CachedSubscribe onSubscribe = new CachedSubscribe(state); - return new CachedObservable(onSubscribe, state); + CacheState state = new CacheState<>(source, capacityHint); + CachedSubscribe onSubscribe = new CachedSubscribe<>(state); + return new CachedObservable<>(onSubscribe, state); } /** @@ -121,7 +121,7 @@ public CacheState(Observable source, int capacityHint) { super(capacityHint); this.source = source; this.producers = EMPTY; - this.connection = new SerialResource(SubscriptionHelper.consumeAndCancel()); + this.connection = new SerialResource<>(SubscriptionHelper.consumeAndCancel()); } /** * Adds a ReplayProducer to the producers array atomically. @@ -237,7 +237,7 @@ public CachedSubscribe(CacheState state) { @Override public void subscribe(Subscriber t) { // we can connect first because we replay everything anyway - ReplaySubscription rp = new ReplaySubscription(t, state); + ReplaySubscription rp = new ReplaySubscription<>(t, state); state.addProducer(rp); t.onSubscribe(rp); diff --git a/src/main/java/io/reactivex/internal/operators/ObservableScalarSource.java b/rxjava/src/main/java/io/reactivex/internal/operators/ObservableScalarSource.java similarity index 60% rename from src/main/java/io/reactivex/internal/operators/ObservableScalarSource.java rename to rxjava/src/main/java/io/reactivex/internal/operators/ObservableScalarSource.java index fbbefc8383..7ab5d663ec 100644 --- a/src/main/java/io/reactivex/internal/operators/ObservableScalarSource.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/ObservableScalarSource.java @@ -26,12 +26,7 @@ public final class ObservableScalarSource extends Observable { private final T value; public ObservableScalarSource(final T value) { - super(new Publisher() { - @Override - public void subscribe(Subscriber s) { - s.onSubscribe(new ScalarSubscription(s, value)); - } - }); + super(s -> s.onSubscribe(new ScalarSubscription<>(s, value))); this.value = value; } @@ -40,22 +35,19 @@ public T value() { } public Publisher scalarFlatMap(final Function> mapper) { - return new Publisher() { - @Override - public void subscribe(Subscriber s) { - Publisher other; - try { - other = mapper.apply(value); - } catch (Throwable e) { - EmptySubscription.error(e, s); - return; - } - if (other == null) { - EmptySubscription.error(new NullPointerException("The publisher returned by the function is null"), s); - return; - } - other.subscribe(s); + return s -> { + Publisher other; + try { + other = mapper.apply(value); + } catch (Throwable e) { + EmptySubscription.error(e, s); + return; + } + if (other == null) { + EmptySubscription.error(new NullPointerException("The publisher returned by the function is null"), s); + return; } + other.subscribe(s); }; } } diff --git a/src/main/java/io/reactivex/internal/operators/OperatorAll.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorAll.java similarity index 98% rename from src/main/java/io/reactivex/internal/operators/OperatorAll.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorAll.java index c2ee4e2246..536842dfb3 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorAll.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorAll.java @@ -29,7 +29,7 @@ public OperatorAll(Predicate predicate) { @Override public Subscriber apply(Subscriber t) { - return new AllSubscriber(t, predicate); + return new AllSubscriber<>(t, predicate); } static final class AllSubscriber extends AtomicInteger implements Subscriber, Subscription { diff --git a/src/main/java/io/reactivex/internal/operators/OperatorAny.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorAny.java similarity index 98% rename from src/main/java/io/reactivex/internal/operators/OperatorAny.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorAny.java index 6f9e309fa1..9dba19f008 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorAny.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorAny.java @@ -28,7 +28,7 @@ public OperatorAny(Predicate predicate) { @Override public Subscriber apply(Subscriber t) { - return new AnySubscriber(t, predicate); + return new AnySubscriber<>(t, predicate); } static final class AnySubscriber extends AtomicInteger implements Subscriber, Subscription { diff --git a/src/main/java/io/reactivex/internal/operators/OperatorBuffer.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorBuffer.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/OperatorBuffer.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorBuffer.java index ebc699f2cc..4798002cf6 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorBuffer.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorBuffer.java @@ -38,13 +38,13 @@ public OperatorBuffer(int count, int skip, Supplier bufferSupplier) { @Override public Subscriber apply(Subscriber t) { if (skip == count) { - BufferExactSubscriber bes = new BufferExactSubscriber(t, count, bufferSupplier); + BufferExactSubscriber bes = new BufferExactSubscriber<>(t, count, bufferSupplier); if (bes.createBuffer()) { return bes; } return EmptySubscriber.INSTANCE; } - return new BufferSkipSubscriber(t, count, skip, bufferSupplier); + return new BufferSkipSubscriber<>(t, count, skip, bufferSupplier); } static final class BufferExactSubscriber> implements Subscriber, Subscription { @@ -169,7 +169,7 @@ public BufferSkipSubscriber(Subscriber actual, int count, int skip, S this.count = count; this.skip = skip; this.bufferSupplier = bufferSupplier; - this.buffers = new ArrayDeque(); + this.buffers = new ArrayDeque<>(); } @Override diff --git a/src/main/java/io/reactivex/internal/operators/OperatorBufferBoundary.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorBufferBoundary.java similarity index 94% rename from src/main/java/io/reactivex/internal/operators/OperatorBufferBoundary.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorBufferBoundary.java index 5fa2658d92..139c336753 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorBufferBoundary.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorBufferBoundary.java @@ -43,10 +43,10 @@ public OperatorBufferBoundary(Publisher bufferOpen, @Override public Subscriber apply(Subscriber t) { - return new BufferBoundarySubscriber( - new SerializedSubscriber(t), - bufferOpen, bufferClose, bufferSupplier - ); + return new BufferBoundarySubscriber<>( + new SerializedSubscriber<>(t), + bufferOpen, bufferClose, bufferSupplier + ); } static final class BufferBoundarySubscriber, Open, Close> @@ -66,12 +66,12 @@ public BufferBoundarySubscriber(Subscriber actual, Publisher bufferOpen, Function> bufferClose, Supplier bufferSupplier) { - super(actual, new MpscLinkedQueue()); + super(actual, new MpscLinkedQueue<>()); this.bufferOpen = bufferOpen; this.bufferClose = bufferClose; this.bufferSupplier = bufferSupplier; - this.buffers = new LinkedList(); - this.resources = new SetCompositeResource(Disposables.consumeAndDispose()); + this.buffers = new LinkedList<>(); + this.resources = new SetCompositeResource<>(Disposables.consumeAndDispose()); } @Override public void onSubscribe(Subscription s) { @@ -80,7 +80,7 @@ public void onSubscribe(Subscription s) { } this.s = s; - BufferOpenSubscriber bos = new BufferOpenSubscriber(this); + BufferOpenSubscriber bos = new BufferOpenSubscriber<>(this); resources.add(bos); actual.onSubscribe(this); @@ -120,7 +120,7 @@ public void onComplete() { void complete() { List list; synchronized (this) { - list = new ArrayList(buffers); + list = new ArrayList<>(buffers); buffers.clear(); } @@ -202,7 +202,7 @@ void open(Open window) { buffers.add(b); } - BufferCloseSubscriber bcs = new BufferCloseSubscriber(b, this); + BufferCloseSubscriber bcs = new BufferCloseSubscriber<>(b, this); resources.add(bcs); windows.getAndIncrement(); diff --git a/src/main/java/io/reactivex/internal/operators/OperatorBufferBoundarySupplier.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorBufferBoundarySupplier.java similarity index 95% rename from src/main/java/io/reactivex/internal/operators/OperatorBufferBoundarySupplier.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorBufferBoundarySupplier.java index ecbced3da7..b4e25a6abf 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorBufferBoundarySupplier.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorBufferBoundarySupplier.java @@ -39,7 +39,7 @@ public OperatorBufferBoundarySupplier(Supplier> boundaryS @Override public Subscriber apply(Subscriber t) { - return new BufferBondarySupplierSubscriber(new SerializedSubscriber(t), bufferSupplier, boundarySupplier); + return new BufferBondarySupplierSubscriber<>(new SerializedSubscriber<>(t), bufferSupplier, boundarySupplier); } static final class BufferBondarySupplierSubscriber, B> @@ -50,18 +50,15 @@ static final class BufferBondarySupplierSubscriber other = new AtomicReference(); + final AtomicReference other = new AtomicReference<>(); - static final Disposable DISPOSED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable DISPOSED = () -> { }; U buffer; public BufferBondarySupplierSubscriber(Subscriber actual, Supplier bufferSupplier, Supplier> boundarySupplier) { - super(actual, new MpscLinkedQueue()); + super(actual, new MpscLinkedQueue<>()); this.bufferSupplier = bufferSupplier; this.boundarySupplier = boundarySupplier; } @@ -112,7 +109,7 @@ public void onSubscribe(Subscription s) { return; } - BufferBoundarySubscriber bs = new BufferBoundarySubscriber(this); + BufferBoundarySubscriber bs = new BufferBoundarySubscriber<>(this); other.set(bs); actual.onSubscribe(this); @@ -224,7 +221,7 @@ void next() { return; } - BufferBoundarySubscriber bs = new BufferBoundarySubscriber(this); + BufferBoundarySubscriber bs = new BufferBoundarySubscriber<>(this); if (!other.compareAndSet(o, bs)) { return; diff --git a/src/main/java/io/reactivex/internal/operators/OperatorBufferExactBoundary.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorBufferExactBoundary.java similarity index 96% rename from src/main/java/io/reactivex/internal/operators/OperatorBufferExactBoundary.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorBufferExactBoundary.java index aa5761769e..daa8a7d1b6 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorBufferExactBoundary.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorBufferExactBoundary.java @@ -37,7 +37,7 @@ public OperatorBufferExactBoundary(Publisher boundary, Supplier bufferSupp @Override public Subscriber apply(Subscriber t) { - return new BufferExactBondarySubscriber(new SerializedSubscriber(t), bufferSupplier, boundary); + return new BufferExactBondarySubscriber<>(new SerializedSubscriber<>(t), bufferSupplier, boundary); } static final class BufferExactBondarySubscriber, B> @@ -54,7 +54,7 @@ static final class BufferExactBondarySubscriber actual, Supplier bufferSupplier, Publisher boundary) { - super(actual, new MpscLinkedQueue()); + super(actual, new MpscLinkedQueue<>()); this.bufferSupplier = bufferSupplier; this.boundary = boundary; } @@ -85,7 +85,7 @@ public void onSubscribe(Subscription s) { } buffer = b; - BufferBoundarySubscriber bs = new BufferBoundarySubscriber(this); + BufferBoundarySubscriber bs = new BufferBoundarySubscriber<>(this); other = bs; actual.onSubscribe(this); diff --git a/src/main/java/io/reactivex/internal/operators/OperatorBufferTimed.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorBufferTimed.java similarity index 91% rename from src/main/java/io/reactivex/internal/operators/OperatorBufferTimed.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorBufferTimed.java index dc1920d31e..b0fa06ce96 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorBufferTimed.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorBufferTimed.java @@ -54,24 +54,24 @@ public OperatorBufferTimed(long timespan, long timeskip, TimeUnit unit, Schedule @Override public Subscriber apply(Subscriber t) { if (timespan == timeskip && maxSize == Integer.MAX_VALUE) { - return new BufferExactUnboundedSubscriber( - new SerializedSubscriber(t), - bufferSupplier, timespan, unit, scheduler); + return new BufferExactUnboundedSubscriber<>( + new SerializedSubscriber<>(t), + bufferSupplier, timespan, unit, scheduler); } Scheduler.Worker w = scheduler.createWorker(); if (timespan == timeskip) { - return new BufferExactBoundedSubscriber( - new SerializedSubscriber(t), - bufferSupplier, - timespan, unit, maxSize, restartTimerOnMaxSize, w + return new BufferExactBoundedSubscriber<>( + new SerializedSubscriber<>(t), + bufferSupplier, + timespan, unit, maxSize, restartTimerOnMaxSize, w ); } // Can't use maxSize because what to do if a buffer is full but its // timespan hasn't been elapsed? - return new BufferSkipBoundedSubscriber( - new SerializedSubscriber(t), - bufferSupplier, timespan, timeskip, unit, w); + return new BufferSkipBoundedSubscriber<>( + new SerializedSubscriber<>(t), + bufferSupplier, timespan, timeskip, unit, w); } static final class BufferExactUnboundedSubscriber> @@ -87,17 +87,14 @@ static final class BufferExactUnboundedSubscriber timer = new AtomicReference(); + final AtomicReference timer = new AtomicReference<>(); - static final Disposable CANCELLED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable CANCELLED = () -> { }; public BufferExactUnboundedSubscriber( Subscriber actual, Supplier bufferSupplier, long timespan, TimeUnit unit, Scheduler scheduler) { - super(actual, new MpscLinkedQueue()); + super(actual, new MpscLinkedQueue<>()); this.bufferSupplier = bufferSupplier; this.timespan = timespan; this.unit = unit; @@ -277,13 +274,13 @@ static final class BufferSkipBoundedSubscriber actual, Supplier bufferSupplier, long timespan, long timeskip, TimeUnit unit, Worker w) { - super(actual, new MpscLinkedQueue()); + super(actual, new MpscLinkedQueue<>()); this.bufferSupplier = bufferSupplier; this.timespan = timespan; this.timeskip = timeskip; this.unit = unit; this.w = w; - this.buffers = new LinkedList(); + this.buffers = new LinkedList<>(); } @Override @@ -319,15 +316,12 @@ public void onSubscribe(Subscription s) { w.schedulePeriodically(this, timeskip, timeskip, unit); - w.schedule(new Runnable() { - @Override - public void run() { - synchronized (BufferSkipBoundedSubscriber.this) { - buffers.remove(b); - } - - fastpathOrderedEmitMax(b, false, w); + w.schedule(() -> { + synchronized (BufferSkipBoundedSubscriber.this) { + buffers.remove(b); } + + fastpathOrderedEmitMax(b, false, w); }, timespan, unit); } @@ -352,7 +346,7 @@ public void onError(Throwable t) { public void onComplete() { List bs; synchronized (this) { - bs = new ArrayList(buffers); + bs = new ArrayList<>(buffers); buffers.clear(); } @@ -410,15 +404,12 @@ public void run() { buffers.add(b); } - w.schedule(new Runnable() { - @Override - public void run() { - synchronized (BufferSkipBoundedSubscriber.this) { - buffers.remove(b); - } - - fastpathOrderedEmitMax(b, false, w); + w.schedule(() -> { + synchronized (BufferSkipBoundedSubscriber.this) { + buffers.remove(b); } + + fastpathOrderedEmitMax(b, false, w); }, timespan, unit); } @@ -453,7 +444,7 @@ public BufferExactBoundedSubscriber( Supplier bufferSupplier, long timespan, TimeUnit unit, int maxSize, boolean restartOnMaxSize, Worker w) { - super(actual, new MpscLinkedQueue()); + super(actual, new MpscLinkedQueue<>()); this.bufferSupplier = bufferSupplier; this.timespan = timespan; this.unit = unit; diff --git a/src/main/java/io/reactivex/internal/operators/OperatorCollect.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorCollect.java similarity index 98% rename from src/main/java/io/reactivex/internal/operators/OperatorCollect.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorCollect.java index 6f28d1a609..70fe4b3ce2 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorCollect.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorCollect.java @@ -43,7 +43,7 @@ public Subscriber apply(Subscriber t) { return CancelledSubscriber.INSTANCE; } - return new CollectSubscriber(t, u, collector); + return new CollectSubscriber<>(t, u, collector); } static final class CollectSubscriber implements Subscriber, Subscription { diff --git a/src/main/java/io/reactivex/internal/operators/OperatorConcatMap.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorConcatMap.java similarity index 96% rename from src/main/java/io/reactivex/internal/operators/OperatorConcatMap.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorConcatMap.java index 03fe9d2969..c39a5eed77 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorConcatMap.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorConcatMap.java @@ -34,10 +34,10 @@ public OperatorConcatMap(Function> m } @Override public Subscriber apply(Subscriber s) { - SerializedSubscriber ssub = new SerializedSubscriber(s); + SerializedSubscriber ssub = new SerializedSubscriber<>(s); SubscriptionArbiter sa = new SubscriptionArbiter(); ssub.onSubscribe(sa); - return new SourceSubscriber(ssub, sa, mapper, bufferSize); + return new SourceSubscriber<>(ssub, sa, mapper, bufferSize); } static final class SourceSubscriber extends AtomicInteger implements Subscriber { @@ -62,12 +62,12 @@ public SourceSubscriber(Subscriber actual, SubscriptionArbiter sa, this.sa = sa; this.mapper = mapper; this.bufferSize = bufferSize; - this.inner = new InnerSubscriber(actual, sa, this); + this.inner = new InnerSubscriber<>(actual, sa, this); Queue q; if (Pow2.isPowerOfTwo(bufferSize)) { - q = new SpscArrayQueue(bufferSize); + q = new SpscArrayQueue<>(bufferSize); } else { - q = new SpscExactArrayQueue(bufferSize); + q = new SpscExactArrayQueue<>(bufferSize); } this.queue = q; } diff --git a/src/main/java/io/reactivex/internal/operators/OperatorCount.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorCount.java similarity index 100% rename from src/main/java/io/reactivex/internal/operators/OperatorCount.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorCount.java diff --git a/src/main/java/io/reactivex/internal/operators/OperatorDebounce.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorDebounce.java similarity index 95% rename from src/main/java/io/reactivex/internal/operators/OperatorDebounce.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorDebounce.java index 2ce4cae388..e84ee9fa96 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorDebounce.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorDebounce.java @@ -35,7 +35,7 @@ public OperatorDebounce(Function> debounceSele @Override public Subscriber apply(Subscriber t) { - return new DebounceSubscriber(new SerializedSubscriber(t), debounceSelector); + return new DebounceSubscriber<>(new SerializedSubscriber<>(t), debounceSelector); } static final class DebounceSubscriber extends AtomicLong @@ -49,12 +49,9 @@ static final class DebounceSubscriber extends AtomicLong Subscription s; - final AtomicReference debouncer = new AtomicReference(); + final AtomicReference debouncer = new AtomicReference<>(); - static final Disposable CANCELLED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable CANCELLED = () -> { }; volatile long index; @@ -107,7 +104,7 @@ public void onNext(T t) { return; } - DebounceInnerSubscriber dis = new DebounceInnerSubscriber(this, idx, t); + DebounceInnerSubscriber dis = new DebounceInnerSubscriber<>(this, idx, t); if (debouncer.compareAndSet(d, dis)) { p.subscribe(dis); diff --git a/src/main/java/io/reactivex/internal/operators/OperatorDebounceTimed.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorDebounceTimed.java similarity index 91% rename from src/main/java/io/reactivex/internal/operators/OperatorDebounceTimed.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorDebounceTimed.java index 184c711e65..7431f5a5f0 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorDebounceTimed.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorDebounceTimed.java @@ -40,9 +40,9 @@ public OperatorDebounceTimed(long timeout, TimeUnit unit, Scheduler scheduler) { @Override public Subscriber apply(Subscriber t) { - return new DebounceTimedSubscriber( - new SerializedSubscriber(t), - timeout, unit, scheduler.createWorker()); + return new DebounceTimedSubscriber<>( + new SerializedSubscriber<>(t), + timeout, unit, scheduler.createWorker()); } static final class DebounceTimedSubscriber extends AtomicLong @@ -56,17 +56,11 @@ static final class DebounceTimedSubscriber extends AtomicLong Subscription s; - final AtomicReference timer = new AtomicReference(); + final AtomicReference timer = new AtomicReference<>(); - static final Disposable CANCELLED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable CANCELLED = () -> { }; - static final Disposable NEW_TIMER = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable NEW_TIMER = () -> { }; volatile long index; @@ -113,7 +107,7 @@ public void onNext(T t) { d.dispose(); } - DebounceEmitter de = new DebounceEmitter(t, idx, this); + DebounceEmitter de = new DebounceEmitter<>(t, idx, this); if (!timer.compareAndSet(d, de)) { return; } @@ -189,10 +183,7 @@ static final class DebounceEmitter extends AtomicReference implem /** */ private static final long serialVersionUID = 6812032969491025141L; - static final Disposable DISPOSED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable DISPOSED = () -> { }; final T value; final long idx; diff --git a/src/main/java/io/reactivex/internal/operators/OperatorDelay.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorDelay.java similarity index 81% rename from src/main/java/io/reactivex/internal/operators/OperatorDelay.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorDelay.java index 0246352f4a..aaa188f4fb 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorDelay.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorDelay.java @@ -45,12 +45,12 @@ public Subscriber apply(Subscriber t) { if (delayError) { s = (Subscriber)t; } else { - s = new SerializedSubscriber(t); + s = new SerializedSubscriber<>(t); } Scheduler.Worker w = scheduler.createWorker(); - return new DelaySubscriber(s, delay, unit, w, delayError); + return new DelaySubscriber<>(s, delay, unit, w, delayError); } static final class DelaySubscriber implements Subscriber, Subscription { @@ -82,25 +82,17 @@ public void onSubscribe(Subscription s) { @Override public void onNext(final T t) { - w.schedule(new Runnable() { - @Override - public void run() { - actual.onNext(t); - } - }, delay, unit); + w.schedule(() -> actual.onNext(t), delay, unit); } @Override public void onError(final Throwable t) { if (delayError) { - w.schedule(new Runnable() { - @Override - public void run() { - try { - actual.onError(t); - } finally { - w.dispose(); - } + w.schedule(() -> { + try { + actual.onError(t); + } finally { + w.dispose(); } }, delay, unit); } else { @@ -110,14 +102,11 @@ public void run() { @Override public void onComplete() { - w.schedule(new Runnable() { - @Override - public void run() { - try { - actual.onComplete(); - } finally { - w.dispose(); - } + w.schedule(() -> { + try { + actual.onComplete(); + } finally { + w.dispose(); } }, delay, unit); } diff --git a/src/main/java/io/reactivex/internal/operators/OperatorDematerialize.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorDematerialize.java similarity index 98% rename from src/main/java/io/reactivex/internal/operators/OperatorDematerialize.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorDematerialize.java index 9bea9a8df1..44d20cd039 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorDematerialize.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorDematerialize.java @@ -30,7 +30,7 @@ public static Operator>> instance() { @Override public Subscriber>> apply(Subscriber t) { - return new DematerializeSubscriber(t); + return new DematerializeSubscriber<>(t); } static final class DematerializeSubscriber implements Subscriber>> { diff --git a/src/main/java/io/reactivex/internal/operators/OperatorDistinct.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorDistinct.java similarity index 67% rename from src/main/java/io/reactivex/internal/operators/OperatorDistinct.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorDistinct.java index f2a218c24a..3d67c63468 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorDistinct.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorDistinct.java @@ -34,49 +34,37 @@ public OperatorDistinct(Function keySelector, Supplier OperatorDistinct withCollection(Function keySelector, final Supplier> collectionSupplier) { - Supplier> p = new Supplier>() { - @Override - public Predicate get() { - final Collection coll = collectionSupplier.get(); - - return new Predicate() { - @Override - public boolean test(K t) { - if (t == null) { - coll.clear(); - return true; - } - return coll.add(t); - } - }; - } + Supplier> p = () -> { + final Collection coll = collectionSupplier.get(); + + return t -> { + if (t == null) { + coll.clear(); + return true; + } + return coll.add(t); + }; }; - return new OperatorDistinct(keySelector, p); + return new OperatorDistinct<>(keySelector, p); } static final OperatorDistinct UNTIL_CHANGED; static { - Supplier> p = new Supplier>() { - @Override - public Predicate get() { - final Object[] last = { null }; - - return new Predicate() { - @Override - public boolean test(Object t) { - if (t == null) { - last[0] = null; - return true; - } - Object o = last[0]; - last[0] = t; - return !Objects.equals(o, t); - } - }; - } + Supplier> p = () -> { + final Object[] last = { null }; + + return t -> { + if (t == null) { + last[0] = null; + return true; + } + Object o = last[0]; + last[0] = t; + return !Objects.equals(o, t); + }; }; - UNTIL_CHANGED = new OperatorDistinct(Functions.identity(), p); + UNTIL_CHANGED = new OperatorDistinct<>(Functions.identity(), p); } @SuppressWarnings("unchecked") @@ -85,26 +73,20 @@ public static OperatorDistinct untilChanged() { } public static OperatorDistinct untilChanged(Function keySelector) { - Supplier> p = new Supplier>() { - @Override - public Predicate get() { - final Object[] last = { null }; - - return new Predicate() { - @Override - public boolean test(K t) { - if (t == null) { - last[0] = null; - return true; - } - Object o = last[0]; - last[0] = t; - return !Objects.equals(o, t); - } - }; - } + Supplier> p = () -> { + final Object[] last = { null }; + + return t -> { + if (t == null) { + last[0] = null; + return true; + } + Object o = last[0]; + last[0] = t; + return !Objects.equals(o, t); + }; }; - return new OperatorDistinct(keySelector, p); + return new OperatorDistinct<>(keySelector, p); } @@ -123,7 +105,7 @@ public Subscriber apply(Subscriber t) { return CancelledSubscriber.INSTANCE; } - return new DistinctSubscriber(t, keySelector, coll); + return new DistinctSubscriber<>(t, keySelector, coll); } static final class DistinctSubscriber implements Subscriber { diff --git a/src/main/java/io/reactivex/internal/operators/OperatorDoOnEach.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorDoOnEach.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/OperatorDoOnEach.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorDoOnEach.java index 1d59cbbc21..c4ebdf2576 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorDoOnEach.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorDoOnEach.java @@ -39,7 +39,7 @@ public OperatorDoOnEach(Consumer onNext, @Override public Subscriber apply(Subscriber t) { - return new DoOnEachSubscriber(t, onNext, onError, onComplete, onAfterTerminate); + return new DoOnEachSubscriber<>(t, onNext, onError, onComplete, onAfterTerminate); } static final class DoOnEachSubscriber implements Subscriber { diff --git a/src/main/java/io/reactivex/internal/operators/OperatorElementAt.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorElementAt.java similarity index 98% rename from src/main/java/io/reactivex/internal/operators/OperatorElementAt.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorElementAt.java index 84d44e5a59..4ebabbb499 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorElementAt.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorElementAt.java @@ -27,7 +27,7 @@ public OperatorElementAt(long index, T defaultValue) { } @Override public Subscriber apply(Subscriber t) { - return new ElementAtSubscriber(t, index, defaultValue); + return new ElementAtSubscriber<>(t, index, defaultValue); } static final class ElementAtSubscriber implements Subscriber, Subscription { diff --git a/src/main/java/io/reactivex/internal/operators/OperatorFilter.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorFilter.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/OperatorFilter.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorFilter.java index 23a73d5e54..aa1d9f4a95 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorFilter.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorFilter.java @@ -28,7 +28,7 @@ public OperatorFilter(Predicate predicate) { @Override public Subscriber apply(Subscriber s) { - return new FilterSubscriber(s, predicate); + return new FilterSubscriber<>(s, predicate); } static final class FilterSubscriber implements ConditionalSubscriber { diff --git a/src/main/java/io/reactivex/internal/operators/OperatorFlatMap.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorFlatMap.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/OperatorFlatMap.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorFlatMap.java index bc9fcb7f15..ce402d0ffb 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorFlatMap.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorFlatMap.java @@ -43,7 +43,7 @@ public OperatorFlatMap( @Override public Subscriber apply(Subscriber t) { - return new MergeSubscriber(t, mapper, delayErrors, maxConcurrency, bufferSize); + return new MergeSubscriber<>(t, mapper, delayErrors, maxConcurrency, bufferSize); } static final class MergeSubscriber extends AtomicInteger implements Subscription, Subscriber { @@ -60,13 +60,13 @@ static final class MergeSubscriber extends AtomicInteger implements Subscr volatile boolean done; - final AtomicReference> errors = new AtomicReference>(); + final AtomicReference> errors = new AtomicReference<>(); - static final Queue ERRORS_CLOSED = new RejectingQueue(); + static final Queue ERRORS_CLOSED = new RejectingQueue<>(); volatile boolean cancelled; - final AtomicReference[]> subscribers = new AtomicReference[]>(); + final AtomicReference[]> subscribers = new AtomicReference<>(); static final InnerSubscriber[] EMPTY = new InnerSubscriber[0]; @@ -126,7 +126,7 @@ public void onNext(T t) { if (p instanceof ObservableScalarSource) { tryEmitScalar(((ObservableScalarSource)p).value()); } else { - InnerSubscriber inner = new InnerSubscriber(this, uniqueId++); + InnerSubscriber inner = new InnerSubscriber<>(this, uniqueId++); addInner(inner); p.subscribe(inner); } @@ -184,12 +184,12 @@ Queue getMainQueue() { Queue q = queue; if (q == null) { if (maxConcurrency == Integer.MAX_VALUE) { - q = new SpscLinkedArrayQueue(bufferSize); + q = new SpscLinkedArrayQueue<>(bufferSize); } else { if (Pow2.isPowerOfTwo(maxConcurrency)) { - q = new SpscArrayQueue(maxConcurrency); + q = new SpscArrayQueue<>(maxConcurrency); } else { - q = new SpscExactArrayQueue(maxConcurrency); + q = new SpscExactArrayQueue<>(maxConcurrency); } } queue = q; @@ -236,7 +236,7 @@ void tryEmitScalar(U value) { Queue getInnerQueue(InnerSubscriber inner) { Queue q = inner.queue; if (q == null) { - q = new SpscArrayQueue(bufferSize); + q = new SpscArrayQueue<>(bufferSize); inner.queue = q; } return q; @@ -264,7 +264,7 @@ void tryEmit(U value, InnerSubscriber inner) { } else { Queue q = inner.queue; if (q == null) { - q = new SpscArrayQueue(bufferSize); + q = new SpscArrayQueue<>(bufferSize); inner.queue = q; } if (!q.offer(value)) { @@ -549,7 +549,7 @@ Queue getErrorQueue() { if (q != null) { return q; } - q = new MpscLinkedQueue(); + q = new MpscLinkedQueue<>(); if (errors.compareAndSet(null, q)) { return q; } diff --git a/src/main/java/io/reactivex/internal/operators/OperatorGroupBy.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorGroupBy.java similarity index 95% rename from src/main/java/io/reactivex/internal/operators/OperatorGroupBy.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorGroupBy.java index bc7de4582a..3e29441289 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorGroupBy.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorGroupBy.java @@ -42,7 +42,7 @@ public OperatorGroupBy(Function keySelector, Function apply(Subscriber> t) { - return new GroupBySubscriber(t, keySelector, valueSelector, bufferSize, delayError); + return new GroupBySubscriber<>(t, keySelector, valueSelector, bufferSize, delayError); } public static final class GroupBySubscriber @@ -78,8 +78,8 @@ public GroupBySubscriber(Subscriber> actual, Fun this.valueSelector = valueSelector; this.bufferSize = bufferSize; this.delayError = delayError; - this.groups = new ConcurrentHashMap>(); - this.queue = new SpscLinkedArrayQueue>(bufferSize); + this.groups = new ConcurrentHashMap<>(); + this.queue = new SpscLinkedArrayQueue<>(bufferSize); } @Override @@ -261,7 +261,7 @@ void drain() { void errorAll(Subscriber> a, Queue q, Throwable ex) { q.clear(); - List> list = new ArrayList>(groups.values()); + List> list = new ArrayList<>(groups.values()); groups.clear(); for (GroupedUnicast e : list) { @@ -280,7 +280,7 @@ boolean checkTerminated(boolean d, boolean empty, return true; } else if (empty) { - List> list = new ArrayList>(groups.values()); + List> list = new ArrayList<>(groups.values()); groups.clear(); for (GroupedUnicast e : list) { @@ -298,8 +298,8 @@ boolean checkTerminated(boolean d, boolean empty, static final class GroupedUnicast extends GroupedObservable { public static GroupedUnicast createWith(K key, int bufferSize, GroupBySubscriber parent, boolean delayError) { - State state = new State(bufferSize, parent, key, delayError); - return new GroupedUnicast(key, state); + State state = new State<>(bufferSize, parent, key, delayError); + return new GroupedUnicast<>(key, state); } final State state; @@ -338,12 +338,12 @@ static final class State extends AtomicInteger implements Subscription, Pu final AtomicBoolean cancelled = new AtomicBoolean(); - final AtomicReference> actual = new AtomicReference>(); + final AtomicReference> actual = new AtomicReference<>(); final AtomicBoolean once = new AtomicBoolean(); public State(int bufferSize, GroupBySubscriber parent, K key, boolean delayError) { - this.queue = new SpscLinkedArrayQueue(bufferSize); + this.queue = new SpscLinkedArrayQueue<>(bufferSize); this.parent = parent; this.key = key; this.delayError = delayError; diff --git a/src/main/java/io/reactivex/internal/operators/OperatorIgnoreElements.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorIgnoreElements.java similarity index 100% rename from src/main/java/io/reactivex/internal/operators/OperatorIgnoreElements.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorIgnoreElements.java diff --git a/src/main/java/io/reactivex/internal/operators/OperatorMap.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorMap.java similarity index 98% rename from src/main/java/io/reactivex/internal/operators/OperatorMap.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorMap.java index a0bbe1dd9a..cf79ad229d 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorMap.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorMap.java @@ -29,7 +29,7 @@ public OperatorMap(Function function) { @Override public Subscriber apply(Subscriber t) { - return new MapperSubscriber(t, function); + return new MapperSubscriber<>(t, function); } static final class MapperSubscriber implements Subscriber { diff --git a/src/main/java/io/reactivex/internal/operators/OperatorMapNotification.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorMapNotification.java similarity index 98% rename from src/main/java/io/reactivex/internal/operators/OperatorMapNotification.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorMapNotification.java index a498636f6a..852a00dc5f 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorMapNotification.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorMapNotification.java @@ -38,7 +38,7 @@ public OperatorMapNotification(Function apply(Subscriber> t) { - return new MapNotificationSubscriber(t, onNextMapper, onErrorMapper, onCompleteSupplier); + return new MapNotificationSubscriber<>(t, onNextMapper, onErrorMapper, onCompleteSupplier); } static final class MapNotificationSubscriber diff --git a/src/main/java/io/reactivex/internal/operators/OperatorMaterialize.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorMaterialize.java similarity index 98% rename from src/main/java/io/reactivex/internal/operators/OperatorMaterialize.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorMaterialize.java index f9a4ea9e73..56507ad32a 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorMaterialize.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorMaterialize.java @@ -32,7 +32,7 @@ public static Operator>, T> instance() { @Override public Subscriber apply(Subscriber>> t) { - return new MaterializeSubscriber(t); + return new MaterializeSubscriber<>(t); } static final class MaterializeSubscriber extends AtomicLong implements Subscriber, Subscription { diff --git a/src/main/java/io/reactivex/internal/operators/OperatorObserveOn.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorObserveOn.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/OperatorObserveOn.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorObserveOn.java index e423293546..c461bc32e7 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorObserveOn.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorObserveOn.java @@ -45,7 +45,7 @@ public Subscriber apply(Subscriber t) { Scheduler.Worker w = scheduler.createWorker(); - return new ObserveOnSubscriber(t, w, delayError, bufferSize); + return new ObserveOnSubscriber<>(t, w, delayError, bufferSize); } /** @@ -100,9 +100,9 @@ public ObserveOnSubscriber(Subscriber actual, Scheduler.Worker worker this.bufferSize = bufferSize; Queue q; if (Pow2.isPowerOfTwo(bufferSize)) { - q = new SpscArrayQueue(bufferSize); + q = new SpscArrayQueue<>(bufferSize); } else { - q = new SpscExactArrayQueue(bufferSize); + q = new SpscExactArrayQueue<>(bufferSize); } this.queue = q; } diff --git a/src/main/java/io/reactivex/internal/operators/OperatorOnBackpressureBuffer.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorOnBackpressureBuffer.java similarity index 96% rename from src/main/java/io/reactivex/internal/operators/OperatorOnBackpressureBuffer.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorOnBackpressureBuffer.java index b09c65fc76..d847082bc6 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorOnBackpressureBuffer.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorOnBackpressureBuffer.java @@ -39,7 +39,7 @@ public OperatorOnBackpressureBuffer(int bufferSize, boolean unbounded, boolean d @Override public Subscriber apply(Subscriber t) { - return new BackpressureBufferSubscriber(t, bufferSize, unbounded, delayError, onOverflow); + return new BackpressureBufferSubscriber<>(t, bufferSize, unbounded, delayError, onOverflow); } static final class BackpressureBufferSubscriber extends AtomicInteger implements Subscriber, Subscription { @@ -68,12 +68,12 @@ public BackpressureBufferSubscriber(Subscriber actual, int bufferSize Queue q; if (unbounded) { - q = new SpscLinkedArrayQueue(bufferSize); + q = new SpscLinkedArrayQueue<>(bufferSize); } else { if (Pow2.isPowerOfTwo(bufferSize)) { - q = new SpscArrayQueue(bufferSize); + q = new SpscArrayQueue<>(bufferSize); } else { - q = new SpscExactArrayQueue(bufferSize); + q = new SpscExactArrayQueue<>(bufferSize); } } diff --git a/src/main/java/io/reactivex/internal/operators/OperatorOnBackpressureDrop.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorOnBackpressureDrop.java similarity index 96% rename from src/main/java/io/reactivex/internal/operators/OperatorOnBackpressureDrop.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorOnBackpressureDrop.java index 114ea7e2f8..cf96cdf0f7 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorOnBackpressureDrop.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorOnBackpressureDrop.java @@ -26,7 +26,7 @@ public final class OperatorOnBackpressureDrop implements Operator { private static final OperatorOnBackpressureDrop DEFAULT = - new OperatorOnBackpressureDrop(Functions.emptyConsumer()); + new OperatorOnBackpressureDrop<>(Functions.emptyConsumer()); @SuppressWarnings("unchecked") public static OperatorOnBackpressureDrop instance() { @@ -41,7 +41,7 @@ public OperatorOnBackpressureDrop(Consumer onDrop) { @Override public Subscriber apply(Subscriber t) { - return new BackpressureDropSubscriber(t, onDrop); + return new BackpressureDropSubscriber<>(t, onDrop); } static final class BackpressureDropSubscriber extends AtomicLong implements Subscriber, Subscription { diff --git a/src/main/java/io/reactivex/internal/operators/OperatorOnBackpressureLatest.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorOnBackpressureLatest.java similarity index 99% rename from src/main/java/io/reactivex/internal/operators/OperatorOnBackpressureLatest.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorOnBackpressureLatest.java index 60633e6509..2672a6831d 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorOnBackpressureLatest.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorOnBackpressureLatest.java @@ -49,7 +49,7 @@ static final class BackpressureLatestSubscriber extends AtomicInteger implements final AtomicLong requested = new AtomicLong(); - final AtomicReference current = new AtomicReference(); + final AtomicReference current = new AtomicReference<>(); public BackpressureLatestSubscriber(Subscriber actual) { this.actual = actual; diff --git a/src/main/java/io/reactivex/internal/operators/OperatorOnErrorNext.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorOnErrorNext.java similarity index 99% rename from src/main/java/io/reactivex/internal/operators/OperatorOnErrorNext.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorOnErrorNext.java index f57ea7ca33..b0721290a5 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorOnErrorNext.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorOnErrorNext.java @@ -32,7 +32,7 @@ public OperatorOnErrorNext(Function apply(Subscriber t) { - OnErrorNextSubscriber parent = new OnErrorNextSubscriber(t, nextSupplier, allowFatal); + OnErrorNextSubscriber parent = new OnErrorNextSubscriber<>(t, nextSupplier, allowFatal); t.onSubscribe(parent.arbiter); return parent; } diff --git a/src/main/java/io/reactivex/internal/operators/OperatorOnErrorReturn.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorOnErrorReturn.java similarity index 98% rename from src/main/java/io/reactivex/internal/operators/OperatorOnErrorReturn.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorOnErrorReturn.java index cf65874227..dfcc214910 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorOnErrorReturn.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorOnErrorReturn.java @@ -31,7 +31,7 @@ public OperatorOnErrorReturn(Function valueSuppl @Override public Subscriber apply(Subscriber t) { - return new OnErrorReturnSubscriber(t, valueSupplier); + return new OnErrorReturnSubscriber<>(t, valueSupplier); } static final class OnErrorReturnSubscriber extends AtomicLong implements Subscriber, Subscription { diff --git a/src/main/java/io/reactivex/internal/operators/OperatorPublish.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorPublish.java similarity index 88% rename from src/main/java/io/reactivex/internal/operators/OperatorPublish.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorPublish.java index faf5645ec8..f59dcbca56 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorPublish.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorPublish.java @@ -50,93 +50,83 @@ public final class OperatorPublish extends ConnectableObservable { */ public static ConnectableObservable create(Observable source, final int bufferSize) { // the current connection to source needs to be shared between the operator and its onSubscribe call - final AtomicReference> curr = new AtomicReference>(); - Publisher onSubscribe = new Publisher() { - @Override - public void subscribe(Subscriber child) { - // concurrent connection/disconnection may change the state, - // we loop to be atomic while the child subscribes - for (;;) { - // get the current subscriber-to-source - PublishSubscriber r = curr.get(); - // if there isn't one or it is unsubscribed - if (r == null || r.isDisposed()) { - // create a new subscriber to source - PublishSubscriber u = new PublishSubscriber(curr, bufferSize); - // let's try setting it as the current subscriber-to-source - if (!curr.compareAndSet(r, u)) { - // didn't work, maybe someone else did it or the current subscriber - // to source has just finished - continue; - } - // we won, let's use it going onwards - r = u; + final AtomicReference> curr = new AtomicReference<>(); + Publisher onSubscribe = child -> { + // concurrent connection/disconnection may change the state, + // we loop to be atomic while the child subscribes + for (;;) { + // get the current subscriber-to-source + PublishSubscriber r = curr.get(); + // if there isn't one or it is unsubscribed + if (r == null || r.isDisposed()) { + // create a new subscriber to source + PublishSubscriber u = new PublishSubscriber<>(curr, bufferSize); + // let's try setting it as the current subscriber-to-source + if (!curr.compareAndSet(r, u)) { + // didn't work, maybe someone else did it or the current subscriber + // to source has just finished + continue; } - - // create the backpressure-managing producer for this child - InnerProducer inner = new InnerProducer(r, child); + // we won, let's use it going onwards + r = u; + } + + // create the backpressure-managing producer for this child + InnerProducer inner = new InnerProducer<>(r, child); + /* + * Try adding it to the current subscriber-to-source, add is atomic in respect + * to other adds and the termination of the subscriber-to-source. + */ + if (!r.add(inner)) { /* - * Try adding it to the current subscriber-to-source, add is atomic in respect - * to other adds and the termination of the subscriber-to-source. + * The current PublishSubscriber has been terminated, try with a newer one. + */ + continue; + /* + * Note: although technically corrent, concurrent disconnects can cause + * unexpected behavior such as child subscribers never receiving anything + * (unless connected again). An alternative approach, similar to + * PublishSubject would be to immediately terminate such child + * subscribers as well: + * + * Object term = r.terminalEvent; + * if (r.nl.isCompleted(term)) { + * child.onCompleted(); + * } else { + * child.onError(r.nl.getError(term)); + * } + * return; + * + * The original concurrent behavior was non-deterministic in this regard as well. + * Allowing this behavior, however, may introduce another unexpected behavior: + * after disconnecting a previous connection, one might not be able to prepare + * a new connection right after a previous termination by subscribing new child + * subscribers asynchronously before a connect call. */ - if (!r.add(inner)) { - /* - * The current PublishSubscriber has been terminated, try with a newer one. - */ - continue; - /* - * Note: although technically corrent, concurrent disconnects can cause - * unexpected behavior such as child subscribers never receiving anything - * (unless connected again). An alternative approach, similar to - * PublishSubject would be to immediately terminate such child - * subscribers as well: - * - * Object term = r.terminalEvent; - * if (r.nl.isCompleted(term)) { - * child.onCompleted(); - * } else { - * child.onError(r.nl.getError(term)); - * } - * return; - * - * The original concurrent behavior was non-deterministic in this regard as well. - * Allowing this behavior, however, may introduce another unexpected behavior: - * after disconnecting a previous connection, one might not be able to prepare - * a new connection right after a previous termination by subscribing new child - * subscribers asynchronously before a connect call. - */ - } - // the producer has been registered with the current subscriber-to-source so - // at least it will receive the next terminal event - // setting the producer will trigger the first request to be considered by - // the subscriber-to-source. - child.onSubscribe(inner); - break; } + // the producer has been registered with the current subscriber-to-source so + // at least it will receive the next terminal event + // setting the producer will trigger the first request to be considered by + // the subscriber-to-source. + child.onSubscribe(inner); + break; } }; - return new OperatorPublish(onSubscribe, source, curr, bufferSize); + return new OperatorPublish<>(onSubscribe, source, curr, bufferSize); } public static Observable create(final Observable source, final Function, ? extends Publisher> selector, final int bufferSize) { - return create(new Publisher() { - @Override - public void subscribe(Subscriber sr) { + return create(sr -> { ConnectableObservable op = create(source, bufferSize); - final SubscriberResourceWrapper srw = new SubscriberResourceWrapper(sr, Disposables.consumeAndDispose()); + final SubscriberResourceWrapper srw = new SubscriberResourceWrapper<>(sr, Disposables.consumeAndDispose()); selector.apply(op).subscribe(srw); - op.connect(new Consumer() { - @Override - public void accept(Disposable r) { - srw.setResource(r); - } - }); + op.connect(srw::setResource); } - }); + ); } private OperatorPublish(Publisher onSubscribe, Publisher source, @@ -158,7 +148,7 @@ public void connect(Consumer connection) { // if there is none yet or the current has unsubscribed if (ps == null || ps.isDisposed()) { // create a new subscriber-to-source - PublishSubscriber u = new PublishSubscriber(current, bufferSize); + PublishSubscriber u = new PublishSubscriber<>(current, bufferSize); // try setting it as the current subscriber-to-source if (!current.compareAndSet(ps, u)) { // did not work, perhaps a new subscriber arrived @@ -220,7 +210,7 @@ static final class PublishSubscriber implements Subscriber, Disposable { /** Guarded by this. */ boolean missed; - final AtomicReference s = new AtomicReference(); + final AtomicReference s = new AtomicReference<>(); static final Subscription CANCELLED = new Subscription() { @Override @@ -235,9 +225,9 @@ public void cancel() { }; public PublishSubscriber(AtomicReference> current, int bufferSize) { - this.queue = new SpscArrayQueue(bufferSize); + this.queue = new SpscArrayQueue<>(bufferSize); - this.producers = new AtomicReference(EMPTY); + this.producers = new AtomicReference<>(EMPTY); this.current = current; this.shouldConnect = new AtomicBoolean(); this.bufferSize = bufferSize; diff --git a/src/main/java/io/reactivex/internal/operators/OperatorReplay.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorReplay.java similarity index 91% rename from src/main/java/io/reactivex/internal/operators/OperatorReplay.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorReplay.java index 372bd90017..b01e8e16a8 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorReplay.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorReplay.java @@ -38,12 +38,7 @@ public final class OperatorReplay extends ConnectableObservable { final Supplier> bufferFactory; @SuppressWarnings("rawtypes") - static final Supplier DEFAULT_UNBOUNDED_FACTORY = new Supplier() { - @Override - public Object get() { - return new UnboundedReplayBuffer(16); - } - }; + static final Supplier DEFAULT_UNBOUNDED_FACTORY = () -> new UnboundedReplayBuffer<>(16); /** * Given a connectable observable factory, it multicasts over the generated @@ -57,9 +52,7 @@ public Object get() { public static Observable multicastSelector( final Supplier> connectableFactory, final Function, ? extends Publisher> selector) { - return Observable.create(new Publisher() { - @Override - public void subscribe(Subscriber child) { + return Observable.create(child -> { ConnectableObservable co; Publisher observable; try { @@ -84,18 +77,13 @@ public void subscribe(Subscriber child) { return; } - final SubscriberResourceWrapper srw = new SubscriberResourceWrapper(child, Disposables.consumeAndDispose()); + final SubscriberResourceWrapper srw = new SubscriberResourceWrapper<>(child, Disposables.consumeAndDispose()); observable.subscribe(srw); - co.connect(new Consumer() { - @Override - public void accept(Disposable r) { - srw.setResource(r); - } - }); + co.connect(srw::setResource); } - }); + ); } /** @@ -139,11 +127,8 @@ public static ConnectableObservable create(Observable source if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } - return create(source, new Supplier>() { - @Override - public ReplayBuffer get() { - return new SizeBoundReplayBuffer(bufferSize); - } + return create(source, () -> { + return new SizeBoundReplayBuffer<>(bufferSize); }); } @@ -173,11 +158,8 @@ public static ConnectableObservable create(Observable source */ public static ConnectableObservable create(Observable source, final long maxAge, final TimeUnit unit, final Scheduler scheduler, final int bufferSize) { - return create(source, new Supplier>() { - @Override - public ReplayBuffer get() { - return new SizeAndTimeBoundReplayBuffer(bufferSize, maxAge, unit, scheduler); - } + return create(source, () -> { + return new SizeAndTimeBoundReplayBuffer<>(bufferSize, maxAge, unit, scheduler); }); } @@ -190,47 +172,44 @@ public ReplayBuffer get() { static ConnectableObservable create(Observable source, final Supplier> bufferFactory) { // the current connection to source needs to be shared between the operator and its onSubscribe call - final AtomicReference> curr = new AtomicReference>(); - Publisher onSubscribe = new Publisher() { - @Override - public void subscribe(Subscriber child) { - // concurrent connection/disconnection may change the state, - // we loop to be atomic while the child subscribes - for (;;) { - // get the current subscriber-to-source - ReplaySubscriber r = curr.get(); - // if there isn't one - if (r == null) { - // create a new subscriber to source - ReplaySubscriber u = new ReplaySubscriber(curr, bufferFactory.get()); - // let's try setting it as the current subscriber-to-source - if (!curr.compareAndSet(r, u)) { - // didn't work, maybe someone else did it or the current subscriber - // to source has just finished - continue; - } - // we won, let's use it going onwards - r = u; + final AtomicReference> curr = new AtomicReference<>(); + Publisher onSubscribe = child -> { + // concurrent connection/disconnection may change the state, + // we loop to be atomic while the child subscribes + for (;;) { + // get the current subscriber-to-source + ReplaySubscriber r = curr.get(); + // if there isn't one + if (r == null) { + // create a new subscriber to source + ReplaySubscriber u = new ReplaySubscriber<>(curr, bufferFactory.get()); + // let's try setting it as the current subscriber-to-source + if (!curr.compareAndSet(r, u)) { + // didn't work, maybe someone else did it or the current subscriber + // to source has just finished + continue; } - - // create the backpressure-managing producer for this child - InnerSubscription inner = new InnerSubscription(r, child); - // we try to add it to the array of producers - // if it fails, no worries because we will still have its buffer - // so it is going to replay it for us - r.add(inner); - // trigger the capturing of the current node and total requested - r.buffer.replay(inner); - // the producer has been registered with the current subscriber-to-source so - // at least it will receive the next terminal event - // setting the producer will trigger the first request to be considered by - // the subscriber-to-source. - child.onSubscribe(inner); - break; + // we won, let's use it going onwards + r = u; } + + // create the backpressure-managing producer for this child + InnerSubscription inner = new InnerSubscription<>(r, child); + // we try to add it to the array of producers + // if it fails, no worries because we will still have its buffer + // so it is going to replay it for us + r.add(inner); + // trigger the capturing of the current node and total requested + r.buffer.replay(inner); + // the producer has been registered with the current subscriber-to-source so + // at least it will receive the next terminal event + // setting the producer will trigger the first request to be considered by + // the subscriber-to-source. + child.onSubscribe(inner); + break; } }; - return new OperatorReplay(onSubscribe, source, curr, bufferFactory); + return new OperatorReplay<>(onSubscribe, source, curr, bufferFactory); } private OperatorReplay(Publisher onSubscribe, Observable source, final AtomicReference> current, @@ -252,7 +231,7 @@ public void connect(Consumer connection) { // if there is none yet or the current has unsubscribed if (ps == null || ps.isDisposed()) { // create a new subscriber-to-source - ReplaySubscriber u = new ReplaySubscriber(current, bufferFactory.get()); + ReplaySubscriber u = new ReplaySubscriber<>(current, bufferFactory.get()); // try setting it as the current subscriber-to-source if (!current.compareAndSet(ps, u)) { // did not work, perhaps a new subscriber arrived @@ -325,7 +304,7 @@ public ReplaySubscriber(AtomicReference> current, ReplayBuffer buffer) { this.buffer = buffer; - this.producers = new AtomicReference(EMPTY); + this.producers = new AtomicReference<>(EMPTY); this.shouldConnect = new AtomicBoolean(); } @@ -787,7 +766,7 @@ public void replay(InnerSubscription output) { int sourceIndex = size; Integer destIndexObject = output.index(); - int destIndex = destIndexObject != null ? destIndexObject.intValue() : 0; + int destIndex = destIndexObject != null ? destIndexObject : 0; long r = output.get(); long r0 = r; @@ -1106,7 +1085,7 @@ public SizeAndTimeBoundReplayBuffer(int limit, long maxAge, TimeUnit unit, Sched @Override Object enterTransform(Object value) { - return new Timed(value, scheduler.now(unit), unit); + return new Timed<>(value, scheduler.now(unit), unit); } @Override diff --git a/src/main/java/io/reactivex/internal/operators/OperatorSamplePublisher.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorSamplePublisher.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/OperatorSamplePublisher.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorSamplePublisher.java index 00d4426865..91cebdd85f 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorSamplePublisher.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorSamplePublisher.java @@ -32,8 +32,8 @@ public OperatorSamplePublisher(Publisher other) { @Override public Subscriber apply(Subscriber t) { - SerializedSubscriber serial = new SerializedSubscriber(t); - return new SamplePublisherSubscriber(serial, other); + SerializedSubscriber serial = new SerializedSubscriber<>(t); + return new SamplePublisherSubscriber<>(serial, other); } static final class SamplePublisherSubscriber extends AtomicReference implements Subscriber, Subscription { @@ -45,7 +45,7 @@ static final class SamplePublisherSubscriber extends AtomicReference imple final AtomicLong requested = new AtomicLong(); - final AtomicReference other = new AtomicReference(); + final AtomicReference other = new AtomicReference<>(); static final Subscription CANCELLED = new Subscription() { @Override @@ -75,7 +75,7 @@ public void onSubscribe(Subscription s) { this.s = s; actual.onSubscribe(this); if (other.get() == null) { - sampler.subscribe(new SamplerSubscriber(this)); + sampler.subscribe(new SamplerSubscriber<>(this)); s.request(Long.MAX_VALUE); } diff --git a/src/main/java/io/reactivex/internal/operators/OperatorSampleTimed.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorSampleTimed.java similarity index 94% rename from src/main/java/io/reactivex/internal/operators/OperatorSampleTimed.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorSampleTimed.java index fb6a21e73f..fa5c3a08c5 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorSampleTimed.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorSampleTimed.java @@ -39,8 +39,8 @@ public OperatorSampleTimed(long period, TimeUnit unit, Scheduler scheduler) { @Override public Subscriber apply(Subscriber t) { - SerializedSubscriber serial = new SerializedSubscriber(t); - return new SampleTimedSubscriber(serial, period, unit, scheduler); + SerializedSubscriber serial = new SerializedSubscriber<>(t); + return new SampleTimedSubscriber<>(serial, period, unit, scheduler); } static final class SampleTimedSubscriber extends AtomicReference implements Subscriber, Subscription, Runnable { @@ -54,12 +54,9 @@ static final class SampleTimedSubscriber extends AtomicReference implement final AtomicLong requested = new AtomicLong(); - final AtomicReference timer = new AtomicReference(); + final AtomicReference timer = new AtomicReference<>(); - static final Disposable DISPOSED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable DISPOSED = () -> { }; Subscription s; diff --git a/src/main/java/io/reactivex/internal/operators/OperatorScan.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorScan.java similarity index 98% rename from src/main/java/io/reactivex/internal/operators/OperatorScan.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorScan.java index 17b5877455..cb99cd9fbb 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorScan.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorScan.java @@ -27,7 +27,7 @@ public OperatorScan(BiFunction accumulator) { @Override public Subscriber apply(Subscriber t) { - return new ScanSubscriber(t, accumulator); + return new ScanSubscriber<>(t, accumulator); } static final class ScanSubscriber implements Subscriber { diff --git a/src/main/java/io/reactivex/internal/operators/OperatorScanSeed.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorScanSeed.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/OperatorScanSeed.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorScanSeed.java index b505b0ea4d..8f4c3abd5a 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorScanSeed.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorScanSeed.java @@ -46,7 +46,7 @@ public Subscriber apply(Subscriber t) { return EmptySubscriber.INSTANCE; } - return new ScanSeedSubscriber(t, accumulator, r); + return new ScanSeedSubscriber<>(t, accumulator, r); } static final class ScanSeedSubscriber extends QueueDrainSubscriber implements Subscription { @@ -57,7 +57,7 @@ static final class ScanSeedSubscriber extends QueueDrainSubscriber actual, BiFunction accumulator, R value) { - super(actual, new SpscArrayQueue(2)); + super(actual, new SpscArrayQueue<>(2)); this.accumulator = accumulator; this.value = value; queue.offer(value); diff --git a/src/main/java/io/reactivex/internal/operators/OperatorSingle.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorSingle.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/OperatorSingle.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorSingle.java index 840dd4fdad..b4c08a0a2c 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorSingle.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorSingle.java @@ -23,7 +23,7 @@ public final class OperatorSingle implements Operator { - static final OperatorSingle NO_DEFAULT = new OperatorSingle(null); + static final OperatorSingle NO_DEFAULT = new OperatorSingle<>(null); @SuppressWarnings("unchecked") public static OperatorSingle instanceNoDefault() { @@ -36,7 +36,7 @@ public OperatorSingle(T defaultValue) { } @Override public Subscriber apply(Subscriber t) { - return new SingleElementSubscriber(t, defaultValue); + return new SingleElementSubscriber<>(t, defaultValue); } static final class SingleElementSubscriber implements Subscriber, Subscription { diff --git a/src/main/java/io/reactivex/internal/operators/OperatorSkip.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorSkip.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/OperatorSkip.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorSkip.java index 84435b8296..30aa60c20e 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorSkip.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorSkip.java @@ -25,7 +25,7 @@ public OperatorSkip(long n) { @Override public Subscriber apply(Subscriber s) { - return new SkipSubscriber(s, n); + return new SkipSubscriber<>(s, n); } static final class SkipSubscriber implements Subscriber { diff --git a/src/main/java/io/reactivex/internal/operators/OperatorSkipLast.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorSkipLast.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/OperatorSkipLast.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorSkipLast.java index 40a6e03c2b..a41fac7198 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorSkipLast.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorSkipLast.java @@ -29,7 +29,7 @@ public OperatorSkipLast(int skip) { @Override public Subscriber apply(Subscriber s) { - return new SkipLastSubscriber(s, skip); + return new SkipLastSubscriber<>(s, skip); } static final class SkipLastSubscriber extends ArrayDeque implements Subscriber { diff --git a/src/main/java/io/reactivex/internal/operators/OperatorSkipLastTimed.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorSkipLastTimed.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/OperatorSkipLastTimed.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorSkipLastTimed.java index 28491301e2..fd880f96a8 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorSkipLastTimed.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorSkipLastTimed.java @@ -41,7 +41,7 @@ public OperatorSkipLastTimed(long time, TimeUnit unit, Scheduler scheduler, int @Override public Subscriber apply(Subscriber t) { - return new SkipLastTimedSubscriber(t, time, unit, scheduler, bufferSize, delayError); + return new SkipLastTimedSubscriber<>(t, time, unit, scheduler, bufferSize, delayError); } static final class SkipLastTimedSubscriber extends AtomicInteger implements Subscriber, Subscription { @@ -68,7 +68,7 @@ public SkipLastTimedSubscriber(Subscriber actual, long time, TimeUnit this.time = time; this.unit = unit; this.scheduler = scheduler; - this.queue = new SpscLinkedArrayQueue(bufferSize); + this.queue = new SpscLinkedArrayQueue<>(bufferSize); this.delayError = delayError; } diff --git a/src/main/java/io/reactivex/internal/operators/OperatorSkipUntil.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorSkipUntil.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/OperatorSkipUntil.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorSkipUntil.java index 10bb231a24..c26ea61f6c 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorSkipUntil.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorSkipUntil.java @@ -31,11 +31,11 @@ public OperatorSkipUntil(Publisher other) { @Override public Subscriber apply(Subscriber child) { - final SerializedSubscriber serial = new SerializedSubscriber(child); + final SerializedSubscriber serial = new SerializedSubscriber<>(child); - final ArrayCompositeResource frc = new ArrayCompositeResource(2, SubscriptionHelper.consumeAndCancel()); + final ArrayCompositeResource frc = new ArrayCompositeResource<>(2, SubscriptionHelper.consumeAndCancel()); - final SkipUntilSubscriber sus = new SkipUntilSubscriber(serial, frc); + final SkipUntilSubscriber sus = new SkipUntilSubscriber<>(serial, frc); other.subscribe(new Subscriber() { Subscription s; diff --git a/src/main/java/io/reactivex/internal/operators/OperatorSkipWhile.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorSkipWhile.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/OperatorSkipWhile.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorSkipWhile.java index ced080f964..36f81f40a5 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorSkipWhile.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorSkipWhile.java @@ -27,7 +27,7 @@ public OperatorSkipWhile(Predicate predicate) { @Override public Subscriber apply(Subscriber s) { - return new SkipWhileSubscriber(s, predicate); + return new SkipWhileSubscriber<>(s, predicate); } static final class SkipWhileSubscriber implements Subscriber { diff --git a/src/main/java/io/reactivex/internal/operators/OperatorSwitchIfEmpty.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorSwitchIfEmpty.java similarity index 99% rename from src/main/java/io/reactivex/internal/operators/OperatorSwitchIfEmpty.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorSwitchIfEmpty.java index 68ff82853f..235e6b8316 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorSwitchIfEmpty.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorSwitchIfEmpty.java @@ -27,7 +27,7 @@ public OperatorSwitchIfEmpty(Publisher other) { @Override public Subscriber apply(Subscriber t) { // TODO Auto-generated method stub - SwitchIfEmptySubscriber parent = new SwitchIfEmptySubscriber(t, other); + SwitchIfEmptySubscriber parent = new SwitchIfEmptySubscriber<>(t, other); t.onSubscribe(parent.arbiter); return parent; } diff --git a/src/main/java/io/reactivex/internal/operators/OperatorSwitchMap.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorSwitchMap.java similarity index 96% rename from src/main/java/io/reactivex/internal/operators/OperatorSwitchMap.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorSwitchMap.java index aa360465d7..6b8b9bb4de 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorSwitchMap.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorSwitchMap.java @@ -36,7 +36,7 @@ public OperatorSwitchMap(Function> m @Override public Subscriber apply(Subscriber t) { - return new SwitchMapSubscriber(t, mapper, bufferSize); + return new SwitchMapSubscriber<>(t, mapper, bufferSize); } static final class SwitchMapSubscriber extends AtomicInteger implements Subscriber, Subscription { @@ -54,13 +54,13 @@ static final class SwitchMapSubscriber extends AtomicInteger implements Su Subscription s; - final AtomicReference> active = new AtomicReference>(); + final AtomicReference> active = new AtomicReference<>(); final AtomicLong requested = new AtomicLong(); static final SwitchMapInnerSubscriber CANCELLED; static { - CANCELLED = new SwitchMapInnerSubscriber(null, -1L, 1); + CANCELLED = new SwitchMapInnerSubscriber<>(null, -1L, 1); CANCELLED.cancel(); } @@ -106,7 +106,7 @@ public void onNext(T t) { return; } - SwitchMapInnerSubscriber nextInner = new SwitchMapInnerSubscriber(this, c, bufferSize); + SwitchMapInnerSubscriber nextInner = new SwitchMapInnerSubscriber<>(this, c, bufferSize); for (;;) { inner = active.get(); @@ -336,9 +336,9 @@ public SwitchMapInnerSubscriber(SwitchMapSubscriber parent, long index, in this.bufferSize = bufferSize; Queue q; if (Pow2.isPowerOfTwo(bufferSize)) { - q = new SpscArrayQueue(bufferSize); + q = new SpscArrayQueue<>(bufferSize); } else { - q = new SpscExactArrayQueue(bufferSize); + q = new SpscExactArrayQueue<>(bufferSize); } this.queue = q; } diff --git a/src/main/java/io/reactivex/internal/operators/OperatorTake.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorTake.java similarity index 98% rename from src/main/java/io/reactivex/internal/operators/OperatorTake.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorTake.java index d1c02a1aa4..72c3deb4e8 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorTake.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorTake.java @@ -30,7 +30,7 @@ public OperatorTake(long limit) { @Override public Subscriber apply(Subscriber t) { - return new TakeSubscriber(t, limit); + return new TakeSubscriber<>(t, limit); } static final class TakeSubscriber extends AtomicLong implements Subscriber, Subscription { diff --git a/src/main/java/io/reactivex/internal/operators/OperatorTakeLast.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorTakeLast.java similarity index 98% rename from src/main/java/io/reactivex/internal/operators/OperatorTakeLast.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorTakeLast.java index dfea2844e2..f3382cbadc 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorTakeLast.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorTakeLast.java @@ -32,7 +32,7 @@ public OperatorTakeLast(int count) { @Override public Subscriber apply(Subscriber t) { - return new TakeLastSubscriber(t, count); + return new TakeLastSubscriber<>(t, count); } static final class TakeLastSubscriber extends ArrayDeque implements Subscriber, Subscription { diff --git a/src/main/java/io/reactivex/internal/operators/OperatorTakeLastOne.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorTakeLastOne.java similarity index 98% rename from src/main/java/io/reactivex/internal/operators/OperatorTakeLastOne.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorTakeLastOne.java index d064cd5d35..b5692312df 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorTakeLastOne.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorTakeLastOne.java @@ -30,7 +30,7 @@ public static Operator instance() { @Override public Subscriber apply(Subscriber s) { - return new TakeLastOneSubscriber(s); + return new TakeLastOneSubscriber<>(s); } static final class TakeLastOneSubscriber extends AtomicInteger implements Subscriber, Subscription { diff --git a/src/main/java/io/reactivex/internal/operators/OperatorTakeLastTimed.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorTakeLastTimed.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/OperatorTakeLastTimed.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorTakeLastTimed.java index 7109236aed..81cf870c06 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorTakeLastTimed.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorTakeLastTimed.java @@ -44,7 +44,7 @@ public OperatorTakeLastTimed(long count, long time, TimeUnit unit, Scheduler sch @Override public Subscriber apply(Subscriber t) { - return new TakeLastTimedSubscriber(t, count, time, unit, scheduler, bufferSize, delayError); + return new TakeLastTimedSubscriber<>(t, count, time, unit, scheduler, bufferSize, delayError); } static final class TakeLastTimedSubscriber extends AtomicInteger implements Subscriber, Subscription { @@ -73,7 +73,7 @@ public TakeLastTimedSubscriber(Subscriber actual, long count, long ti this.time = time; this.unit = unit; this.scheduler = scheduler; - this.queue = new SpscLinkedArrayQueue(bufferSize); + this.queue = new SpscLinkedArrayQueue<>(bufferSize); this.delayError = delayError; } diff --git a/src/main/java/io/reactivex/internal/operators/OperatorTakeUntil.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorTakeUntil.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/OperatorTakeUntil.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorTakeUntil.java index 7d3d444c8c..6c766c32fc 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorTakeUntil.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorTakeUntil.java @@ -29,11 +29,11 @@ public OperatorTakeUntil(Publisher other) { } @Override public Subscriber apply(Subscriber child) { - final SerializedSubscriber serial = new SerializedSubscriber(child); + final SerializedSubscriber serial = new SerializedSubscriber<>(child); - final ArrayCompositeResource frc = new ArrayCompositeResource(2, SubscriptionHelper.consumeAndCancel()); + final ArrayCompositeResource frc = new ArrayCompositeResource<>(2, SubscriptionHelper.consumeAndCancel()); - final TakeUntilSubscriber tus = new TakeUntilSubscriber(serial, frc); + final TakeUntilSubscriber tus = new TakeUntilSubscriber<>(serial, frc); other.subscribe(new Subscriber() { @Override diff --git a/src/main/java/io/reactivex/internal/operators/OperatorTakeUntilPredicate.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorTakeUntilPredicate.java similarity index 98% rename from src/main/java/io/reactivex/internal/operators/OperatorTakeUntilPredicate.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorTakeUntilPredicate.java index 4ad84b0dd2..3774e773c6 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorTakeUntilPredicate.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorTakeUntilPredicate.java @@ -27,7 +27,7 @@ public OperatorTakeUntilPredicate(Predicate predicate) { @Override public Subscriber apply(Subscriber s) { - return new InnerSubscriber(s, predicate); + return new InnerSubscriber<>(s, predicate); } static final class InnerSubscriber implements Subscriber { diff --git a/src/main/java/io/reactivex/internal/operators/OperatorTakeWhile.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorTakeWhile.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/OperatorTakeWhile.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorTakeWhile.java index ea180f438d..68016a5834 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorTakeWhile.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorTakeWhile.java @@ -27,7 +27,7 @@ public OperatorTakeWhile(Predicate predicate) { @Override public Subscriber apply(Subscriber t) { - return new TakeWhileSubscriber(t, predicate); + return new TakeWhileSubscriber<>(t, predicate); } static final class TakeWhileSubscriber implements Subscriber { diff --git a/src/main/java/io/reactivex/internal/operators/OperatorThrottleFirstTimed.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorThrottleFirstTimed.java similarity index 92% rename from src/main/java/io/reactivex/internal/operators/OperatorThrottleFirstTimed.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorThrottleFirstTimed.java index 602f7b3e93..e5559f1ff1 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorThrottleFirstTimed.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorThrottleFirstTimed.java @@ -40,9 +40,9 @@ public OperatorThrottleFirstTimed(long timeout, TimeUnit unit, Scheduler schedul @Override public Subscriber apply(Subscriber t) { - return new DebounceTimedSubscriber( - new SerializedSubscriber(t), - timeout, unit, scheduler.createWorker()); + return new DebounceTimedSubscriber<>( + new SerializedSubscriber<>(t), + timeout, unit, scheduler.createWorker()); } static final class DebounceTimedSubscriber @@ -57,17 +57,11 @@ static final class DebounceTimedSubscriber Subscription s; - final AtomicReference timer = new AtomicReference(); + final AtomicReference timer = new AtomicReference<>(); - static final Disposable CANCELLED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable CANCELLED = () -> { }; - static final Disposable NEW_TIMER = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable NEW_TIMER = () -> { }; volatile boolean gate; diff --git a/src/main/java/io/reactivex/internal/operators/OperatorTimeInterval.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorTimeInterval.java similarity index 94% rename from src/main/java/io/reactivex/internal/operators/OperatorTimeInterval.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorTimeInterval.java index b8d4e98767..edc689f260 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorTimeInterval.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorTimeInterval.java @@ -32,7 +32,7 @@ public OperatorTimeInterval(TimeUnit unit, Scheduler scheduler) { @Override public Subscriber apply(Subscriber> t) { - return new TimeIntervalSubscriber(t, unit, scheduler); + return new TimeIntervalSubscriber<>(t, unit, scheduler); } static final class TimeIntervalSubscriber implements Subscriber { @@ -60,7 +60,7 @@ public void onNext(T t) { long last = lastTime; lastTime = now; long delta = now - last; - actual.onNext(new Timed(t, delta, unit)); + actual.onNext(new Timed<>(t, delta, unit)); } @Override diff --git a/src/main/java/io/reactivex/internal/operators/OperatorTimeout.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorTimeout.java similarity index 92% rename from src/main/java/io/reactivex/internal/operators/OperatorTimeout.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorTimeout.java index 8ff92adcec..354ca8b80c 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorTimeout.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorTimeout.java @@ -41,11 +41,11 @@ public OperatorTimeout(Supplier> firstTimeoutSelector, @Override public Subscriber apply(Subscriber t) { if (other == null) { - return new TimeoutSubscriber( - new SerializedSubscriber(t), - firstTimeoutSelector, timeoutSelector); + return new TimeoutSubscriber<>( + new SerializedSubscriber<>(t), + firstTimeoutSelector, timeoutSelector); } - return new TimeoutOtherSubscriber(t, firstTimeoutSelector, timeoutSelector, other); + return new TimeoutOtherSubscriber<>(t, firstTimeoutSelector, timeoutSelector, other); } static final class TimeoutSubscriber implements Subscriber, Subscription, OnTimeout { @@ -59,12 +59,9 @@ static final class TimeoutSubscriber implements Subscriber, Subscrip volatile long index; - final AtomicReference timeout = new AtomicReference(); + final AtomicReference timeout = new AtomicReference<>(); - static final Disposable CANCELLED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable CANCELLED = () -> { }; public TimeoutSubscriber(Subscriber actual, Supplier> firstTimeoutSelector, @@ -104,7 +101,7 @@ public void onSubscribe(Subscription s) { return; } - TimeoutInnerSubscriber tis = new TimeoutInnerSubscriber(this, 0); + TimeoutInnerSubscriber tis = new TimeoutInnerSubscriber<>(this, 0); if (timeout.compareAndSet(null, tis)) { a.onSubscribe(s); @@ -143,7 +140,7 @@ public void onNext(T t) { return; } - TimeoutInnerSubscriber tis = new TimeoutInnerSubscriber(this, idx); + TimeoutInnerSubscriber tis = new TimeoutInnerSubscriber<>(this, idx); if (timeout.compareAndSet(d, tis)) { p.subscribe(tis); @@ -247,12 +244,9 @@ static final class TimeoutOtherSubscriber implements Subscriber, Dis volatile long index; - final AtomicReference timeout = new AtomicReference(); + final AtomicReference timeout = new AtomicReference<>(); - static final Disposable CANCELLED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable CANCELLED = () -> { }; public TimeoutOtherSubscriber(Subscriber actual, Supplier> firstTimeoutSelector, @@ -261,7 +255,7 @@ public TimeoutOtherSubscriber(Subscriber actual, this.firstTimeoutSelector = firstTimeoutSelector; this.timeoutSelector = timeoutSelector; this.other = other; - this.arbiter = new FullArbiter(actual, this, 8); + this.arbiter = new FullArbiter<>(actual, this, 8); } @Override @@ -293,7 +287,7 @@ public void onSubscribe(Subscription s) { return; } - TimeoutInnerSubscriber tis = new TimeoutInnerSubscriber(this, 0); + TimeoutInnerSubscriber tis = new TimeoutInnerSubscriber<>(this, 0); if (timeout.compareAndSet(null, tis)) { a.onSubscribe(arbiter); @@ -335,7 +329,7 @@ public void onNext(T t) { return; } - TimeoutInnerSubscriber tis = new TimeoutInnerSubscriber(this, idx); + TimeoutInnerSubscriber tis = new TimeoutInnerSubscriber<>(this, idx); if (timeout.compareAndSet(d, tis)) { p.subscribe(tis); @@ -381,7 +375,7 @@ public void dispose() { public void timeout(long idx) { if (idx == index) { dispose(); - other.subscribe(new FullArbiterSubscriber(arbiter)); + other.subscribe(new FullArbiterSubscriber<>(arbiter)); } } } diff --git a/src/main/java/io/reactivex/internal/operators/OperatorTimeoutTimed.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorTimeoutTimed.java similarity index 79% rename from src/main/java/io/reactivex/internal/operators/OperatorTimeoutTimed.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorTimeoutTimed.java index 54cc3eebd7..6596825aa7 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorTimeoutTimed.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorTimeoutTimed.java @@ -43,13 +43,13 @@ public OperatorTimeoutTimed(long timeout, TimeUnit unit, Scheduler scheduler, Pu @Override public Subscriber apply(Subscriber t) { if (other == null) { - return new TimeoutTimedSubscriber( - new SerializedSubscriber(t), // because errors can race - timeout, unit, scheduler.createWorker()); + return new TimeoutTimedSubscriber<>( + new SerializedSubscriber<>(t), // because errors can race + timeout, unit, scheduler.createWorker()); } - return new TimeoutTimedOtherSubscriber( - t, // the FullArbiter serializes - timeout, unit, scheduler.createWorker(), other); + return new TimeoutTimedOtherSubscriber<>( + t, // the FullArbiter serializes + timeout, unit, scheduler.createWorker(), other); } static final class TimeoutTimedOtherSubscriber implements Subscriber, Disposable { @@ -63,17 +63,11 @@ static final class TimeoutTimedOtherSubscriber implements Subscriber, Disp final FullArbiter arbiter; - final AtomicReference timer = new AtomicReference(); + final AtomicReference timer = new AtomicReference<>(); - static final Disposable CANCELLED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable CANCELLED = () -> { }; - static final Disposable NEW_TIMER = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable NEW_TIMER = () -> { }; volatile long index; @@ -86,7 +80,7 @@ public TimeoutTimedOtherSubscriber(Subscriber actual, long timeout, T this.unit = unit; this.worker = worker; this.other = other; - this.arbiter = new FullArbiter(actual, this, 8); + this.arbiter = new FullArbiter<>(actual, this, 8); } @Override @@ -123,20 +117,17 @@ void scheduleTimeout(final long idx) { } if (timer.compareAndSet(d, NEW_TIMER)) { - d = worker.schedule(new Runnable() { - @Override - public void run() { - if (idx == index) { - done = true; - s.cancel(); - disposeTimer(); - worker.dispose(); - - if (other == null) { - actual.onError(new TimeoutException()); - } else { - subscribeNext(); - } + d = worker.schedule(() -> { + if (idx == index) { + done = true; + s.cancel(); + disposeTimer(); + worker.dispose(); + + if (other == null) { + actual.onError(new TimeoutException()); + } else { + subscribeNext(); } } }, timeout, unit); @@ -148,7 +139,7 @@ public void run() { } void subscribeNext() { - other.subscribe(new FullArbiterSubscriber(arbiter)); + other.subscribe(new FullArbiterSubscriber<>(arbiter)); } @Override @@ -199,17 +190,11 @@ static final class TimeoutTimedSubscriber implements Subscriber, Disposabl Subscription s; - final AtomicReference timer = new AtomicReference(); + final AtomicReference timer = new AtomicReference<>(); - static final Disposable CANCELLED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable CANCELLED = () -> { }; - static final Disposable NEW_TIMER = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable NEW_TIMER = () -> { }; volatile long index; @@ -253,16 +238,13 @@ void scheduleTimeout(final long idx) { } if (timer.compareAndSet(d, NEW_TIMER)) { - d = worker.schedule(new Runnable() { - @Override - public void run() { - if (idx == index) { - done = true; - s.cancel(); - dispose(); - - actual.onError(new TimeoutException()); - } + d = worker.schedule(() -> { + if (idx == index) { + done = true; + s.cancel(); + dispose(); + + actual.onError(new TimeoutException()); } }, timeout, unit); diff --git a/src/main/java/io/reactivex/internal/operators/OperatorToList.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorToList.java similarity index 93% rename from src/main/java/io/reactivex/internal/operators/OperatorToList.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorToList.java index c40f04fb22..7e99dbc0fd 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorToList.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorToList.java @@ -26,12 +26,7 @@ public final class OperatorToList> implements Operator { @SuppressWarnings({"rawtypes", "unchecked"}) - static final OperatorToList DEFAULT = new OperatorToList(new Supplier() { - @Override - public Object get() { - return new ArrayList(); - } - }); + static final OperatorToList DEFAULT = new OperatorToList(ArrayList::new); @SuppressWarnings("unchecked") public static OperatorToList> defaultInstance() { @@ -53,7 +48,7 @@ public Subscriber apply(Subscriber t) { EmptySubscription.error(e, t); return CancelledSubscriber.INSTANCE; } - return new ToListSubscriber(t, coll); + return new ToListSubscriber<>(t, coll); } static final class ToListSubscriber> implements Subscriber, Subscription { diff --git a/src/main/java/io/reactivex/internal/operators/OperatorUnsubscribeOn.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorUnsubscribeOn.java similarity index 90% rename from src/main/java/io/reactivex/internal/operators/OperatorUnsubscribeOn.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorUnsubscribeOn.java index 82334ebe12..b173296e97 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorUnsubscribeOn.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorUnsubscribeOn.java @@ -29,7 +29,7 @@ public OperatorUnsubscribeOn(Scheduler scheduler) { @Override public Subscriber apply(Subscriber t) { - return new UnsubscribeSubscriber(t, scheduler); + return new UnsubscribeSubscriber<>(t, scheduler); } static final class UnsubscribeSubscriber extends AtomicBoolean implements Subscriber, Subscription { @@ -78,12 +78,7 @@ public void request(long n) { @Override public void cancel() { if (compareAndSet(false, true)) { - scheduler.scheduleDirect(new Runnable() { - @Override - public void run() { - s.cancel(); - } - }); + scheduler.scheduleDirect(s::cancel); } } } diff --git a/src/main/java/io/reactivex/internal/operators/OperatorWindow.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorWindow.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/OperatorWindow.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorWindow.java index 777f99de3e..74ffcd94cd 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorWindow.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorWindow.java @@ -38,9 +38,9 @@ public OperatorWindow(long count, long skip, int capacityHint) { @Override public Subscriber apply(Subscriber> t) { if (count == skip) { - return new WindowExactSubscriber(t, count, capacityHint); + return new WindowExactSubscriber<>(t, count, capacityHint); } - return new WindowSkipSubscriber(t, count, skip, capacityHint); + return new WindowSkipSubscriber<>(t, count, skip, capacityHint); } static final class WindowExactSubscriber @@ -166,7 +166,7 @@ public WindowSkipSubscriber(Subscriber> actual, long count this.count = count; this.skip = skip; this.capacityHint = capacityHint; - this.windows = new ArrayDeque>(); + this.windows = new ArrayDeque<>(); } @Override diff --git a/src/main/java/io/reactivex/internal/operators/OperatorWindowBoundary.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorWindowBoundary.java similarity index 96% rename from src/main/java/io/reactivex/internal/operators/OperatorWindowBoundary.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorWindowBoundary.java index e556db61a9..2b72032c42 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorWindowBoundary.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorWindowBoundary.java @@ -40,7 +40,7 @@ public OperatorWindowBoundary(Publisher other, int bufferSize) { @Override public Subscriber apply(Subscriber> t) { - return new WindowBoundaryMainSubscriber(new SerializedSubscriber>(t), other, bufferSize); + return new WindowBoundaryMainSubscriber<>(new SerializedSubscriber<>(t), other, bufferSize); } static final class WindowBoundaryMainSubscriber @@ -52,12 +52,9 @@ static final class WindowBoundaryMainSubscriber Subscription s; - final AtomicReference boundary = new AtomicReference(); + final AtomicReference boundary = new AtomicReference<>(); - static final Disposable CANCELLED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable CANCELLED = () -> { }; UnicastSubject window; @@ -67,7 +64,7 @@ public void dispose() { } public WindowBoundaryMainSubscriber(Subscriber> actual, Publisher other, int bufferSize) { - super(actual, new MpscLinkedQueue()); + super(actual, new MpscLinkedQueue<>()); this.other = other; this.bufferSize = bufferSize; windows.lazySet(1); @@ -102,7 +99,7 @@ public void onSubscribe(Subscription s) { window = w; - WindowBoundaryInnerSubscriber inner = new WindowBoundaryInnerSubscriber(this); + WindowBoundaryInnerSubscriber inner = new WindowBoundaryInnerSubscriber<>(this); if (boundary.compareAndSet(null, inner)) { windows.getAndIncrement(); diff --git a/src/main/java/io/reactivex/internal/operators/OperatorWindowBoundarySelector.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorWindowBoundarySelector.java similarity index 95% rename from src/main/java/io/reactivex/internal/operators/OperatorWindowBoundarySelector.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorWindowBoundarySelector.java index 9669ba3e26..2347ad3db0 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorWindowBoundarySelector.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorWindowBoundarySelector.java @@ -45,9 +45,9 @@ public OperatorWindowBoundarySelector(Publisher open, Function apply(Subscriber> t) { - return new WindowBoundaryMainSubscriber( - new SerializedSubscriber>(t), - open, close, bufferSize); + return new WindowBoundaryMainSubscriber<>( + new SerializedSubscriber<>(t), + open, close, bufferSize); } static final class WindowBoundaryMainSubscriber @@ -60,12 +60,9 @@ static final class WindowBoundaryMainSubscriber Subscription s; - final AtomicReference boundary = new AtomicReference(); + final AtomicReference boundary = new AtomicReference<>(); - static final Disposable CANCELLED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable CANCELLED = () -> { }; final List> ws; @@ -73,12 +70,12 @@ public void dispose() { } public WindowBoundaryMainSubscriber(Subscriber> actual, Publisher open, Function> close, int bufferSize) { - super(actual, new MpscLinkedQueue()); + super(actual, new MpscLinkedQueue<>()); this.open = open; this.close = close; this.bufferSize = bufferSize; - this.resources = new SetCompositeResource(Disposables.consumeAndDispose()); - this.ws = new ArrayList>(); + this.resources = new SetCompositeResource<>(Disposables.consumeAndDispose()); + this.ws = new ArrayList<>(); windows.lazySet(1); } @@ -96,7 +93,7 @@ public void onSubscribe(Subscription s) { return; } - OperatorWindowBoundaryOpenSubscriber os = new OperatorWindowBoundaryOpenSubscriber(this); + OperatorWindowBoundaryOpenSubscriber os = new OperatorWindowBoundaryOpenSubscriber<>(this); if (boundary.compareAndSet(null, os)) { windows.getAndIncrement(); @@ -292,7 +289,7 @@ void drainLoop() { continue; } - OperatorWindowBoundaryCloseSubscriber cl = new OperatorWindowBoundaryCloseSubscriber(this, w); + OperatorWindowBoundaryCloseSubscriber cl = new OperatorWindowBoundaryCloseSubscriber<>(this, w); if (resources.add(cl)) { windows.getAndIncrement(); diff --git a/src/main/java/io/reactivex/internal/operators/OperatorWindowBoundarySupplier.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorWindowBoundarySupplier.java similarity index 96% rename from src/main/java/io/reactivex/internal/operators/OperatorWindowBoundarySupplier.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorWindowBoundarySupplier.java index 39ab3c51ab..bfde4a231f 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorWindowBoundarySupplier.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorWindowBoundarySupplier.java @@ -41,7 +41,7 @@ public OperatorWindowBoundarySupplier(Supplier> other, in @Override public Subscriber apply(Subscriber> t) { - return new WindowBoundaryMainSubscriber(new SerializedSubscriber>(t), other, bufferSize); + return new WindowBoundaryMainSubscriber<>(new SerializedSubscriber<>(t), other, bufferSize); } static final class WindowBoundaryMainSubscriber @@ -53,12 +53,9 @@ static final class WindowBoundaryMainSubscriber Subscription s; - final AtomicReference boundary = new AtomicReference(); + final AtomicReference boundary = new AtomicReference<>(); - static final Disposable CANCELLED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable CANCELLED = () -> { }; UnicastSubject window; @@ -68,7 +65,7 @@ public void dispose() { } public WindowBoundaryMainSubscriber(Subscriber> actual, Supplier> other, int bufferSize) { - super(actual, new MpscLinkedQueue()); + super(actual, new MpscLinkedQueue<>()); this.other = other; this.bufferSize = bufferSize; windows.lazySet(1); @@ -120,7 +117,7 @@ public void onSubscribe(Subscription s) { window = w; - WindowBoundaryInnerSubscriber inner = new WindowBoundaryInnerSubscriber(this); + WindowBoundaryInnerSubscriber inner = new WindowBoundaryInnerSubscriber<>(this); if (boundary.compareAndSet(null, inner)) { windows.getAndIncrement(); @@ -283,7 +280,7 @@ void drainLoop() { window = w; - WindowBoundaryInnerSubscriber b = new WindowBoundaryInnerSubscriber(this); + WindowBoundaryInnerSubscriber b = new WindowBoundaryInnerSubscriber<>(this); if (boundary.compareAndSet(boundary.get(), b)) { p.subscribe(b); diff --git a/src/main/java/io/reactivex/internal/operators/OperatorWindowTimed.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorWindowTimed.java similarity index 94% rename from src/main/java/io/reactivex/internal/operators/OperatorWindowTimed.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorWindowTimed.java index d82811e63e..3226bd3259 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorWindowTimed.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorWindowTimed.java @@ -54,21 +54,21 @@ public OperatorWindowTimed(long timespan, long timeskip, TimeUnit unit, Schedule @Override public Subscriber apply(Subscriber> t) { - SerializedSubscriber> actual = new SerializedSubscriber>(t); + SerializedSubscriber> actual = new SerializedSubscriber<>(t); if (timespan == timeskip) { if (maxSize == Long.MAX_VALUE) { - return new WindowExactUnboundedSubscriber( - actual, - timespan, unit, scheduler, bufferSize); + return new WindowExactUnboundedSubscriber<>( + actual, + timespan, unit, scheduler, bufferSize); } - return new WindowExactBoundedSubscriber( - actual, - timespan, unit, scheduler, - bufferSize, maxSize, restartTimerOnMaxSize); + return new WindowExactBoundedSubscriber<>( + actual, + timespan, unit, scheduler, + bufferSize, maxSize, restartTimerOnMaxSize); } - return new WindowSkipSubscriber(actual, - timespan, timeskip, unit, scheduler.createWorker(), bufferSize); + return new WindowSkipSubscriber<>(actual, + timespan, timeskip, unit, scheduler.createWorker(), bufferSize); } static final class WindowExactUnboundedSubscriber @@ -85,12 +85,9 @@ static final class WindowExactUnboundedSubscriber UnicastSubject window; - final AtomicReference timer = new AtomicReference(); + final AtomicReference timer = new AtomicReference<>(); - static final Disposable CANCELLED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable CANCELLED = () -> { }; static final Object NEXT = new Object(); @@ -98,7 +95,7 @@ public void dispose() { } public WindowExactUnboundedSubscriber(Subscriber> actual, long timespan, TimeUnit unit, Scheduler scheduler, int bufferSize) { - super(actual, new MpscLinkedQueue()); + super(actual, new MpscLinkedQueue<>()); this.timespan = timespan; this.unit = unit; this.scheduler = scheduler; @@ -323,18 +320,15 @@ static final class WindowExactBoundedSubscriber volatile boolean terminated; - final AtomicReference timer = new AtomicReference(); + final AtomicReference timer = new AtomicReference<>(); - static final Disposable CANCELLED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable CANCELLED = () -> { }; public WindowExactBoundedSubscriber( Subscriber> actual, long timespan, TimeUnit unit, Scheduler scheduler, int bufferSize, long maxSize, boolean restartTimerOnMaxSize) { - super(actual, new MpscLinkedQueue()); + super(actual, new MpscLinkedQueue<>()); this.timespan = timespan; this.unit = unit; this.scheduler = scheduler; @@ -664,13 +658,13 @@ static final class WindowSkipSubscriber public WindowSkipSubscriber(Subscriber> actual, long timespan, long timeskip, TimeUnit unit, Worker worker, int bufferSize) { - super(actual, new MpscLinkedQueue()); + super(actual, new MpscLinkedQueue<>()); this.timespan = timespan; this.timeskip = timeskip; this.unit = unit; this.worker = worker; this.bufferSize = bufferSize; - this.windows = new LinkedList>(); + this.windows = new LinkedList<>(); } @Override @@ -696,12 +690,7 @@ public void onSubscribe(Subscription s) { if (r != Long.MAX_VALUE) { produced(1); } - worker.schedule(new Runnable() { - @Override - public void run() { - complete(w); - } - }, timespan, unit); + worker.schedule(() -> complete(w), timespan, unit); worker.schedulePeriodically(this, timeskip, timeskip, unit); @@ -779,7 +768,7 @@ public boolean accept(Subscriber> a, Object v) { } void complete(UnicastSubject w) { - queue.offer(new SubjectWork(w, false)); + queue.offer(new SubjectWork<>(w, false)); if (enter()) { drainLoop(); } @@ -849,12 +838,7 @@ void drainLoop() { produced(1); } - worker.schedule(new Runnable() { - @Override - public void run() { - complete(w); - } - }, timespan, unit); + worker.schedule(() -> complete(w), timespan, unit); } else { a.onError(new IllegalStateException("Can't emit window due to lack of requests")); continue; @@ -886,7 +870,7 @@ public void run() { UnicastSubject w = UnicastSubject.create(bufferSize); - SubjectWork sw = new SubjectWork(w, true); + SubjectWork sw = new SubjectWork<>(w, true); if (!cancelled) { queue.offer(sw); } diff --git a/src/main/java/io/reactivex/internal/operators/OperatorWithLatestFrom.java b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorWithLatestFrom.java similarity index 98% rename from src/main/java/io/reactivex/internal/operators/OperatorWithLatestFrom.java rename to rxjava/src/main/java/io/reactivex/internal/operators/OperatorWithLatestFrom.java index 01f9cfbdcd..ac27824d28 100644 --- a/src/main/java/io/reactivex/internal/operators/OperatorWithLatestFrom.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/OperatorWithLatestFrom.java @@ -33,8 +33,8 @@ public OperatorWithLatestFrom(BiFunction comb @Override public Subscriber apply(Subscriber t) { - final SerializedSubscriber serial = new SerializedSubscriber(t); - final WithLatestFromSubscriber wlf = new WithLatestFromSubscriber(serial, combiner); + final SerializedSubscriber serial = new SerializedSubscriber<>(t); + final WithLatestFromSubscriber wlf = new WithLatestFromSubscriber<>(serial, combiner); other.subscribe(new Subscriber() { @Override @@ -70,9 +70,9 @@ static final class WithLatestFromSubscriber extends AtomicReference final Subscriber actual; final BiFunction combiner; - final AtomicReference s = new AtomicReference(); + final AtomicReference s = new AtomicReference<>(); - final AtomicReference other = new AtomicReference(); + final AtomicReference other = new AtomicReference<>(); static final Subscription CANCELLED = new Subscription() { @Override diff --git a/src/main/java/io/reactivex/internal/operators/PublisherAmb.java b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherAmb.java similarity index 98% rename from src/main/java/io/reactivex/internal/operators/PublisherAmb.java rename to rxjava/src/main/java/io/reactivex/internal/operators/PublisherAmb.java index 0f67c6dc4b..e46ced1ccb 100644 --- a/src/main/java/io/reactivex/internal/operators/PublisherAmb.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherAmb.java @@ -58,7 +58,7 @@ public void subscribe(Subscriber s) { return; } - AmbCoordinator ac = new AmbCoordinator(s, count); + AmbCoordinator ac = new AmbCoordinator<>(s, count); ac.subscribe(sources); } @@ -78,7 +78,7 @@ public void subscribe(Publisher[] sources) { AmbInnerSubscriber[] as = subscribers; int len = as.length; for (int i = 0; i < len; i++) { - as[i] = new AmbInnerSubscriber(this, i + 1, actual); + as[i] = new AmbInnerSubscriber<>(this, i + 1, actual); } winner.lazySet(0); // release the contents of 'as' actual.onSubscribe(this); diff --git a/src/main/java/io/reactivex/internal/operators/PublisherArraySource.java b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherArraySource.java similarity index 98% rename from src/main/java/io/reactivex/internal/operators/PublisherArraySource.java rename to rxjava/src/main/java/io/reactivex/internal/operators/PublisherArraySource.java index 535b5c09be..0a3762c4d3 100644 --- a/src/main/java/io/reactivex/internal/operators/PublisherArraySource.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherArraySource.java @@ -33,9 +33,9 @@ public T[] array() { public void subscribe(Subscriber s) { if (s instanceof ConditionalSubscriber) { ConditionalSubscriber cs = (ConditionalSubscriber) s; - s.onSubscribe(new ConditionalArraySourceSubscription(array, cs)); + s.onSubscribe(new ConditionalArraySourceSubscription<>(array, cs)); } else { - s.onSubscribe(new ArraySourceSubscription(array, s)); + s.onSubscribe(new ArraySourceSubscription<>(array, s)); } } diff --git a/src/main/java/io/reactivex/internal/operators/PublisherAutoConnect.java b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherAutoConnect.java similarity index 100% rename from src/main/java/io/reactivex/internal/operators/PublisherAutoConnect.java rename to rxjava/src/main/java/io/reactivex/internal/operators/PublisherAutoConnect.java diff --git a/src/main/java/io/reactivex/internal/operators/PublisherCombineLatest.java b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherCombineLatest.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/PublisherCombineLatest.java rename to rxjava/src/main/java/io/reactivex/internal/operators/PublisherCombineLatest.java index 73915ad5c1..2da13a0888 100644 --- a/src/main/java/io/reactivex/internal/operators/PublisherCombineLatest.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherCombineLatest.java @@ -68,7 +68,7 @@ public void subscribe(Subscriber s) { return; } - LatestCoordinator lc = new LatestCoordinator(s, combiner, count, bufferSize, delayError); + LatestCoordinator lc = new LatestCoordinator<>(s, combiner, count, bufferSize, delayError); lc.subscribe(sources); } @@ -90,7 +90,7 @@ static final class LatestCoordinator extends AtomicInteger implements Subs final AtomicLong requested = new AtomicLong(); - final AtomicReference error = new AtomicReference(); + final AtomicReference error = new AtomicReference<>(); int active; int complete; @@ -106,14 +106,14 @@ public LatestCoordinator(Subscriber actual, this.delayError = delayError; this.latest = new Object[count]; this.subscribers = new CombinerSubscriber[count]; - this.queue = new SpscLinkedArrayQueue(bufferSize); + this.queue = new SpscLinkedArrayQueue<>(bufferSize); } public void subscribe(Publisher[] sources) { Subscriber[] as = subscribers; int len = as.length; for (int i = 0; i < len; i++) { - as[i] = new CombinerSubscriber(this, i); + as[i] = new CombinerSubscriber<>(this, i); } lazySet(0); // release array contents actual.onSubscribe(this); @@ -344,7 +344,7 @@ static final class CombinerSubscriber implements Subscriber, Subscripti boolean done; - final AtomicReference s = new AtomicReference(); + final AtomicReference s = new AtomicReference<>(); static final Subscription CANCELLED = new Subscription() { @Override diff --git a/src/main/java/io/reactivex/internal/operators/PublisherDefer.java b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherDefer.java similarity index 100% rename from src/main/java/io/reactivex/internal/operators/PublisherDefer.java rename to rxjava/src/main/java/io/reactivex/internal/operators/PublisherDefer.java diff --git a/src/main/java/io/reactivex/internal/operators/PublisherDelaySubscriptionOther.java b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherDelaySubscriptionOther.java similarity index 100% rename from src/main/java/io/reactivex/internal/operators/PublisherDelaySubscriptionOther.java rename to rxjava/src/main/java/io/reactivex/internal/operators/PublisherDelaySubscriptionOther.java diff --git a/src/main/java/io/reactivex/internal/operators/PublisherEmptySource.java b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherEmptySource.java similarity index 100% rename from src/main/java/io/reactivex/internal/operators/PublisherEmptySource.java rename to rxjava/src/main/java/io/reactivex/internal/operators/PublisherEmptySource.java diff --git a/src/main/java/io/reactivex/internal/operators/PublisherErrorSource.java b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherErrorSource.java similarity index 100% rename from src/main/java/io/reactivex/internal/operators/PublisherErrorSource.java rename to rxjava/src/main/java/io/reactivex/internal/operators/PublisherErrorSource.java diff --git a/src/main/java/io/reactivex/internal/operators/PublisherFutureSource.java b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherFutureSource.java similarity index 99% rename from src/main/java/io/reactivex/internal/operators/PublisherFutureSource.java rename to rxjava/src/main/java/io/reactivex/internal/operators/PublisherFutureSource.java index 2ba1e90765..a8dff06246 100644 --- a/src/main/java/io/reactivex/internal/operators/PublisherFutureSource.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherFutureSource.java @@ -32,7 +32,7 @@ public PublisherFutureSource(Future future, long timeout, TimeUnit @Override public void subscribe(Subscriber s) { - ScalarAsyncSubscription sas = new ScalarAsyncSubscription(s); + ScalarAsyncSubscription sas = new ScalarAsyncSubscription<>(s); s.onSubscribe(sas); if (!sas.isComplete()) { T v; diff --git a/src/main/java/io/reactivex/internal/operators/PublisherGenerate.java b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherGenerate.java similarity index 98% rename from src/main/java/io/reactivex/internal/operators/PublisherGenerate.java rename to rxjava/src/main/java/io/reactivex/internal/operators/PublisherGenerate.java index 5c2beba60c..c99b25cb9c 100644 --- a/src/main/java/io/reactivex/internal/operators/PublisherGenerate.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherGenerate.java @@ -45,7 +45,7 @@ public void subscribe(Subscriber s) { return; } - s.onSubscribe(new GeneratorSubscription(s, generator, disposeState, state)); + s.onSubscribe(new GeneratorSubscription<>(s, generator, disposeState, state)); } static final class GeneratorSubscription diff --git a/src/main/java/io/reactivex/internal/operators/PublisherIntervalOnceSource.java b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherIntervalOnceSource.java similarity index 93% rename from src/main/java/io/reactivex/internal/operators/PublisherIntervalOnceSource.java rename to rxjava/src/main/java/io/reactivex/internal/operators/PublisherIntervalOnceSource.java index 381b7a4cf8..74b71cf4db 100644 --- a/src/main/java/io/reactivex/internal/operators/PublisherIntervalOnceSource.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherIntervalOnceSource.java @@ -49,16 +49,10 @@ static final class IntervalOnceSubscriber extends AtomicReference final Subscriber actual; - static final Disposable DISPOSED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable DISPOSED = () -> { }; /** This state tells the setResource not to call dispose since the run is finishing anyway. */ - static final Disposable DONE = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable DONE = () -> { }; volatile boolean requested; diff --git a/src/main/java/io/reactivex/internal/operators/PublisherIntervalRangeSource.java b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherIntervalRangeSource.java similarity index 96% rename from src/main/java/io/reactivex/internal/operators/PublisherIntervalRangeSource.java rename to rxjava/src/main/java/io/reactivex/internal/operators/PublisherIntervalRangeSource.java index 55feb17261..25edb069ff 100644 --- a/src/main/java/io/reactivex/internal/operators/PublisherIntervalRangeSource.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherIntervalRangeSource.java @@ -62,12 +62,9 @@ static final class IntervalRangeSubscriber extends AtomicLong volatile boolean cancelled; - static final Disposable DISPOSED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable DISPOSED = () -> { }; - final AtomicReference resource = new AtomicReference(); + final AtomicReference resource = new AtomicReference<>(); public IntervalRangeSubscriber(Subscriber actual, long start, long end) { this.actual = actual; diff --git a/src/main/java/io/reactivex/internal/operators/PublisherIntervalSource.java b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherIntervalSource.java similarity index 96% rename from src/main/java/io/reactivex/internal/operators/PublisherIntervalSource.java rename to rxjava/src/main/java/io/reactivex/internal/operators/PublisherIntervalSource.java index 37dee8c2e8..3408d1252c 100644 --- a/src/main/java/io/reactivex/internal/operators/PublisherIntervalSource.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherIntervalSource.java @@ -59,12 +59,9 @@ static final class IntervalSubscriber extends AtomicLong volatile boolean cancelled; - static final Disposable DISPOSED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable DISPOSED = () -> { }; - final AtomicReference resource = new AtomicReference(); + final AtomicReference resource = new AtomicReference<>(); public IntervalSubscriber(Subscriber actual) { this.actual = actual; diff --git a/src/main/java/io/reactivex/internal/operators/PublisherIterableSource.java b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherIterableSource.java similarity index 98% rename from src/main/java/io/reactivex/internal/operators/PublisherIterableSource.java rename to rxjava/src/main/java/io/reactivex/internal/operators/PublisherIterableSource.java index fa7af841f9..003fbf8a46 100644 --- a/src/main/java/io/reactivex/internal/operators/PublisherIterableSource.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherIterableSource.java @@ -50,7 +50,7 @@ public void subscribe(Subscriber s) { EmptySubscription.complete(s); return; } - s.onSubscribe(new IteratorSourceSubscription(it, s)); + s.onSubscribe(new IteratorSourceSubscription<>(it, s)); } static final class IteratorSourceSubscription extends AtomicLong implements Subscription { diff --git a/src/main/java/io/reactivex/internal/operators/PublisherLift.java b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherLift.java similarity index 100% rename from src/main/java/io/reactivex/internal/operators/PublisherLift.java rename to rxjava/src/main/java/io/reactivex/internal/operators/PublisherLift.java diff --git a/src/main/java/io/reactivex/internal/operators/PublisherRangeSource.java b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherRangeSource.java similarity index 100% rename from src/main/java/io/reactivex/internal/operators/PublisherRangeSource.java rename to rxjava/src/main/java/io/reactivex/internal/operators/PublisherRangeSource.java diff --git a/src/main/java/io/reactivex/internal/operators/PublisherRedo.java b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherRedo.java similarity index 93% rename from src/main/java/io/reactivex/internal/operators/PublisherRedo.java rename to rxjava/src/main/java/io/reactivex/internal/operators/PublisherRedo.java index 93a2a78309..70200cdc98 100644 --- a/src/main/java/io/reactivex/internal/operators/PublisherRedo.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherRedo.java @@ -39,18 +39,13 @@ public void subscribe(Subscriber s) { // FIXE use BehaviorSubject? (once available) BehaviorSubject>> subject = BehaviorSubject.create(); - final RedoSubscriber parent = new RedoSubscriber(s, subject, source); + final RedoSubscriber parent = new RedoSubscriber<>(s, subject, source); s.onSubscribe(parent.arbiter); Publisher action = manager.apply(subject); - action.subscribe(new ToNotificationSubscriber(new Consumer>>() { - @Override - public void accept(Try> v) { - parent.handle(v); - } - })); + action.subscribe(new ToNotificationSubscriber<>(parent::handle)); // trigger first subscription parent.handle(Notification.next((Object)0)); diff --git a/src/main/java/io/reactivex/internal/operators/PublisherRefCount.java b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherRefCount.java similarity index 81% rename from src/main/java/io/reactivex/internal/operators/PublisherRefCount.java rename to rxjava/src/main/java/io/reactivex/internal/operators/PublisherRefCount.java index e0c10a4191..f97001dbf1 100644 --- a/src/main/java/io/reactivex/internal/operators/PublisherRefCount.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherRefCount.java @@ -91,7 +91,7 @@ void cleanup() { try { if (baseSubscription == currentBase) { baseSubscription.dispose(); - baseSubscription = new SetCompositeResource(Disposables.consumeAndDispose()); + baseSubscription = new SetCompositeResource<>(Disposables.consumeAndDispose()); subscriptionCount.set(0); } } finally { @@ -101,7 +101,7 @@ void cleanup() { } final ConnectableObservable source; - volatile SetCompositeResource baseSubscription = new SetCompositeResource(Disposables.consumeAndDispose()); + volatile SetCompositeResource baseSubscription = new SetCompositeResource<>(Disposables.consumeAndDispose()); final AtomicInteger subscriptionCount = new AtomicInteger(0); /** @@ -155,18 +155,15 @@ public void subscribe(final Subscriber subscriber) { private Consumer onSubscribe(final Subscriber subscriber, final AtomicBoolean writeLocked) { - return new Consumer() { - @Override - public void accept(Disposable subscription) { - try { - baseSubscription.add(subscription); - // ready to subscribe to source so do it - doSubscribe(subscriber, baseSubscription); - } finally { - // release the write lock - lock.unlock(); - writeLocked.set(false); - } + return subscription -> { + try { + baseSubscription.add(subscription); + // ready to subscribe to source so do it + doSubscribe(subscriber, baseSubscription); + } finally { + // release the write lock + lock.unlock(); + writeLocked.set(false); } }; } @@ -181,22 +178,19 @@ void doSubscribe(final Subscriber subscriber, final SetCompositeResou } private Disposable disconnect(final SetCompositeResource current) { - return new Disposable() { - @Override - public void dispose() { - lock.lock(); - try { - if (baseSubscription == current) { - if (subscriptionCount.decrementAndGet() == 0) { - baseSubscription.dispose(); - // need a new baseSubscription because once - // unsubscribed stays that way - baseSubscription = new SetCompositeResource(Disposables.consumeAndDispose()); - } + return () -> { + lock.lock(); + try { + if (baseSubscription == current) { + if (subscriptionCount.decrementAndGet() == 0) { + baseSubscription.dispose(); + // need a new baseSubscription because once + // unsubscribed stays that way + baseSubscription = new SetCompositeResource<>(Disposables.consumeAndDispose()); } - } finally { - lock.unlock(); } + } finally { + lock.unlock(); } }; } diff --git a/src/main/java/io/reactivex/internal/operators/PublisherRepeat.java b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherRepeat.java similarity index 96% rename from src/main/java/io/reactivex/internal/operators/PublisherRepeat.java rename to rxjava/src/main/java/io/reactivex/internal/operators/PublisherRepeat.java index 78b3904167..807a039f29 100644 --- a/src/main/java/io/reactivex/internal/operators/PublisherRepeat.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherRepeat.java @@ -32,7 +32,7 @@ public void subscribe(Subscriber s) { SubscriptionArbiter sa = new SubscriptionArbiter(); s.onSubscribe(sa); - RepeatSubscriber rs = new RepeatSubscriber(s, count != Long.MAX_VALUE ? count - 1 : Long.MAX_VALUE, sa, source); + RepeatSubscriber rs = new RepeatSubscriber<>(s, count != Long.MAX_VALUE ? count - 1 : Long.MAX_VALUE, sa, source); rs.subscribeNext(); } diff --git a/src/main/java/io/reactivex/internal/operators/PublisherRepeatUntil.java b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherRepeatUntil.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/PublisherRepeatUntil.java rename to rxjava/src/main/java/io/reactivex/internal/operators/PublisherRepeatUntil.java index 17eff72e61..3cdfbc5260 100644 --- a/src/main/java/io/reactivex/internal/operators/PublisherRepeatUntil.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherRepeatUntil.java @@ -33,7 +33,7 @@ public void subscribe(Subscriber s) { SubscriptionArbiter sa = new SubscriptionArbiter(); s.onSubscribe(sa); - RepeatSubscriber rs = new RepeatSubscriber(s, until, sa, source); + RepeatSubscriber rs = new RepeatSubscriber<>(s, until, sa, source); rs.subscribeNext(); } diff --git a/src/main/java/io/reactivex/internal/operators/PublisherRetryBiPredicate.java b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherRetryBiPredicate.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/PublisherRetryBiPredicate.java rename to rxjava/src/main/java/io/reactivex/internal/operators/PublisherRetryBiPredicate.java index 25ffd9f26c..5d7ab31770 100644 --- a/src/main/java/io/reactivex/internal/operators/PublisherRetryBiPredicate.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherRetryBiPredicate.java @@ -36,7 +36,7 @@ public void subscribe(Subscriber s) { SubscriptionArbiter sa = new SubscriptionArbiter(); s.onSubscribe(sa); - RetryBiSubscriber rs = new RetryBiSubscriber(s, predicate, sa, source); + RetryBiSubscriber rs = new RetryBiSubscriber<>(s, predicate, sa, source); rs.subscribeNext(); } diff --git a/src/main/java/io/reactivex/internal/operators/PublisherRetryPredicate.java b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherRetryPredicate.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/PublisherRetryPredicate.java rename to rxjava/src/main/java/io/reactivex/internal/operators/PublisherRetryPredicate.java index a3a1a08c32..4c8f588dd2 100644 --- a/src/main/java/io/reactivex/internal/operators/PublisherRetryPredicate.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherRetryPredicate.java @@ -38,7 +38,7 @@ public void subscribe(Subscriber s) { SubscriptionArbiter sa = new SubscriptionArbiter(); s.onSubscribe(sa); - RepeatSubscriber rs = new RepeatSubscriber(s, count, predicate, sa, source); + RepeatSubscriber rs = new RepeatSubscriber<>(s, count, predicate, sa, source); rs.subscribeNext(); } diff --git a/src/main/java/io/reactivex/internal/operators/PublisherScalarAsyncSource.java b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherScalarAsyncSource.java similarity index 99% rename from src/main/java/io/reactivex/internal/operators/PublisherScalarAsyncSource.java rename to rxjava/src/main/java/io/reactivex/internal/operators/PublisherScalarAsyncSource.java index 2f7a2b8895..a18fe43aa2 100644 --- a/src/main/java/io/reactivex/internal/operators/PublisherScalarAsyncSource.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherScalarAsyncSource.java @@ -26,7 +26,7 @@ public PublisherScalarAsyncSource(Callable callable) { } @Override public void subscribe(Subscriber s) { - ScalarAsyncSubscription sub = new ScalarAsyncSubscription(s); + ScalarAsyncSubscription sub = new ScalarAsyncSubscription<>(s); s.onSubscribe(sub); if (sub.isComplete()) { return; diff --git a/src/main/java/io/reactivex/internal/operators/PublisherSequenceEqual.java b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherSequenceEqual.java similarity index 95% rename from src/main/java/io/reactivex/internal/operators/PublisherSequenceEqual.java rename to rxjava/src/main/java/io/reactivex/internal/operators/PublisherSequenceEqual.java index d0cc62befb..9b30e77408 100644 --- a/src/main/java/io/reactivex/internal/operators/PublisherSequenceEqual.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherSequenceEqual.java @@ -40,7 +40,7 @@ public PublisherSequenceEqual(Publisher first, Publisher s) { - EqualCoordinator ec = new EqualCoordinator(s, bufferSize, first, second, comparer); + EqualCoordinator ec = new EqualCoordinator<>(s, bufferSize, first, second, comparer); ec.subscribe(); } @@ -68,9 +68,9 @@ public EqualCoordinator(Subscriber actual, int bufferSize, @SuppressWarnings("unchecked") EqualSubscriber[] as = new EqualSubscriber[2]; this.subscribers = as; - as[0] = new EqualSubscriber(this, 0, bufferSize); - as[1] = new EqualSubscriber(this, 1, bufferSize); - this.resources = new ArrayCompositeResource(2, SubscriptionHelper.consumeAndCancel()); + as[0] = new EqualSubscriber<>(this, 0, bufferSize); + as[1] = new EqualSubscriber<>(this, 1, bufferSize); + this.resources = new ArrayCompositeResource<>(2, SubscriptionHelper.consumeAndCancel()); } boolean setSubscription(Subscription s, int index) { @@ -239,9 +239,9 @@ public EqualSubscriber(EqualCoordinator parent, int index, int bufferSize) { this.index = index; Queue q; if (Pow2.isPowerOfTwo(bufferSize)) { - q = new SpscArrayQueue(bufferSize); + q = new SpscArrayQueue<>(bufferSize); } else { - q = new SpscExactArrayQueue(bufferSize); + q = new SpscExactArrayQueue<>(bufferSize); } this.queue = q; } diff --git a/src/main/java/io/reactivex/internal/operators/PublisherSubscribeOn.java b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherSubscribeOn.java similarity index 85% rename from src/main/java/io/reactivex/internal/operators/PublisherSubscribeOn.java rename to rxjava/src/main/java/io/reactivex/internal/operators/PublisherSubscribeOn.java index c9b515657a..061cfe7a95 100644 --- a/src/main/java/io/reactivex/internal/operators/PublisherSubscribeOn.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherSubscribeOn.java @@ -40,20 +40,10 @@ public void subscribe(final Subscriber s) { */ if (requestOn) { Scheduler.Worker w = scheduler.createWorker(); - final SubscribeOnSubscriber sos = new SubscribeOnSubscriber(s, w); - w.schedule(new Runnable() { - @Override - public void run() { - source.subscribe(sos); - } - }); + final SubscribeOnSubscriber sos = new SubscribeOnSubscriber<>(s, w); + w.schedule(() -> source.subscribe(sos)); } else { - scheduler.scheduleDirect(new Runnable() { - @Override - public void run() { - source.subscribe(s); - } - }); + scheduler.scheduleDirect(() -> source.subscribe(s)); } } @@ -111,12 +101,7 @@ public void request(final long n) { if (Thread.currentThread() == get()) { s.request(n); } else { - worker.schedule(new Runnable() { - @Override - public void run() { - s.request(n); - } - }); + worker.schedule(() -> s.request(n)); } } diff --git a/src/main/java/io/reactivex/internal/operators/PublisherUsing.java b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherUsing.java similarity index 98% rename from src/main/java/io/reactivex/internal/operators/PublisherUsing.java rename to rxjava/src/main/java/io/reactivex/internal/operators/PublisherUsing.java index 2753bf3ad9..864e3d528a 100644 --- a/src/main/java/io/reactivex/internal/operators/PublisherUsing.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherUsing.java @@ -63,7 +63,7 @@ public void subscribe(Subscriber s) { return; } - UsingSubscriber us = new UsingSubscriber(s, resource, disposer, eager); + UsingSubscriber us = new UsingSubscriber<>(s, resource, disposer, eager); source.subscribe(us); } diff --git a/src/main/java/io/reactivex/internal/operators/PublisherZip.java b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherZip.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/PublisherZip.java rename to rxjava/src/main/java/io/reactivex/internal/operators/PublisherZip.java index 9fa0e9c986..34b3bd1dbd 100644 --- a/src/main/java/io/reactivex/internal/operators/PublisherZip.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherZip.java @@ -68,7 +68,7 @@ public void subscribe(Subscriber s) { return; } - ZipCoordinator zc = new ZipCoordinator(s, zipper, count, delayError); + ZipCoordinator zc = new ZipCoordinator<>(s, zipper, count, delayError); zc.subscribe(sources, bufferSize); } @@ -100,7 +100,7 @@ public void subscribe(Publisher[] sources, int bufferSize) { ZipSubscriber[] s = subscribers; int len = s.length; for (int i = 0; i < len; i++) { - s[i] = new ZipSubscriber(this, bufferSize); + s[i] = new ZipSubscriber<>(this, bufferSize); } // this makes sure the contents of the subscribers array is visible requested.lazySet(0); @@ -272,7 +272,7 @@ static final class ZipSubscriber extends AtomicLong implements Subscriber< volatile boolean done; Throwable error; - final AtomicReference s = new AtomicReference(); + final AtomicReference s = new AtomicReference<>(); Subscription cachedS; @@ -293,9 +293,9 @@ public ZipSubscriber(ZipCoordinator parent, int bufferSize) { this.bufferSize = bufferSize; Queue q; if (Pow2.isPowerOfTwo(bufferSize)) { - q = new SpscArrayQueue(bufferSize); + q = new SpscArrayQueue<>(bufferSize); } else { - q = new SpscExactArrayQueue(bufferSize); + q = new SpscExactArrayQueue<>(bufferSize); } this.queue = q; } diff --git a/src/main/java/io/reactivex/internal/operators/PublisherZipIterable.java b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherZipIterable.java similarity index 98% rename from src/main/java/io/reactivex/internal/operators/PublisherZipIterable.java rename to rxjava/src/main/java/io/reactivex/internal/operators/PublisherZipIterable.java index 937d7df8dc..1a871f199c 100644 --- a/src/main/java/io/reactivex/internal/operators/PublisherZipIterable.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/PublisherZipIterable.java @@ -64,7 +64,7 @@ public void subscribe(Subscriber t) { return; } - source.subscribe(new ZipIterableSubscriber(t, it, zipper)); + source.subscribe(new ZipIterableSubscriber<>(t, it, zipper)); } static final class ZipIterableSubscriber implements Subscriber { diff --git a/src/main/java/io/reactivex/internal/operators/SubscriberResourceWrapper.java b/rxjava/src/main/java/io/reactivex/internal/operators/SubscriberResourceWrapper.java similarity index 99% rename from src/main/java/io/reactivex/internal/operators/SubscriberResourceWrapper.java rename to rxjava/src/main/java/io/reactivex/internal/operators/SubscriberResourceWrapper.java index d68770a206..49db141383 100644 --- a/src/main/java/io/reactivex/internal/operators/SubscriberResourceWrapper.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/SubscriberResourceWrapper.java @@ -29,7 +29,7 @@ public final class SubscriberResourceWrapper extends AtomicReference actual; final Consumer disposer; - final AtomicReference subscription = new AtomicReference(); + final AtomicReference subscription = new AtomicReference<>(); static final Subscription TERMINATED = new Subscription() { @Override diff --git a/src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeConcat.java b/rxjava/src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeConcat.java similarity index 96% rename from src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeConcat.java rename to rxjava/src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeConcat.java index 89df1407c3..3f5c414c34 100644 --- a/src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeConcat.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeConcat.java @@ -63,8 +63,8 @@ static final class CompletableConcatSubscriber public CompletableConcatSubscriber(CompletableSubscriber actual, int prefetch) { this.actual = actual; this.prefetch = prefetch; - this.queue = new SpscArrayQueue(prefetch); - this.sr = new SerialResource(Disposables.consumeAndDispose()); + this.queue = new SpscArrayQueue<>(prefetch); + this.sr = new SerialResource<>(Disposables.consumeAndDispose()); this.inner = new ConcatInnerSubscriber(); } diff --git a/src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeConcatArray.java b/rxjava/src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeConcatArray.java similarity index 100% rename from src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeConcatArray.java rename to rxjava/src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeConcatArray.java diff --git a/src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeConcatIterable.java b/rxjava/src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeConcatIterable.java similarity index 100% rename from src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeConcatIterable.java rename to rxjava/src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeConcatIterable.java diff --git a/src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeMerge.java b/rxjava/src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeMerge.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeMerge.java rename to rxjava/src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeMerge.java index 09319ccce2..c45e40bec9 100644 --- a/src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeMerge.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeMerge.java @@ -59,7 +59,7 @@ static final class CompletableMergeSubscriber volatile boolean done; - final AtomicReference> errors = new AtomicReference>(); + final AtomicReference> errors = new AtomicReference<>(); final AtomicBoolean once = new AtomicBoolean(); @@ -67,7 +67,7 @@ public CompletableMergeSubscriber(CompletableSubscriber actual, int maxConcurren this.actual = actual; this.maxConcurrency = maxConcurrency; this.delayErrors = delayErrors; - this.set = new SetCompositeResource(Disposables.consumeAndDispose()); + this.set = new SetCompositeResource<>(Disposables.consumeAndDispose()); lazySet(1); } @@ -99,7 +99,7 @@ Queue getOrCreateErrors() { return q; } - q = new ConcurrentLinkedQueue(); + q = new ConcurrentLinkedQueue<>(); if (errors.compareAndSet(null, q)) { return q; } diff --git a/src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeMergeArray.java b/rxjava/src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeMergeArray.java similarity index 100% rename from src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeMergeArray.java rename to rxjava/src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeMergeArray.java diff --git a/src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeMergeDelayErrorArray.java b/rxjava/src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeMergeDelayErrorArray.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeMergeDelayErrorArray.java rename to rxjava/src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeMergeDelayErrorArray.java index a877523fc1..4f26cff70d 100644 --- a/src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeMergeDelayErrorArray.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeMergeDelayErrorArray.java @@ -33,7 +33,7 @@ public void accept(final CompletableSubscriber s) { final CompositeDisposable set = new CompositeDisposable(); final AtomicInteger wip = new AtomicInteger(sources.length + 1); - final Queue q = new ConcurrentLinkedQueue(); + final Queue q = new ConcurrentLinkedQueue<>(); s.onSubscribe(set); diff --git a/src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeMergeDelayErrorIterable.java b/rxjava/src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeMergeDelayErrorIterable.java similarity index 98% rename from src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeMergeDelayErrorIterable.java rename to rxjava/src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeMergeDelayErrorIterable.java index c2d36219ce..6e7b2125f2 100644 --- a/src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeMergeDelayErrorIterable.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeMergeDelayErrorIterable.java @@ -33,7 +33,7 @@ public void accept(final CompletableSubscriber s) { final CompositeDisposable set = new CompositeDisposable(); final AtomicInteger wip = new AtomicInteger(1); - final Queue queue = new MpscLinkedQueue(); + final Queue queue = new MpscLinkedQueue<>(); s.onSubscribe(set); diff --git a/src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeMergeIterable.java b/rxjava/src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeMergeIterable.java similarity index 100% rename from src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeMergeIterable.java rename to rxjava/src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeMergeIterable.java diff --git a/src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeTimeout.java b/rxjava/src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeTimeout.java similarity index 68% rename from src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeTimeout.java rename to rxjava/src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeTimeout.java index 479e2d0004..68faebea44 100644 --- a/src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeTimeout.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/completable/CompletableOnSubscribeTimeout.java @@ -45,35 +45,32 @@ public void accept(final CompletableSubscriber s) { final AtomicBoolean once = new AtomicBoolean(); - Disposable timer = scheduler.scheduleDirect(new Runnable() { - @Override - public void run() { - if (once.compareAndSet(false, true)) { - set.clear(); - if (other == null) { - s.onError(new TimeoutException()); - } else { - other.subscribe(new CompletableSubscriber() { - - @Override - public void onSubscribe(Disposable d) { - set.add(d); - } - - @Override - public void onError(Throwable e) { - set.dispose(); - s.onError(e); - } - - @Override - public void onComplete() { - set.dispose(); - s.onComplete(); - } - - }); - } + Disposable timer = scheduler.scheduleDirect(() -> { + if (once.compareAndSet(false, true)) { + set.clear(); + if (other == null) { + s.onError(new TimeoutException()); + } else { + other.subscribe(new CompletableSubscriber() { + + @Override + public void onSubscribe(Disposable d) { + set.add(d); + } + + @Override + public void onError(Throwable e) { + set.dispose(); + s.onError(e); + } + + @Override + public void onComplete() { + set.dispose(); + s.onComplete(); + } + + }); } } }, timeout, unit); diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpBlockingOperatorLatest.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpBlockingOperatorLatest.java similarity index 89% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpBlockingOperatorLatest.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpBlockingOperatorLatest.java index 22613c4cf3..d2f0e55cf1 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpBlockingOperatorLatest.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpBlockingOperatorLatest.java @@ -40,17 +40,14 @@ public enum NbpBlockingOperatorLatest { * been returned by the {@code Iterable}, then returns that item */ public static Iterable latest(final NbpObservable source) { - return new Iterable() { - @Override - public Iterator iterator() { - NbpLatestObserverIterator lio = new NbpLatestObserverIterator(); - - @SuppressWarnings("unchecked") - NbpObservable>> materialized = ((NbpObservable)source).materialize(); - - materialized.subscribe(lio); - return lio; - } + return () -> { + NbpLatestObserverIterator lio = new NbpLatestObserverIterator<>(); + + @SuppressWarnings("unchecked") + NbpObservable>> materialized = ((NbpObservable)source).materialize(); + + materialized.subscribe(lio); + return lio; }; } @@ -58,7 +55,7 @@ public Iterator iterator() { static final class NbpLatestObserverIterator extends NbpDisposableSubscriber>> implements Iterator { final Semaphore notify = new Semaphore(0); // observer's notification - final AtomicReference>> value = new AtomicReference>>(); + final AtomicReference>> value = new AtomicReference<>(); @Override public void onNext(Try> args) { diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpBlockingOperatorMostRecent.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpBlockingOperatorMostRecent.java similarity index 88% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpBlockingOperatorMostRecent.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpBlockingOperatorMostRecent.java index eff82c060f..259bbe21a3 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpBlockingOperatorMostRecent.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpBlockingOperatorMostRecent.java @@ -39,19 +39,16 @@ public enum NbpBlockingOperatorMostRecent { * {@code initialValue} if {@code source} has not yet emitted any items */ public static Iterable mostRecent(final NbpObservable source, final T initialValue) { - return new Iterable() { - @Override - public Iterator iterator() { - NbpMostRecentObserver mostRecentObserver = new NbpMostRecentObserver(initialValue); + return () -> { + NbpMostRecentObserver mostRecentObserver = new NbpMostRecentObserver<>(initialValue); - /** - * Subscribe instead of unsafeSubscribe since this is the final subscribe in the chain - * since it is for BlockingObservable. - */ - source.subscribe(mostRecentObserver); + /** + * Subscribe instead of unsafeSubscribe since this is the final subscribe in the chain + * since it is for BlockingObservable. + */ + source.subscribe(mostRecentObserver); - return mostRecentObserver.getIterable(); - } + return mostRecentObserver.getIterable(); }; } diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpBlockingOperatorNext.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpBlockingOperatorNext.java similarity index 95% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpBlockingOperatorNext.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpBlockingOperatorNext.java index 293567d2f6..c20d376487 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpBlockingOperatorNext.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpBlockingOperatorNext.java @@ -39,12 +39,9 @@ public enum NbpBlockingOperatorNext { * @return an {@code Iterable} that behaves like a blocking version of {@code items} */ public static Iterable next(final NbpObservable items) { - return new Iterable() { - @Override - public Iterator iterator() { - NbpNextObserver nextObserver = new NbpNextObserver(); - return new NextIterator(items, nextObserver); - } + return () -> { + NbpNextObserver nextObserver = new NbpNextObserver<>(); + return new NextIterator<>(items, nextObserver); }; } @@ -142,7 +139,7 @@ public void remove() { } private static class NbpNextObserver extends NbpDisposableSubscriber>> { - private final BlockingQueue>> buf = new ArrayBlockingQueue>>(1); + private final BlockingQueue>> buf = new ArrayBlockingQueue<>(1); final AtomicInteger waiting = new AtomicInteger(); @Override diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpCachedObservable.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpCachedObservable.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpCachedObservable.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpCachedObservable.java index 3d3113a720..7645165563 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpCachedObservable.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpCachedObservable.java @@ -51,9 +51,9 @@ public static NbpCachedObservable from(NbpObservable source, if (capacityHint < 1) { throw new IllegalArgumentException("capacityHint > 0 required"); } - CacheState state = new CacheState(source, capacityHint); - CachedSubscribe onSubscribe = new CachedSubscribe(state); - return new NbpCachedObservable(onSubscribe, state); + CacheState state = new CacheState<>(source, capacityHint); + CachedSubscribe onSubscribe = new CachedSubscribe<>(state); + return new NbpCachedObservable<>(onSubscribe, state); } /** @@ -118,7 +118,7 @@ public CacheState(NbpObservable source, int capacityHint) { super(capacityHint); this.source = source; this.producers = EMPTY; - this.connection = new SerialResource(Disposables.consumeAndDispose()); + this.connection = new SerialResource<>(Disposables.consumeAndDispose()); } /** * Adds a ReplayProducer to the producers array atomically. @@ -232,7 +232,7 @@ public CachedSubscribe(CacheState state) { @Override public void accept(NbpSubscriber t) { // we can connect first because we replay everything anyway - ReplaySubscription rp = new ReplaySubscription(t, state); + ReplaySubscription rp = new ReplaySubscription<>(t, state); state.addProducer(rp); t.onSubscribe(rp); diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpObservableScalarSource.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpObservableScalarSource.java similarity index 53% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpObservableScalarSource.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpObservableScalarSource.java index eb009abbde..be2b346927 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpObservableScalarSource.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpObservableScalarSource.java @@ -24,13 +24,10 @@ public final class NbpObservableScalarSource extends NbpObservable { private final T value; public NbpObservableScalarSource(final T value) { - super(new NbpOnSubscribe() { - @Override - public void accept(NbpSubscriber s) { - s.onSubscribe(EmptyDisposable.INSTANCE); - s.onNext(value); - s.onComplete(); - } + super(s -> { + s.onSubscribe(EmptyDisposable.INSTANCE); + s.onNext(value); + s.onComplete(); }); this.value = value; } @@ -40,29 +37,26 @@ public T value() { } public NbpOnSubscribe scalarFlatMap(final Function> mapper) { - return new NbpOnSubscribe() { - @Override - public void accept(NbpSubscriber s) { - NbpObservable other; - try { - other = mapper.apply(value); - } catch (Throwable e) { - EmptyDisposable.error(e, s); - return; - } - if (other == null) { - EmptyDisposable.error(new NullPointerException("The publisher returned by the function is null"), s); - return; - } - if (other instanceof NbpObservableScalarSource) { - @SuppressWarnings("unchecked") - NbpObservableScalarSource o = (NbpObservableScalarSource)other; - s.onSubscribe(EmptyDisposable.INSTANCE); - s.onNext(o.value); - s.onComplete(); - } else { - other.subscribe(s); - } + return s -> { + NbpObservable other; + try { + other = mapper.apply(value); + } catch (Throwable e) { + EmptyDisposable.error(e, s); + return; + } + if (other == null) { + EmptyDisposable.error(new NullPointerException("The publisher returned by the function is null"), s); + return; + } + if (other instanceof NbpObservableScalarSource) { + @SuppressWarnings("unchecked") + NbpObservableScalarSource o = (NbpObservableScalarSource)other; + s.onSubscribe(EmptyDisposable.INSTANCE); + s.onNext(o.value); + s.onComplete(); + } else { + other.subscribe(s); } }; } diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeAmb.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeAmb.java similarity index 96% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeAmb.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeAmb.java index 498ff6432d..cd787b3343 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeAmb.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeAmb.java @@ -59,7 +59,7 @@ public void accept(NbpSubscriber s) { return; } - AmbCoordinator ac = new AmbCoordinator(s, count); + AmbCoordinator ac = new AmbCoordinator<>(s, count); ac.subscribe(sources); } @@ -79,7 +79,7 @@ public void subscribe(NbpObservable[] sources) { AmbInnerSubscriber[] as = subscribers; int len = as.length; for (int i = 0; i < len; i++) { - as[i] = new AmbInnerSubscriber(this, i + 1, actual); + as[i] = new AmbInnerSubscriber<>(this, i + 1, actual); } winner.lazySet(0); // release the contents of 'as' actual.onSubscribe(this); @@ -132,10 +132,7 @@ static final class AmbInnerSubscriber extends AtomicReference imp boolean won; - static final Disposable CANCELLED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable CANCELLED = () -> { }; public AmbInnerSubscriber(AmbCoordinator parent, int index, NbpSubscriber actual) { this.parent = parent; diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeArraySource.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeArraySource.java similarity index 100% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeArraySource.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeArraySource.java diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeAutoConnect.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeAutoConnect.java similarity index 100% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeAutoConnect.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeAutoConnect.java diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeCombineLatest.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeCombineLatest.java similarity index 96% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeCombineLatest.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeCombineLatest.java index 976fe206c8..c4dd977afe 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeCombineLatest.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeCombineLatest.java @@ -69,7 +69,7 @@ public void accept(NbpSubscriber s) { return; } - LatestCoordinator lc = new LatestCoordinator(s, combiner, count, bufferSize, delayError); + LatestCoordinator lc = new LatestCoordinator<>(s, combiner, count, bufferSize, delayError); lc.subscribe(sources); } @@ -89,7 +89,7 @@ static final class LatestCoordinator extends AtomicInteger implements Disp volatile boolean done; - final AtomicReference error = new AtomicReference(); + final AtomicReference error = new AtomicReference<>(); int active; int complete; @@ -105,14 +105,14 @@ public LatestCoordinator(NbpSubscriber actual, this.delayError = delayError; this.latest = new Object[count]; this.subscribers = new CombinerSubscriber[count]; - this.queue = new SpscLinkedArrayQueue(bufferSize); + this.queue = new SpscLinkedArrayQueue<>(bufferSize); } public void subscribe(NbpObservable[] sources) { NbpSubscriber[] as = subscribers; int len = as.length; for (int i = 0; i < len; i++) { - as[i] = new CombinerSubscriber(this, i); + as[i] = new CombinerSubscriber<>(this, i); } lazySet(0); // release array contents actual.onSubscribe(this); @@ -318,12 +318,9 @@ static final class CombinerSubscriber implements NbpSubscriber, Disposa boolean done; - final AtomicReference s = new AtomicReference(); + final AtomicReference s = new AtomicReference<>(); - static final Disposable CANCELLED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable CANCELLED = () -> { }; public CombinerSubscriber(LatestCoordinator parent, int index) { this.parent = parent; diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeDefer.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeDefer.java similarity index 100% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeDefer.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeDefer.java diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeDelaySubscriptionOther.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeDelaySubscriptionOther.java similarity index 100% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeDelaySubscriptionOther.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeDelaySubscriptionOther.java diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeErrorSource.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeErrorSource.java similarity index 100% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeErrorSource.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeErrorSource.java diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeFutureSource.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeFutureSource.java similarity index 100% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeFutureSource.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeFutureSource.java diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeGenerate.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeGenerate.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeGenerate.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeGenerate.java index 4c825c2d7d..68f57d33bd 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeGenerate.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeGenerate.java @@ -42,7 +42,7 @@ public void accept(NbpSubscriber s) { return; } - GeneratorDisposable gd = new GeneratorDisposable(s, generator, disposeState, state); + GeneratorDisposable gd = new GeneratorDisposable<>(s, generator, disposeState, state); s.onSubscribe(gd); gd.run(); } diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeIntervalRangeSource.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeIntervalRangeSource.java similarity index 96% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeIntervalRangeSource.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeIntervalRangeSource.java index 4e5336741d..a54eb9ca55 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeIntervalRangeSource.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeIntervalRangeSource.java @@ -58,12 +58,9 @@ static final class IntervalRangeSubscriber volatile boolean cancelled; - static final Disposable DISPOSED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable DISPOSED = () -> { }; - final AtomicReference resource = new AtomicReference(); + final AtomicReference resource = new AtomicReference<>(); public IntervalRangeSubscriber(NbpSubscriber actual, long start, long end) { this.actual = actual; diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeIntervalSource.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeIntervalSource.java similarity index 95% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeIntervalSource.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeIntervalSource.java index a81a0183ed..70b48042ae 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeIntervalSource.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeIntervalSource.java @@ -53,12 +53,9 @@ static final class IntervalSubscriber volatile boolean cancelled; - static final Disposable DISPOSED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable DISPOSED = () -> { }; - final AtomicReference resource = new AtomicReference(); + final AtomicReference resource = new AtomicReference<>(); public IntervalSubscriber(NbpSubscriber actual) { this.actual = actual; diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeIterableSource.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeIterableSource.java similarity index 100% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeIterableSource.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeIterableSource.java diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeLift.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeLift.java similarity index 100% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeLift.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeLift.java diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRedo.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRedo.java similarity index 93% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRedo.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRedo.java index aff97aece6..4fe47ae4d3 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRedo.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRedo.java @@ -38,18 +38,13 @@ public void accept(NbpSubscriber s) { // FIXE use BehaviorSubject? (once available) NbpBehaviorSubject>> subject = NbpBehaviorSubject.create(); - final RedoSubscriber parent = new RedoSubscriber(s, subject, source); + final RedoSubscriber parent = new RedoSubscriber<>(s, subject, source); s.onSubscribe(parent.arbiter); NbpObservable action = manager.apply(subject); - action.subscribe(new NbpToNotificationSubscriber(new Consumer>>() { - @Override - public void accept(Try> o) { - parent.handle(o); - } - })); + action.subscribe(new NbpToNotificationSubscriber<>(parent::handle)); // trigger first subscription parent.handle(Notification.next(0)); diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRefCount.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRefCount.java similarity index 81% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRefCount.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRefCount.java index 596309bb52..dcdaee53be 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRefCount.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRefCount.java @@ -85,7 +85,7 @@ void cleanup() { try { if (baseSubscription == currentBase) { baseSubscription.dispose(); - baseSubscription = new SetCompositeResource(Disposables.consumeAndDispose()); + baseSubscription = new SetCompositeResource<>(Disposables.consumeAndDispose()); subscriptionCount.set(0); } } finally { @@ -96,7 +96,7 @@ void cleanup() { final NbpConnectableObservable source; - volatile SetCompositeResource baseSubscription = new SetCompositeResource(Disposables.consumeAndDispose()); + volatile SetCompositeResource baseSubscription = new SetCompositeResource<>(Disposables.consumeAndDispose()); final AtomicInteger subscriptionCount = new AtomicInteger(); @@ -151,18 +151,15 @@ public void accept(final NbpSubscriber subscriber) { private Consumer onSubscribe(final NbpSubscriber subscriber, final AtomicBoolean writeLocked) { - return new Consumer() { - @Override - public void accept(Disposable subscription) { - try { - baseSubscription.add(subscription); - // ready to subscribe to source so do it - doSubscribe(subscriber, baseSubscription); - } finally { - // release the write lock - lock.unlock(); - writeLocked.set(false); - } + return subscription -> { + try { + baseSubscription.add(subscription); + // ready to subscribe to source so do it + doSubscribe(subscriber, baseSubscription); + } finally { + // release the write lock + lock.unlock(); + writeLocked.set(false); } }; } @@ -177,22 +174,19 @@ void doSubscribe(final NbpSubscriber subscriber, final SetCompositeRe } private Disposable disconnect(final SetCompositeResource current) { - return new Disposable() { - @Override - public void dispose() { - lock.lock(); - try { - if (baseSubscription == current) { - if (subscriptionCount.decrementAndGet() == 0) { - baseSubscription.dispose(); - // need a new baseSubscription because once - // unsubscribed stays that way - baseSubscription = new SetCompositeResource(Disposables.consumeAndDispose()); - } + return () -> { + lock.lock(); + try { + if (baseSubscription == current) { + if (subscriptionCount.decrementAndGet() == 0) { + baseSubscription.dispose(); + // need a new baseSubscription because once + // unsubscribed stays that way + baseSubscription = new SetCompositeResource<>(Disposables.consumeAndDispose()); } - } finally { - lock.unlock(); } + } finally { + lock.unlock(); } }; } diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRepeat.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRepeat.java similarity index 96% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRepeat.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRepeat.java index d1c87ee84e..503e10b6f7 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRepeat.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRepeat.java @@ -32,7 +32,7 @@ public void accept(NbpSubscriber s) { MultipleAssignmentDisposable mad = new MultipleAssignmentDisposable(); s.onSubscribe(mad); - RepeatSubscriber rs = new RepeatSubscriber(s, count != Long.MAX_VALUE ? count - 1 : Long.MAX_VALUE, mad, source); + RepeatSubscriber rs = new RepeatSubscriber<>(s, count != Long.MAX_VALUE ? count - 1 : Long.MAX_VALUE, mad, source); rs.subscribeNext(); } diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRepeatUntil.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRepeatUntil.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRepeatUntil.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRepeatUntil.java index deec32b34c..3b6cf53b01 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRepeatUntil.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRepeatUntil.java @@ -33,7 +33,7 @@ public void accept(NbpSubscriber s) { MultipleAssignmentDisposable sa = new MultipleAssignmentDisposable(); s.onSubscribe(sa); - RepeatSubscriber rs = new RepeatSubscriber(s, until, sa, source); + RepeatSubscriber rs = new RepeatSubscriber<>(s, until, sa, source); rs.subscribeNext(); } diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRetryBiPredicate.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRetryBiPredicate.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRetryBiPredicate.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRetryBiPredicate.java index 0ba5868da4..5dba4747e7 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRetryBiPredicate.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRetryBiPredicate.java @@ -36,7 +36,7 @@ public void accept(NbpSubscriber s) { SerialDisposable sa = new SerialDisposable(); s.onSubscribe(sa); - RetryBiSubscriber rs = new RetryBiSubscriber(s, predicate, sa, source); + RetryBiSubscriber rs = new RetryBiSubscriber<>(s, predicate, sa, source); rs.subscribeNext(); } diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRetryPredicate.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRetryPredicate.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRetryPredicate.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRetryPredicate.java index 3b4516317f..290886da59 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRetryPredicate.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRetryPredicate.java @@ -38,7 +38,7 @@ public void accept(NbpSubscriber s) { SerialDisposable sa = new SerialDisposable(); s.onSubscribe(sa); - RepeatSubscriber rs = new RepeatSubscriber(s, count, predicate, sa, source); + RepeatSubscriber rs = new RepeatSubscriber<>(s, count, predicate, sa, source); rs.subscribeNext(); } diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeScalarAsyncSource.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeScalarAsyncSource.java similarity index 100% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeScalarAsyncSource.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeScalarAsyncSource.java diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeSequenceEqual.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeSequenceEqual.java similarity index 95% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeSequenceEqual.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeSequenceEqual.java index ec2866be4f..dcde2c01bf 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeSequenceEqual.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeSequenceEqual.java @@ -39,7 +39,7 @@ public NbpOnSubscribeSequenceEqual(NbpObservable first, NbpObservab @Override public void accept(NbpSubscriber s) { - EqualCoordinator ec = new EqualCoordinator(s, bufferSize, first, second, comparer); + EqualCoordinator ec = new EqualCoordinator<>(s, bufferSize, first, second, comparer); ec.subscribe(); } @@ -65,9 +65,9 @@ public EqualCoordinator(NbpSubscriber actual, int bufferSize, @SuppressWarnings("unchecked") EqualSubscriber[] as = new EqualSubscriber[2]; this.subscribers = as; - as[0] = new EqualSubscriber(this, 0, bufferSize); - as[1] = new EqualSubscriber(this, 1, bufferSize); - this.resources = new ArrayCompositeResource(2, Disposables.consumeAndDispose()); + as[0] = new EqualSubscriber<>(this, 0, bufferSize); + as[1] = new EqualSubscriber<>(this, 1, bufferSize); + this.resources = new ArrayCompositeResource<>(2, Disposables.consumeAndDispose()); } boolean setSubscription(Disposable s, int index) { @@ -212,7 +212,7 @@ static final class EqualSubscriber implements NbpSubscriber { public EqualSubscriber(EqualCoordinator parent, int index, int bufferSize) { this.parent = parent; this.index = index; - this.queue = new SpscLinkedArrayQueue(bufferSize); + this.queue = new SpscLinkedArrayQueue<>(bufferSize); } @Override diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeSubscribeOn.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeSubscribeOn.java similarity index 94% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeSubscribeOn.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeSubscribeOn.java index 5c263ac0cd..d54b0d81b7 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeSubscribeOn.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeSubscribeOn.java @@ -36,12 +36,7 @@ public void accept(final NbpSubscriber s) { * one must set a Subscription on s on the current thread, but * it is expected that onSubscribe is run on the target scheduler. */ - scheduler.scheduleDirect(new Runnable() { - @Override - public void run() { - source.subscribe(s); - } - }); + scheduler.scheduleDirect(() -> source.subscribe(s)); } static final class SubscribeOnSubscriber extends AtomicReference implements NbpSubscriber, Disposable { diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeTimerOnceSource.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeTimerOnceSource.java similarity index 92% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeTimerOnceSource.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeTimerOnceSource.java index 41420a9d10..a107164866 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeTimerOnceSource.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeTimerOnceSource.java @@ -48,16 +48,10 @@ static final class IntervalOnceSubscriber extends AtomicReference final NbpSubscriber actual; - static final Disposable DISPOSED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable DISPOSED = () -> { }; /** This state tells the setResource not to call dispose since the run is finishing anyway. */ - static final Disposable DONE = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable DONE = () -> { }; volatile boolean cancelled; diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeUsing.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeUsing.java similarity index 98% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeUsing.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeUsing.java index 218dc20e6e..e51e4f848d 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeUsing.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeUsing.java @@ -65,7 +65,7 @@ public void accept(NbpSubscriber s) { return; } - UsingSubscriber us = new UsingSubscriber(s, resource, disposer, eager); + UsingSubscriber us = new UsingSubscriber<>(s, resource, disposer, eager); source.subscribe(us); } diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeZip.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeZip.java similarity index 96% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeZip.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeZip.java index cdf8ec9486..8e3431482b 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeZip.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeZip.java @@ -68,7 +68,7 @@ public void accept(NbpSubscriber s) { return; } - ZipCoordinator zc = new ZipCoordinator(s, zipper, count, delayError); + ZipCoordinator zc = new ZipCoordinator<>(s, zipper, count, delayError); zc.subscribe(sources, bufferSize); } @@ -98,7 +98,7 @@ public void subscribe(NbpObservable[] sources, int bufferSize) { ZipSubscriber[] s = subscribers; int len = s.length; for (int i = 0; i < len; i++) { - s[i] = new ZipSubscriber(this, bufferSize); + s[i] = new ZipSubscriber<>(this, bufferSize); } // this makes sure the contents of the subscribers array is visible this.lazySet(0); @@ -241,16 +241,13 @@ static final class ZipSubscriber implements NbpSubscriber, Disposable { volatile boolean done; Throwable error; - final AtomicReference s = new AtomicReference(); + final AtomicReference s = new AtomicReference<>(); - static final Disposable CANCELLED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable CANCELLED = () -> { }; public ZipSubscriber(ZipCoordinator parent, int bufferSize) { this.parent = parent; - this.queue = new SpscLinkedArrayQueue(bufferSize); + this.queue = new SpscLinkedArrayQueue<>(bufferSize); } @Override public void onSubscribe(Disposable s) { diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeZipIterable.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeZipIterable.java similarity index 98% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeZipIterable.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeZipIterable.java index 5c562484ff..02d0805c6e 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeZipIterable.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeZipIterable.java @@ -66,7 +66,7 @@ public void accept(NbpSubscriber t) { return; } - source.subscribe(new ZipIterableSubscriber(t, it, zipper)); + source.subscribe(new ZipIterableSubscriber<>(t, it, zipper)); } static final class ZipIterableSubscriber implements NbpSubscriber { diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorAll.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorAll.java similarity index 98% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorAll.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorAll.java index 59ce08e8b1..8b3b26daa4 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorAll.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorAll.java @@ -26,7 +26,7 @@ public NbpOperatorAll(Predicate predicate) { @Override public NbpSubscriber apply(NbpSubscriber t) { - return new AllSubscriber(t, predicate); + return new AllSubscriber<>(t, predicate); } static final class AllSubscriber implements NbpSubscriber { diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorAny.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorAny.java similarity index 98% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorAny.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorAny.java index 6d1c75f985..e313ef2a84 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorAny.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorAny.java @@ -25,7 +25,7 @@ public NbpOperatorAny(Predicate predicate) { @Override public NbpSubscriber apply(NbpSubscriber t) { - return new AnySubscriber(t, predicate); + return new AnySubscriber<>(t, predicate); } static final class AnySubscriber implements NbpSubscriber { diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorBuffer.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorBuffer.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorBuffer.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorBuffer.java index e4764febd0..816c92bee3 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorBuffer.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorBuffer.java @@ -37,13 +37,13 @@ public NbpOperatorBuffer(int count, int skip, Supplier bufferSupplier) { @Override public NbpSubscriber apply(NbpSubscriber t) { if (skip == count) { - BufferExactSubscriber bes = new BufferExactSubscriber(t, count, bufferSupplier); + BufferExactSubscriber bes = new BufferExactSubscriber<>(t, count, bufferSupplier); if (bes.createBuffer()) { return bes; } return NbpEmptySubscriber.INSTANCE; } - return new BufferSkipSubscriber(t, count, skip, bufferSupplier); + return new BufferSkipSubscriber<>(t, count, skip, bufferSupplier); } static final class BufferExactSubscriber> implements NbpSubscriber { @@ -155,7 +155,7 @@ public BufferSkipSubscriber(NbpSubscriber actual, int count, int skip this.count = count; this.skip = skip; this.bufferSupplier = bufferSupplier; - this.buffers = new ArrayDeque(); + this.buffers = new ArrayDeque<>(); } @Override diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorBufferBoundary.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorBufferBoundary.java similarity index 94% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorBufferBoundary.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorBufferBoundary.java index 6e287f7e8c..cc8107e0ac 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorBufferBoundary.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorBufferBoundary.java @@ -42,10 +42,10 @@ public NbpOperatorBufferBoundary(NbpObservable bufferOpen, @Override public NbpSubscriber apply(NbpSubscriber t) { - return new BufferBoundarySubscriber( - new NbpSerializedSubscriber(t), - bufferOpen, bufferClose, bufferSupplier - ); + return new BufferBoundarySubscriber<>( + new NbpSerializedSubscriber<>(t), + bufferOpen, bufferClose, bufferSupplier + ); } static final class BufferBoundarySubscriber, Open, Close> @@ -65,12 +65,12 @@ public BufferBoundarySubscriber(NbpSubscriber actual, NbpObservable bufferOpen, Function> bufferClose, Supplier bufferSupplier) { - super(actual, new MpscLinkedQueue()); + super(actual, new MpscLinkedQueue<>()); this.bufferOpen = bufferOpen; this.bufferClose = bufferClose; this.bufferSupplier = bufferSupplier; - this.buffers = new LinkedList(); - this.resources = new SetCompositeResource(Disposables.consumeAndDispose()); + this.buffers = new LinkedList<>(); + this.resources = new SetCompositeResource<>(Disposables.consumeAndDispose()); } @Override public void onSubscribe(Disposable s) { @@ -79,7 +79,7 @@ public void onSubscribe(Disposable s) { } this.s = s; - BufferOpenSubscriber bos = new BufferOpenSubscriber(this); + BufferOpenSubscriber bos = new BufferOpenSubscriber<>(this); resources.add(bos); actual.onSubscribe(this); @@ -117,7 +117,7 @@ public void onComplete() { void complete() { List list; synchronized (this) { - list = new ArrayList(buffers); + list = new ArrayList<>(buffers); buffers.clear(); } @@ -188,7 +188,7 @@ void open(Open window) { buffers.add(b); } - BufferCloseSubscriber bcs = new BufferCloseSubscriber(b, this); + BufferCloseSubscriber bcs = new BufferCloseSubscriber<>(b, this); resources.add(bcs); windows.getAndIncrement(); diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorBufferBoundarySupplier.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorBufferBoundarySupplier.java similarity index 95% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorBufferBoundarySupplier.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorBufferBoundarySupplier.java index f4fc1d9392..eec4685671 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorBufferBoundarySupplier.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorBufferBoundarySupplier.java @@ -39,7 +39,7 @@ public NbpOperatorBufferBoundarySupplier(Supplier> bo @Override public NbpSubscriber apply(NbpSubscriber t) { - return new BufferBondarySupplierSubscriber(new NbpSerializedSubscriber(t), bufferSupplier, boundarySupplier); + return new BufferBondarySupplierSubscriber<>(new NbpSerializedSubscriber<>(t), bufferSupplier, boundarySupplier); } static final class BufferBondarySupplierSubscriber, B> @@ -50,18 +50,15 @@ static final class BufferBondarySupplierSubscriber other = new AtomicReference(); + final AtomicReference other = new AtomicReference<>(); - static final Disposable DISPOSED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable DISPOSED = () -> { }; U buffer; public BufferBondarySupplierSubscriber(NbpSubscriber actual, Supplier bufferSupplier, Supplier> boundarySupplier) { - super(actual, new MpscLinkedQueue()); + super(actual, new MpscLinkedQueue<>()); this.bufferSupplier = bufferSupplier; this.boundarySupplier = boundarySupplier; } @@ -112,7 +109,7 @@ public void onSubscribe(Disposable s) { return; } - BufferBoundarySubscriber bs = new BufferBoundarySubscriber(this); + BufferBoundarySubscriber bs = new BufferBoundarySubscriber<>(this); other.set(bs); actual.onSubscribe(this); @@ -217,7 +214,7 @@ void next() { return; } - BufferBoundarySubscriber bs = new BufferBoundarySubscriber(this); + BufferBoundarySubscriber bs = new BufferBoundarySubscriber<>(this); if (!other.compareAndSet(o, bs)) { return; diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorBufferExactBoundary.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorBufferExactBoundary.java similarity index 96% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorBufferExactBoundary.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorBufferExactBoundary.java index be5b4fa3eb..6e11ac4e3c 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorBufferExactBoundary.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorBufferExactBoundary.java @@ -37,7 +37,7 @@ public NbpOperatorBufferExactBoundary(NbpObservable boundary, Supplier buf @Override public NbpSubscriber apply(NbpSubscriber t) { - return new BufferExactBondarySubscriber(new NbpSerializedSubscriber(t), bufferSupplier, boundary); + return new BufferExactBondarySubscriber<>(new NbpSerializedSubscriber<>(t), bufferSupplier, boundary); } static final class BufferExactBondarySubscriber, B> @@ -54,7 +54,7 @@ static final class BufferExactBondarySubscriber actual, Supplier bufferSupplier, NbpObservable boundary) { - super(actual, new MpscLinkedQueue()); + super(actual, new MpscLinkedQueue<>()); this.bufferSupplier = bufferSupplier; this.boundary = boundary; } @@ -85,7 +85,7 @@ public void onSubscribe(Disposable s) { } buffer = b; - BufferBoundarySubscriber bs = new BufferBoundarySubscriber(this); + BufferBoundarySubscriber bs = new BufferBoundarySubscriber<>(this); other = bs; actual.onSubscribe(this); diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorBufferTimed.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorBufferTimed.java similarity index 91% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorBufferTimed.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorBufferTimed.java index 1529afe21a..b30ca1baf5 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorBufferTimed.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorBufferTimed.java @@ -53,24 +53,24 @@ public NbpOperatorBufferTimed(long timespan, long timeskip, TimeUnit unit, Sched @Override public NbpSubscriber apply(NbpSubscriber t) { if (timespan == timeskip && maxSize == Integer.MAX_VALUE) { - return new BufferExactUnboundedSubscriber( - new NbpSerializedSubscriber(t), - bufferSupplier, timespan, unit, scheduler); + return new BufferExactUnboundedSubscriber<>( + new NbpSerializedSubscriber<>(t), + bufferSupplier, timespan, unit, scheduler); } Scheduler.Worker w = scheduler.createWorker(); if (timespan == timeskip) { - return new BufferExactBoundedSubscriber( - new NbpSerializedSubscriber(t), - bufferSupplier, - timespan, unit, maxSize, restartTimerOnMaxSize, w + return new BufferExactBoundedSubscriber<>( + new NbpSerializedSubscriber<>(t), + bufferSupplier, + timespan, unit, maxSize, restartTimerOnMaxSize, w ); } // Can't use maxSize because what to do if a buffer is full but its // timespan hasn't been elapsed? - return new BufferSkipBoundedSubscriber( - new NbpSerializedSubscriber(t), - bufferSupplier, timespan, timeskip, unit, w); + return new BufferSkipBoundedSubscriber<>( + new NbpSerializedSubscriber<>(t), + bufferSupplier, timespan, timeskip, unit, w); } static final class BufferExactUnboundedSubscriber> @@ -86,17 +86,14 @@ static final class BufferExactUnboundedSubscriber timer = new AtomicReference(); + final AtomicReference timer = new AtomicReference<>(); - static final Disposable CANCELLED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable CANCELLED = () -> { }; public BufferExactUnboundedSubscriber( NbpSubscriber actual, Supplier bufferSupplier, long timespan, TimeUnit unit, Scheduler scheduler) { - super(actual, new MpscLinkedQueue()); + super(actual, new MpscLinkedQueue<>()); this.bufferSupplier = bufferSupplier; this.timespan = timespan; this.unit = unit; @@ -261,13 +258,13 @@ static final class BufferSkipBoundedSubscriber actual, Supplier bufferSupplier, long timespan, long timeskip, TimeUnit unit, Worker w) { - super(actual, new MpscLinkedQueue()); + super(actual, new MpscLinkedQueue<>()); this.bufferSupplier = bufferSupplier; this.timespan = timespan; this.timeskip = timeskip; this.unit = unit; this.w = w; - this.buffers = new LinkedList(); + this.buffers = new LinkedList<>(); } @Override @@ -301,15 +298,12 @@ public void onSubscribe(Disposable s) { w.schedulePeriodically(this, timeskip, timeskip, unit); - w.schedule(new Runnable() { - @Override - public void run() { - synchronized (BufferSkipBoundedSubscriber.this) { - buffers.remove(b); - } - - fastpathOrderedEmit(b, false, w); + w.schedule(() -> { + synchronized (BufferSkipBoundedSubscriber.this) { + buffers.remove(b); } + + fastpathOrderedEmit(b, false, w); }, timespan, unit); } @@ -334,7 +328,7 @@ public void onError(Throwable t) { public void onComplete() { List bs; synchronized (this) { - bs = new ArrayList(buffers); + bs = new ArrayList<>(buffers); buffers.clear(); } @@ -390,15 +384,12 @@ public void run() { buffers.add(b); } - w.schedule(new Runnable() { - @Override - public void run() { - synchronized (BufferSkipBoundedSubscriber.this) { - buffers.remove(b); - } - - fastpathOrderedEmit(b, false, w); + w.schedule(() -> { + synchronized (BufferSkipBoundedSubscriber.this) { + buffers.remove(b); } + + fastpathOrderedEmit(b, false, w); }, timespan, unit); } @@ -432,7 +423,7 @@ public BufferExactBoundedSubscriber( Supplier bufferSupplier, long timespan, TimeUnit unit, int maxSize, boolean restartOnMaxSize, Worker w) { - super(actual, new MpscLinkedQueue()); + super(actual, new MpscLinkedQueue<>()); this.bufferSupplier = bufferSupplier; this.timespan = timespan; this.unit = unit; diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorCollect.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorCollect.java similarity index 98% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorCollect.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorCollect.java index aa90efef3e..c48e1a4502 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorCollect.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorCollect.java @@ -44,7 +44,7 @@ public NbpSubscriber apply(NbpSubscriber t) { return NbpCancelledSubscriber.INSTANCE; } - return new CollectSubscriber(t, u, collector); + return new CollectSubscriber<>(t, u, collector); } static final class CollectSubscriber implements NbpSubscriber { diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorConcatMap.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorConcatMap.java similarity index 96% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorConcatMap.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorConcatMap.java index 84c11cc5c6..f5c2dd2bbc 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorConcatMap.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorConcatMap.java @@ -33,10 +33,10 @@ public NbpOperatorConcatMap(Function apply(NbpSubscriber s) { - NbpSerializedSubscriber ssub = new NbpSerializedSubscriber(s); + NbpSerializedSubscriber ssub = new NbpSerializedSubscriber<>(s); SerialDisposable sa = new SerialDisposable(); ssub.onSubscribe(sa); - return new SourceSubscriber(ssub, sa, mapper, bufferSize); + return new SourceSubscriber<>(ssub, sa, mapper, bufferSize); } static final class SourceSubscriber extends AtomicInteger implements NbpSubscriber { @@ -61,8 +61,8 @@ public SourceSubscriber(NbpSubscriber actual, SerialDisposable sa, this.sa = sa; this.mapper = mapper; this.bufferSize = bufferSize; - this.inner = new InnerSubscriber(actual, sa, this); - this.queue = new SpscLinkedArrayQueue(bufferSize); + this.inner = new InnerSubscriber<>(actual, sa, this); + this.queue = new SpscLinkedArrayQueue<>(bufferSize); } @Override public void onSubscribe(Disposable s) { diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorCount.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorCount.java similarity index 100% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorCount.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorCount.java diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorDebounce.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorDebounce.java similarity index 95% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorDebounce.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorDebounce.java index 771b652d55..3fd9818913 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorDebounce.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorDebounce.java @@ -33,7 +33,7 @@ public NbpOperatorDebounce(Function> debou @Override public NbpSubscriber apply(NbpSubscriber t) { - return new DebounceSubscriber(new NbpSerializedSubscriber(t), debounceSelector); + return new DebounceSubscriber<>(new NbpSerializedSubscriber<>(t), debounceSelector); } static final class DebounceSubscriber @@ -45,12 +45,9 @@ static final class DebounceSubscriber Disposable s; - final AtomicReference debouncer = new AtomicReference(); + final AtomicReference debouncer = new AtomicReference<>(); - static final Disposable CANCELLED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable CANCELLED = () -> { }; volatile long index; @@ -102,7 +99,7 @@ public void onNext(T t) { return; } - DebounceInnerSubscriber dis = new DebounceInnerSubscriber(this, idx, t); + DebounceInnerSubscriber dis = new DebounceInnerSubscriber<>(this, idx, t); if (debouncer.compareAndSet(d, dis)) { p.subscribe(dis); diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorDebounceTimed.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorDebounceTimed.java similarity index 89% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorDebounceTimed.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorDebounceTimed.java index 86193be821..83c741a6f4 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorDebounceTimed.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorDebounceTimed.java @@ -37,9 +37,9 @@ public NbpOperatorDebounceTimed(long timeout, TimeUnit unit, Scheduler scheduler @Override public NbpSubscriber apply(NbpSubscriber t) { - return new DebounceTimedSubscriber( - new NbpSerializedSubscriber(t), - timeout, unit, scheduler.createWorker()); + return new DebounceTimedSubscriber<>( + new NbpSerializedSubscriber<>(t), + timeout, unit, scheduler.createWorker()); } static final class DebounceTimedSubscriber @@ -51,17 +51,11 @@ static final class DebounceTimedSubscriber Disposable s; - final AtomicReference timer = new AtomicReference(); + final AtomicReference timer = new AtomicReference<>(); - static final Disposable CANCELLED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable CANCELLED = () -> { }; - static final Disposable NEW_TIMER = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable NEW_TIMER = () -> { }; volatile long index; @@ -107,7 +101,7 @@ public void onNext(T t) { d.dispose(); } - DebounceEmitter de = new DebounceEmitter(t, idx, this); + DebounceEmitter de = new DebounceEmitter<>(t, idx, this); if (!timer.compareAndSet(d, de)) { return; } @@ -165,10 +159,7 @@ static final class DebounceEmitter extends AtomicReference implem /** */ private static final long serialVersionUID = 6812032969491025141L; - static final Disposable DISPOSED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable DISPOSED = () -> { }; final T value; final long idx; diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorDelay.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorDelay.java similarity index 80% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorDelay.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorDelay.java index 15f909848f..316cc27f00 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorDelay.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorDelay.java @@ -44,12 +44,12 @@ public NbpSubscriber apply(NbpSubscriber t) { if (delayError) { s = (NbpSubscriber)t; } else { - s = new NbpSerializedSubscriber(t); + s = new NbpSerializedSubscriber<>(t); } Scheduler.Worker w = scheduler.createWorker(); - return new DelaySubscriber(s, delay, unit, w, delayError); + return new DelaySubscriber<>(s, delay, unit, w, delayError); } static final class DelaySubscriber implements NbpSubscriber, Disposable { @@ -81,25 +81,17 @@ public void onSubscribe(Disposable s) { @Override public void onNext(final T t) { - w.schedule(new Runnable() { - @Override - public void run() { - actual.onNext(t); - } - }, delay, unit); + w.schedule(() -> actual.onNext(t), delay, unit); } @Override public void onError(final Throwable t) { if (delayError) { - w.schedule(new Runnable() { - @Override - public void run() { - try { - actual.onError(t); - } finally { - w.dispose(); - } + w.schedule(() -> { + try { + actual.onError(t); + } finally { + w.dispose(); } }, delay, unit); } else { @@ -109,14 +101,11 @@ public void run() { @Override public void onComplete() { - w.schedule(new Runnable() { - @Override - public void run() { - try { - actual.onComplete(); - } finally { - w.dispose(); - } + w.schedule(() -> { + try { + actual.onComplete(); + } finally { + w.dispose(); } }, delay, unit); } diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorDematerialize.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorDematerialize.java similarity index 98% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorDematerialize.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorDematerialize.java index 51d11dd8ad..c437a68114 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorDematerialize.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorDematerialize.java @@ -29,7 +29,7 @@ public static NbpOperator>> instance() { @Override public NbpSubscriber>> apply(NbpSubscriber t) { - return new DematerializeSubscriber(t); + return new DematerializeSubscriber<>(t); } static final class DematerializeSubscriber implements NbpSubscriber>> { diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorDistinct.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorDistinct.java similarity index 68% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorDistinct.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorDistinct.java index c75cac9c0b..16791e186d 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorDistinct.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorDistinct.java @@ -34,49 +34,37 @@ public NbpOperatorDistinct(Function keySelector, Supplier NbpOperatorDistinct withCollection(final Function keySelector, final Supplier> collectionSupplier) { - Supplier> p = new Supplier>() { - @Override - public Predicate get() { - final Collection coll = collectionSupplier.get(); - - return new Predicate() { - @Override - public boolean test(K t) { - if (t == null) { - coll.clear(); - return true; - } - return coll.add(t); - } - }; - } + Supplier> p = () -> { + final Collection coll = collectionSupplier.get(); + + return t -> { + if (t == null) { + coll.clear(); + return true; + } + return coll.add(t); + }; }; - return new NbpOperatorDistinct(keySelector, p); + return new NbpOperatorDistinct<>(keySelector, p); } static final NbpOperatorDistinct UNTIL_CHANGED; static { - Supplier> p = new Supplier>() { - @Override - public Predicate get() { - final Object[] last = { null }; - - return new Predicate() { - @Override - public boolean test(Object t) { - if (t == null) { - last[0] = null; - return true; - } - Object o = last[0]; - last[0] = t; - return !Objects.equals(o, t); - } - }; - } + Supplier> p = () -> { + final Object[] last = { null }; + + return t -> { + if (t == null) { + last[0] = null; + return true; + } + Object o = last[0]; + last[0] = t; + return !Objects.equals(o, t); + }; }; - UNTIL_CHANGED = new NbpOperatorDistinct(Functions.identity(), p); + UNTIL_CHANGED = new NbpOperatorDistinct<>(Functions.identity(), p); } @SuppressWarnings("unchecked") @@ -85,26 +73,20 @@ public static NbpOperatorDistinct untilChanged() { } public static NbpOperatorDistinct untilChanged(Function keySelector) { - Supplier> p = new Supplier>() { - @Override - public Predicate get() { - final Object[] last = { null }; - - return new Predicate() { - @Override - public boolean test(K t) { - if (t == null) { - last[0] = null; - return true; - } - Object o = last[0]; - last[0] = t; - return !Objects.equals(o, t); - } - }; - } + Supplier> p = () -> { + final Object[] last = { null }; + + return t -> { + if (t == null) { + last[0] = null; + return true; + } + Object o = last[0]; + last[0] = t; + return !Objects.equals(o, t); + }; }; - return new NbpOperatorDistinct(keySelector, p); + return new NbpOperatorDistinct<>(keySelector, p); } @@ -123,7 +105,7 @@ public NbpSubscriber apply(NbpSubscriber t) { return NbpCancelledSubscriber.INSTANCE; } - return new DistinctSubscriber(t, keySelector, coll); + return new DistinctSubscriber<>(t, keySelector, coll); } static final class DistinctSubscriber implements NbpSubscriber { diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorDoOnEach.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorDoOnEach.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorDoOnEach.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorDoOnEach.java index 4893c95262..44f0e2fbac 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorDoOnEach.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorDoOnEach.java @@ -38,7 +38,7 @@ public NbpOperatorDoOnEach(Consumer onNext, @Override public NbpSubscriber apply(NbpSubscriber t) { - return new DoOnEachSubscriber(t, onNext, onError, onComplete, onAfterTerminate); + return new DoOnEachSubscriber<>(t, onNext, onError, onComplete, onAfterTerminate); } static final class DoOnEachSubscriber implements NbpSubscriber { diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorElementAt.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorElementAt.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorElementAt.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorElementAt.java index 59f38865f9..ff4d415cd4 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorElementAt.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorElementAt.java @@ -26,7 +26,7 @@ public NbpOperatorElementAt(long index, T defaultValue) { } @Override public NbpSubscriber apply(NbpSubscriber t) { - return new ElementAtSubscriber(t, index, defaultValue); + return new ElementAtSubscriber<>(t, index, defaultValue); } static final class ElementAtSubscriber implements NbpSubscriber { diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorFilter.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorFilter.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorFilter.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorFilter.java index 452e45e700..c98a60cc69 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorFilter.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorFilter.java @@ -26,7 +26,7 @@ public NbpOperatorFilter(Predicate predicate) { @Override public NbpSubscriber apply(NbpSubscriber s) { - return new FilterSubscriber(s, predicate); + return new FilterSubscriber<>(s, predicate); } static final class FilterSubscriber implements NbpSubscriber { diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorFlatMap.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorFlatMap.java similarity index 95% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorFlatMap.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorFlatMap.java index 2070d922c3..6b97d8311a 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorFlatMap.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorFlatMap.java @@ -42,7 +42,7 @@ public NbpOperatorFlatMap( @Override public NbpSubscriber apply(NbpSubscriber t) { - return new MergeSubscriber(t, mapper, delayErrors, maxConcurrency, bufferSize); + return new MergeSubscriber<>(t, mapper, delayErrors, maxConcurrency, bufferSize); } static final class MergeSubscriber extends AtomicInteger implements Disposable, NbpSubscriber { @@ -59,9 +59,9 @@ static final class MergeSubscriber extends AtomicInteger implements Dispos volatile boolean done; - final AtomicReference> errors = new AtomicReference>(); + final AtomicReference> errors = new AtomicReference<>(); - static final Queue ERRORS_CLOSED = new RejectingQueue(); + static final Queue ERRORS_CLOSED = new RejectingQueue<>(); volatile boolean cancelled; @@ -89,9 +89,9 @@ public MergeSubscriber(NbpSubscriber actual, Function>(maxConcurrency); + sources = new ArrayDeque<>(maxConcurrency); } - this.subscribers = new AtomicReference[]>(EMPTY); + this.subscribers = new AtomicReference<>(EMPTY); } @Override @@ -135,7 +135,7 @@ public void onNext(T t) { } void subscribeInner(NbpObservable p) { - InnerSubscriber inner = new InnerSubscriber(this, uniqueId++); + InnerSubscriber inner = new InnerSubscriber<>(this, uniqueId++); addInner(inner); p.subscribe(inner); } @@ -192,12 +192,12 @@ Queue getMainQueue() { Queue q = queue; if (q == null) { if (maxConcurrency == Integer.MAX_VALUE) { - q = new SpscLinkedArrayQueue(bufferSize); + q = new SpscLinkedArrayQueue<>(bufferSize); } else { if (Pow2.isPowerOfTwo(maxConcurrency)) { - q = new SpscArrayQueue(maxConcurrency); + q = new SpscArrayQueue<>(maxConcurrency); } else { - q = new SpscExactArrayQueue(maxConcurrency); + q = new SpscExactArrayQueue<>(maxConcurrency); } } queue = q; @@ -227,7 +227,7 @@ void tryEmitScalar(U value) { Queue getInnerQueue(InnerSubscriber inner) { Queue q = inner.queue; if (q == null) { - q = new SpscArrayQueue(bufferSize); + q = new SpscArrayQueue<>(bufferSize); inner.queue = q; } return q; @@ -242,7 +242,7 @@ void tryEmit(U value, InnerSubscriber inner) { } else { Queue q = inner.queue; if (q == null) { - q = new SpscLinkedArrayQueue(bufferSize); + q = new SpscLinkedArrayQueue<>(bufferSize); inner.queue = q; } if (!q.offer(value)) { @@ -493,7 +493,7 @@ Queue getErrorQueue() { if (q != null) { return q; } - q = new MpscLinkedQueue(); + q = new MpscLinkedQueue<>(); if (errors.compareAndSet(null, q)) { return q; } @@ -511,10 +511,7 @@ static final class InnerSubscriber extends AtomicReference volatile boolean done; volatile Queue queue; - static final Disposable CANCELLED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable CANCELLED = () -> { }; public InnerSubscriber(MergeSubscriber parent, long id) { this.id = id; diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorGroupBy.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorGroupBy.java similarity index 94% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorGroupBy.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorGroupBy.java index ef83b95ec5..3e1b2ee3bd 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorGroupBy.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorGroupBy.java @@ -40,7 +40,7 @@ public NbpOperatorGroupBy(Function keySelector, Function @Override public NbpSubscriber apply(NbpSubscriber> t) { - return new GroupBySubscriber(t, keySelector, valueSelector, bufferSize, delayError); + return new GroupBySubscriber<>(t, keySelector, valueSelector, bufferSize, delayError); } public static final class GroupBySubscriber extends AtomicInteger implements NbpSubscriber, Disposable { @@ -66,7 +66,7 @@ public GroupBySubscriber(NbpSubscriber> actua this.valueSelector = valueSelector; this.bufferSize = bufferSize; this.delayError = delayError; - this.groups = new ConcurrentHashMap>(); + this.groups = new ConcurrentHashMap<>(); this.lazySet(1); } @@ -128,7 +128,7 @@ public void onNext(T t) { @Override public void onError(Throwable t) { - List> list = new ArrayList>(groups.values()); + List> list = new ArrayList<>(groups.values()); groups.clear(); for (GroupedUnicast e : list) { @@ -140,7 +140,7 @@ public void onError(Throwable t) { @Override public void onComplete() { - List> list = new ArrayList>(groups.values()); + List> list = new ArrayList<>(groups.values()); groups.clear(); for (GroupedUnicast e : list) { @@ -173,8 +173,8 @@ public void cancel(K key) { static final class GroupedUnicast extends NbpGroupedObservable { public static GroupedUnicast createWith(K key, int bufferSize, GroupBySubscriber parent, boolean delayError) { - State state = new State(bufferSize, parent, key, delayError); - return new GroupedUnicast(key, state); + State state = new State<>(bufferSize, parent, key, delayError); + return new GroupedUnicast<>(key, state); } final State state; @@ -211,10 +211,10 @@ static final class State extends AtomicInteger implements Disposable, NbpO final AtomicBoolean cancelled = new AtomicBoolean(); - final AtomicReference> actual = new AtomicReference>(); + final AtomicReference> actual = new AtomicReference<>(); public State(int bufferSize, GroupBySubscriber parent, K key, boolean delayError) { - this.queue = new SpscLinkedArrayQueue(bufferSize); + this.queue = new SpscLinkedArrayQueue<>(bufferSize); this.parent = parent; this.key = key; this.delayError = delayError; diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorIgnoreElements.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorIgnoreElements.java similarity index 100% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorIgnoreElements.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorIgnoreElements.java diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorMap.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorMap.java similarity index 98% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorMap.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorMap.java index 184920affe..25314ebda5 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorMap.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorMap.java @@ -29,7 +29,7 @@ public NbpOperatorMap(Function function) { @Override public NbpSubscriber apply(NbpSubscriber t) { - return new MapperSubscriber(t, function); + return new MapperSubscriber<>(t, function); } static final class MapperSubscriber implements NbpSubscriber { diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorMapNotification.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorMapNotification.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorMapNotification.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorMapNotification.java index b9597c033e..14580e7e4d 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorMapNotification.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorMapNotification.java @@ -35,7 +35,7 @@ public NbpOperatorMapNotification(Function apply(NbpSubscriber> t) { - return new MapNotificationSubscriber(t, onNextMapper, onErrorMapper, onCompleteSupplier); + return new MapNotificationSubscriber<>(t, onNextMapper, onErrorMapper, onCompleteSupplier); } static final class MapNotificationSubscriber diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorMaterialize.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorMaterialize.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorMaterialize.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorMaterialize.java index 94087b7ae8..afeb3f83a5 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorMaterialize.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorMaterialize.java @@ -28,7 +28,7 @@ public static NbpOperator>, T> instance() { @Override public NbpSubscriber apply(NbpSubscriber>> t) { - return new MaterializeSubscriber(t); + return new MaterializeSubscriber<>(t); } static final class MaterializeSubscriber implements NbpSubscriber { diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorObserveOn.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorObserveOn.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorObserveOn.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorObserveOn.java index aa3892f991..28c83a309d 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorObserveOn.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorObserveOn.java @@ -43,7 +43,7 @@ public NbpSubscriber apply(NbpSubscriber t) { Scheduler.Worker w = scheduler.createWorker(); - return new ObserveOnSubscriber(t, w, delayError, bufferSize); + return new ObserveOnSubscriber<>(t, w, delayError, bufferSize); } /** @@ -78,7 +78,7 @@ public ObserveOnSubscriber(NbpSubscriber actual, Scheduler.Worker wor this.worker = worker; this.delayError = delayError; this.bufferSize = bufferSize; - this.queue = new SpscLinkedArrayQueue(bufferSize); + this.queue = new SpscLinkedArrayQueue<>(bufferSize); } @Override diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorOnErrorNext.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorOnErrorNext.java similarity index 99% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorOnErrorNext.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorOnErrorNext.java index 3a28e0de91..3ff9e6281b 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorOnErrorNext.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorOnErrorNext.java @@ -31,7 +31,7 @@ public NbpOperatorOnErrorNext(Function apply(NbpSubscriber t) { - OnErrorNextSubscriber parent = new OnErrorNextSubscriber(t, nextSupplier, allowFatal); + OnErrorNextSubscriber parent = new OnErrorNextSubscriber<>(t, nextSupplier, allowFatal); t.onSubscribe(parent.arbiter); return parent; } diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorOnErrorReturn.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorOnErrorReturn.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorOnErrorReturn.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorOnErrorReturn.java index 5b98d1c494..2ca2c24617 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorOnErrorReturn.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorOnErrorReturn.java @@ -27,7 +27,7 @@ public NbpOperatorOnErrorReturn(Function valueSu @Override public NbpSubscriber apply(NbpSubscriber t) { - return new OnErrorReturnSubscriber(t, valueSupplier); + return new OnErrorReturnSubscriber<>(t, valueSupplier); } static final class OnErrorReturnSubscriber implements NbpSubscriber { diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorPublish.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorPublish.java similarity index 85% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorPublish.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorPublish.java index 3dd15f15b0..0669af1a00 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorPublish.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorPublish.java @@ -47,92 +47,81 @@ public final class NbpOperatorPublish extends NbpConnectableObservable { */ public static NbpConnectableObservable create(NbpObservable source, final int bufferSize) { // the current connection to source needs to be shared between the operator and its onSubscribe call - final AtomicReference> curr = new AtomicReference>(); - NbpOnSubscribe onSubscribe = new NbpOnSubscribe() { - @Override - public void accept(NbpSubscriber child) { - // concurrent connection/disconnection may change the state, - // we loop to be atomic while the child subscribes - for (;;) { - // get the current subscriber-to-source - PublishSubscriber r = curr.get(); - // if there isn't one or it is unsubscribed - if (r == null || r.isDisposed()) { - // create a new subscriber to source - PublishSubscriber u = new PublishSubscriber(curr, bufferSize); - // let's try setting it as the current subscriber-to-source - if (!curr.compareAndSet(r, u)) { - // didn't work, maybe someone else did it or the current subscriber - // to source has just finished - continue; - } - // we won, let's use it going onwards - r = u; + final AtomicReference> curr = new AtomicReference<>(); + NbpOnSubscribe onSubscribe = child -> { + // concurrent connection/disconnection may change the state, + // we loop to be atomic while the child subscribes + for (;;) { + // get the current subscriber-to-source + PublishSubscriber r = curr.get(); + // if there isn't one or it is unsubscribed + if (r == null || r.isDisposed()) { + // create a new subscriber to source + PublishSubscriber u = new PublishSubscriber<>(curr, bufferSize); + // let's try setting it as the current subscriber-to-source + if (!curr.compareAndSet(r, u)) { + // didn't work, maybe someone else did it or the current subscriber + // to source has just finished + continue; } - - // create the backpressure-managing producer for this child - InnerProducer inner = new InnerProducer(r, child); + // we won, let's use it going onwards + r = u; + } + + // create the backpressure-managing producer for this child + InnerProducer inner = new InnerProducer<>(r, child); + /* + * Try adding it to the current subscriber-to-source, add is atomic in respect + * to other adds and the termination of the subscriber-to-source. + */ + if (!r.add(inner)) { /* - * Try adding it to the current subscriber-to-source, add is atomic in respect - * to other adds and the termination of the subscriber-to-source. + * The current PublishSubscriber has been terminated, try with a newer one. + */ + continue; + /* + * Note: although technically corrent, concurrent disconnects can cause + * unexpected behavior such as child subscribers never receiving anything + * (unless connected again). An alternative approach, similar to + * PublishSubject would be to immediately terminate such child + * subscribers as well: + * + * Object term = r.terminalEvent; + * if (r.nl.isCompleted(term)) { + * child.onCompleted(); + * } else { + * child.onError(r.nl.getError(term)); + * } + * return; + * + * The original concurrent behavior was non-deterministic in this regard as well. + * Allowing this behavior, however, may introduce another unexpected behavior: + * after disconnecting a previous connection, one might not be able to prepare + * a new connection right after a previous termination by subscribing new child + * subscribers asynchronously before a connect call. */ - if (!r.add(inner)) { - /* - * The current PublishSubscriber has been terminated, try with a newer one. - */ - continue; - /* - * Note: although technically corrent, concurrent disconnects can cause - * unexpected behavior such as child subscribers never receiving anything - * (unless connected again). An alternative approach, similar to - * PublishSubject would be to immediately terminate such child - * subscribers as well: - * - * Object term = r.terminalEvent; - * if (r.nl.isCompleted(term)) { - * child.onCompleted(); - * } else { - * child.onError(r.nl.getError(term)); - * } - * return; - * - * The original concurrent behavior was non-deterministic in this regard as well. - * Allowing this behavior, however, may introduce another unexpected behavior: - * after disconnecting a previous connection, one might not be able to prepare - * a new connection right after a previous termination by subscribing new child - * subscribers asynchronously before a connect call. - */ - } - // the producer has been registered with the current subscriber-to-source so - // at least it will receive the next terminal event - // setting the producer will trigger the first request to be considered by - // the subscriber-to-source. - child.onSubscribe(inner); - break; } + // the producer has been registered with the current subscriber-to-source so + // at least it will receive the next terminal event + // setting the producer will trigger the first request to be considered by + // the subscriber-to-source. + child.onSubscribe(inner); + break; } }; - return new NbpOperatorPublish(onSubscribe, source, curr, bufferSize); + return new NbpOperatorPublish<>(onSubscribe, source, curr, bufferSize); } public static NbpObservable create(final NbpObservable source, final Function, ? extends NbpObservable> selector, final int bufferSize) { - return create(new NbpOnSubscribe() { - @Override - public void accept(NbpSubscriber sr) { - NbpConnectableObservable op = create(source, bufferSize); - - final NbpSubscriberResourceWrapper srw = new NbpSubscriberResourceWrapper(sr, Disposables.consumeAndDispose()); - - selector.apply(op).subscribe(srw); - - op.connect(new Consumer() { - @Override - public void accept(Disposable r) { - srw.setResource(r); - } - }); - } + return create(sr -> { + NbpConnectableObservable op = create(source, bufferSize); + + final NbpSubscriberResourceWrapper srw = new NbpSubscriberResourceWrapper<>(sr, Disposables.consumeAndDispose()); + + selector.apply(op).subscribe(srw); + + op.connect(srw::setResource); }); } @@ -155,7 +144,7 @@ public void connect(Consumer connection) { // if there is none yet or the current has unsubscribed if (ps == null || ps.isDisposed()) { // create a new subscriber-to-source - PublishSubscriber u = new PublishSubscriber(current, bufferSize); + PublishSubscriber u = new PublishSubscriber<>(current, bufferSize); // try setting it as the current subscriber-to-source if (!current.compareAndSet(ps, u)) { // did not work, perhaps a new subscriber arrived @@ -217,17 +206,14 @@ static final class PublishSubscriber implements NbpSubscriber, Disposable /** Guarded by this. */ boolean missed; - final AtomicReference s = new AtomicReference(); + final AtomicReference s = new AtomicReference<>(); - static final Disposable CANCELLED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable CANCELLED = () -> { }; public PublishSubscriber(AtomicReference> current, int bufferSize) { - this.queue = new SpscArrayQueue(bufferSize); + this.queue = new SpscArrayQueue<>(bufferSize); - this.producers = new AtomicReference(EMPTY); + this.producers = new AtomicReference<>(EMPTY); this.current = current; this.shouldConnect = new AtomicBoolean(); this.bufferSize = bufferSize; diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorReplay.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorReplay.java similarity index 87% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorReplay.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorReplay.java index 9957bda3e2..68ce294d56 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorReplay.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorReplay.java @@ -35,12 +35,7 @@ public final class NbpOperatorReplay extends NbpConnectableObservable { final Supplier> bufferFactory; @SuppressWarnings("rawtypes") - static final Supplier DEFAULT_UNBOUNDED_FACTORY = new Supplier() { - @Override - public Object get() { - return new UnboundedReplayBuffer(16); - } - }; + static final Supplier DEFAULT_UNBOUNDED_FACTORY = () -> new UnboundedReplayBuffer<>(16); /** * Given a connectable observable factory, it multicasts over the generated @@ -54,30 +49,22 @@ public Object get() { public static NbpObservable multicastSelector( final Supplier> connectableFactory, final Function, ? extends NbpObservable> selector) { - return NbpObservable.create(new NbpOnSubscribe() { - @Override - public void accept(NbpSubscriber child) { - NbpConnectableObservable co; - NbpObservable observable; - try { - co = connectableFactory.get(); - observable = selector.apply(co); - } catch (Throwable e) { - EmptyDisposable.error(e, child); - return; - } - - final NbpSubscriberResourceWrapper srw = new NbpSubscriberResourceWrapper(child, Disposables.consumeAndDispose()); - - observable.subscribe(srw); - - co.connect(new Consumer() { - @Override - public void accept(Disposable r) { - srw.setResource(r); - } - }); + return NbpObservable.create(child -> { + NbpConnectableObservable co; + NbpObservable observable; + try { + co = connectableFactory.get(); + observable = selector.apply(co); + } catch (Throwable e) { + EmptyDisposable.error(e, child); + return; } + + final NbpSubscriberResourceWrapper srw = new NbpSubscriberResourceWrapper<>(child, Disposables.consumeAndDispose()); + + observable.subscribe(srw); + + co.connect(srw::setResource); }); } @@ -91,12 +78,7 @@ public void accept(Disposable r) { */ public static NbpConnectableObservable observeOn(final NbpConnectableObservable co, final Scheduler scheduler) { final NbpObservable observable = co.observeOn(scheduler); - return new NbpConnectableObservable(new NbpOnSubscribe() { - @Override - public void accept(NbpSubscriber s) { - observable.subscribe(s); - } - }) { + return new NbpConnectableObservable(observable::subscribe) { @Override public void connect(Consumer connection) { co.connect(connection); @@ -127,12 +109,7 @@ public static NbpConnectableObservable create(NbpObservable if (bufferSize == Integer.MAX_VALUE) { return createFrom(source); } - return create(source, new Supplier>() { - @Override - public ReplayBuffer get() { - return new SizeBoundReplayBuffer(bufferSize); - } - }); + return create(source, () -> new SizeBoundReplayBuffer<>(bufferSize)); } /** @@ -161,12 +138,7 @@ public static NbpConnectableObservable create(NbpObservable */ public static NbpConnectableObservable create(NbpObservable source, final long maxAge, final TimeUnit unit, final Scheduler scheduler, final int bufferSize) { - return create(source, new Supplier>() { - @Override - public ReplayBuffer get() { - return new SizeAndTimeBoundReplayBuffer(bufferSize, maxAge, unit, scheduler); - } - }); + return create(source, () -> new SizeAndTimeBoundReplayBuffer<>(bufferSize, maxAge, unit, scheduler)); } /** @@ -178,49 +150,46 @@ public ReplayBuffer get() { static NbpConnectableObservable create(NbpObservable source, final Supplier> bufferFactory) { // the current connection to source needs to be shared between the operator and its onSubscribe call - final AtomicReference> curr = new AtomicReference>(); - NbpOnSubscribe onSubscribe = new NbpOnSubscribe() { - @Override - public void accept(NbpSubscriber child) { - // concurrent connection/disconnection may change the state, - // we loop to be atomic while the child subscribes - for (;;) { - // get the current subscriber-to-source - ReplaySubscriber r = curr.get(); - // if there isn't one - if (r == null) { - // create a new subscriber to source - ReplaySubscriber u = new ReplaySubscriber(curr, bufferFactory.get()); - // let's try setting it as the current subscriber-to-source - if (!curr.compareAndSet(r, u)) { - // didn't work, maybe someone else did it or the current subscriber - // to source has just finished - continue; - } - // we won, let's use it going onwards - r = u; + final AtomicReference> curr = new AtomicReference<>(); + NbpOnSubscribe onSubscribe = child -> { + // concurrent connection/disconnection may change the state, + // we loop to be atomic while the child subscribes + for (;;) { + // get the current subscriber-to-source + ReplaySubscriber r = curr.get(); + // if there isn't one + if (r == null) { + // create a new subscriber to source + ReplaySubscriber u = new ReplaySubscriber<>(curr, bufferFactory.get()); + // let's try setting it as the current subscriber-to-source + if (!curr.compareAndSet(r, u)) { + // didn't work, maybe someone else did it or the current subscriber + // to source has just finished + continue; } - - // create the backpressure-managing producer for this child - InnerSubscription inner = new InnerSubscription(r, child); - // we try to add it to the array of producers - // if it fails, no worries because we will still have its buffer - // so it is going to replay it for us - r.add(inner); - // the producer has been registered with the current subscriber-to-source so - // at least it will receive the next terminal event - // setting the producer will trigger the first request to be considered by - // the subscriber-to-source. - child.onSubscribe(inner); - - // replay the contents of the buffer - r.buffer.replay(inner); - - break; + // we won, let's use it going onwards + r = u; } + + // create the backpressure-managing producer for this child + InnerSubscription inner = new InnerSubscription<>(r, child); + // we try to add it to the array of producers + // if it fails, no worries because we will still have its buffer + // so it is going to replay it for us + r.add(inner); + // the producer has been registered with the current subscriber-to-source so + // at least it will receive the next terminal event + // setting the producer will trigger the first request to be considered by + // the subscriber-to-source. + child.onSubscribe(inner); + + // replay the contents of the buffer + r.buffer.replay(inner); + + break; } }; - return new NbpOperatorReplay(onSubscribe, source, curr, bufferFactory); + return new NbpOperatorReplay<>(onSubscribe, source, curr, bufferFactory); } private NbpOperatorReplay(NbpOnSubscribe onSubscribe, NbpObservable source, final AtomicReference> current, @@ -242,7 +211,7 @@ public void connect(Consumer connection) { // if there is none yet or the current has unsubscribed if (ps == null || ps.isDisposed()) { // create a new subscriber-to-source - ReplaySubscriber u = new ReplaySubscriber(current, bufferFactory.get()); + ReplaySubscriber u = new ReplaySubscriber<>(current, bufferFactory.get()); // try setting it as the current subscriber-to-source if (!current.compareAndSet(ps, u)) { // did not work, perhaps a new subscriber arrived @@ -311,7 +280,7 @@ public ReplaySubscriber(AtomicReference> current, ReplayBuffer buffer) { this.buffer = buffer; - this.producers = new AtomicReference(EMPTY); + this.producers = new AtomicReference<>(EMPTY); this.shouldConnect = new AtomicBoolean(); } @@ -600,7 +569,7 @@ public void replay(InnerSubscription output) { int sourceIndex = size; Integer destIndexObject = output.index(); - int destIndex = destIndexObject != null ? destIndexObject.intValue() : 0; + int destIndex = destIndexObject != null ? destIndexObject : 0; while (destIndex < sourceIndex) { Object o = get(destIndex); @@ -892,7 +861,7 @@ public SizeAndTimeBoundReplayBuffer(int limit, long maxAge, TimeUnit unit, Sched @Override Object enterTransform(Object value) { - return new Timed(value, scheduler.now(unit), unit); + return new Timed<>(value, scheduler.now(unit), unit); } @Override diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSampleTimed.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSampleTimed.java similarity index 93% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSampleTimed.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSampleTimed.java index 57c2d0f026..669268581d 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSampleTimed.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSampleTimed.java @@ -36,8 +36,8 @@ public NbpOperatorSampleTimed(long period, TimeUnit unit, Scheduler scheduler) { @Override public NbpSubscriber apply(NbpSubscriber t) { - NbpSerializedSubscriber serial = new NbpSerializedSubscriber(t); - return new SampleTimedSubscriber(serial, period, unit, scheduler); + NbpSerializedSubscriber serial = new NbpSerializedSubscriber<>(t); + return new SampleTimedSubscriber<>(serial, period, unit, scheduler); } static final class SampleTimedSubscriber extends AtomicReference implements NbpSubscriber, Disposable, Runnable { @@ -49,12 +49,9 @@ static final class SampleTimedSubscriber extends AtomicReference implement final TimeUnit unit; final Scheduler scheduler; - final AtomicReference timer = new AtomicReference(); + final AtomicReference timer = new AtomicReference<>(); - static final Disposable DISPOSED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable DISPOSED = () -> { }; Disposable s; diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSampleWithObservable.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSampleWithObservable.java similarity index 93% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSampleWithObservable.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSampleWithObservable.java index 5f7f6d2b7a..5afa391b07 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSampleWithObservable.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSampleWithObservable.java @@ -30,8 +30,8 @@ public NbpOperatorSampleWithObservable(NbpObservable other) { @Override public NbpSubscriber apply(NbpSubscriber t) { - NbpSerializedSubscriber serial = new NbpSerializedSubscriber(t); - return new SamplePublisherSubscriber(serial, other); + NbpSerializedSubscriber serial = new NbpSerializedSubscriber<>(t); + return new SamplePublisherSubscriber<>(serial, other); } static final class SamplePublisherSubscriber extends AtomicReference @@ -42,12 +42,9 @@ static final class SamplePublisherSubscriber extends AtomicReference final NbpSubscriber actual; final NbpObservable sampler; - final AtomicReference other = new AtomicReference(); + final AtomicReference other = new AtomicReference<>(); - static final Disposable CANCELLED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable CANCELLED = () -> { }; Disposable s; @@ -65,7 +62,7 @@ public void onSubscribe(Disposable s) { this.s = s; actual.onSubscribe(this); if (other.get() == null) { - sampler.subscribe(new SamplerSubscriber(this)); + sampler.subscribe(new SamplerSubscriber<>(this)); } } diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorScan.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorScan.java similarity index 98% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorScan.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorScan.java index 5924b01b8c..0bd93a68fd 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorScan.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorScan.java @@ -26,7 +26,7 @@ public NbpOperatorScan(BiFunction accumulator) { @Override public NbpSubscriber apply(NbpSubscriber t) { - return new ScanSubscriber(t, accumulator); + return new ScanSubscriber<>(t, accumulator); } static final class ScanSubscriber implements NbpSubscriber { diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorScanSeed.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorScanSeed.java similarity index 98% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorScanSeed.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorScanSeed.java index 2fadf90762..31f7f4f007 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorScanSeed.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorScanSeed.java @@ -45,7 +45,7 @@ public NbpSubscriber apply(NbpSubscriber t) { return NbpEmptySubscriber.INSTANCE; } - return new ScanSeedSubscriber(t, accumulator, r); + return new ScanSeedSubscriber<>(t, accumulator, r); } static final class ScanSeedSubscriber implements NbpSubscriber { diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSingle.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSingle.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSingle.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSingle.java index eae65a92db..aa1f71b1c7 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSingle.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSingle.java @@ -21,7 +21,7 @@ public final class NbpOperatorSingle implements NbpOperator { - static final NbpOperatorSingle NO_DEFAULT = new NbpOperatorSingle(null); + static final NbpOperatorSingle NO_DEFAULT = new NbpOperatorSingle<>(null); @SuppressWarnings("unchecked") public static NbpOperatorSingle instanceNoDefault() { @@ -34,7 +34,7 @@ public NbpOperatorSingle(T defaultValue) { } @Override public NbpSubscriber apply(NbpSubscriber t) { - return new SingleElementSubscriber(t, defaultValue); + return new SingleElementSubscriber<>(t, defaultValue); } static final class SingleElementSubscriber implements NbpSubscriber { diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSkip.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSkip.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSkip.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSkip.java index d6efda8e92..0e85264b2a 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSkip.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSkip.java @@ -24,7 +24,7 @@ public NbpOperatorSkip(long n) { @Override public NbpSubscriber apply(NbpSubscriber s) { - return new SkipSubscriber(s, n); + return new SkipSubscriber<>(s, n); } static final class SkipSubscriber implements NbpSubscriber { diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipLast.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipLast.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipLast.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipLast.java index 6676d83bec..4013b37a2f 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipLast.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipLast.java @@ -27,7 +27,7 @@ public NbpOperatorSkipLast(int skip) { @Override public NbpSubscriber apply(NbpSubscriber s) { - return new SkipLastSubscriber(s, skip); + return new SkipLastSubscriber<>(s, skip); } static final class SkipLastSubscriber extends ArrayDeque implements NbpSubscriber { diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipLastTimed.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipLastTimed.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipLastTimed.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipLastTimed.java index 77c9975f91..89f552c1b3 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipLastTimed.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipLastTimed.java @@ -39,7 +39,7 @@ public NbpOperatorSkipLastTimed(long time, TimeUnit unit, Scheduler scheduler, i @Override public NbpSubscriber apply(NbpSubscriber t) { - return new SkipLastTimedSubscriber(t, time, unit, scheduler, bufferSize, delayError); + return new SkipLastTimedSubscriber<>(t, time, unit, scheduler, bufferSize, delayError); } static final class SkipLastTimedSubscriber extends AtomicInteger implements NbpSubscriber, Disposable { @@ -64,7 +64,7 @@ public SkipLastTimedSubscriber(NbpSubscriber actual, long time, TimeU this.time = time; this.unit = unit; this.scheduler = scheduler; - this.queue = new SpscLinkedArrayQueue(bufferSize); + this.queue = new SpscLinkedArrayQueue<>(bufferSize); this.delayError = delayError; } diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipUntil.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipUntil.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipUntil.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipUntil.java index 95315678e6..4e93497976 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipUntil.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipUntil.java @@ -31,11 +31,11 @@ public NbpOperatorSkipUntil(NbpObservable other) { @Override public NbpSubscriber apply(NbpSubscriber child) { - final NbpSerializedSubscriber serial = new NbpSerializedSubscriber(child); + final NbpSerializedSubscriber serial = new NbpSerializedSubscriber<>(child); - final ArrayCompositeResource frc = new ArrayCompositeResource(2, Disposables.consumeAndDispose()); + final ArrayCompositeResource frc = new ArrayCompositeResource<>(2, Disposables.consumeAndDispose()); - final SkipUntilSubscriber sus = new SkipUntilSubscriber(serial, frc); + final SkipUntilSubscriber sus = new SkipUntilSubscriber<>(serial, frc); other.subscribe(new NbpSubscriber() { Disposable s; diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipWhile.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipWhile.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipWhile.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipWhile.java index 8798fc58eb..7a0ec77b56 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipWhile.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipWhile.java @@ -26,7 +26,7 @@ public NbpOperatorSkipWhile(Predicate predicate) { @Override public NbpSubscriber apply(NbpSubscriber s) { - return new SkipWhileSubscriber(s, predicate); + return new SkipWhileSubscriber<>(s, predicate); } static final class SkipWhileSubscriber implements NbpSubscriber { diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSwitchIfEmpty.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSwitchIfEmpty.java similarity index 99% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSwitchIfEmpty.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSwitchIfEmpty.java index 82dddbdd4e..c638a6a527 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSwitchIfEmpty.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSwitchIfEmpty.java @@ -25,7 +25,7 @@ public NbpOperatorSwitchIfEmpty(NbpObservable other) { @Override public NbpSubscriber apply(NbpSubscriber t) { - SwitchIfEmptySubscriber parent = new SwitchIfEmptySubscriber(t, other); + SwitchIfEmptySubscriber parent = new SwitchIfEmptySubscriber<>(t, other); t.onSubscribe(parent.arbiter); return parent; } diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSwitchMap.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSwitchMap.java similarity index 95% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSwitchMap.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSwitchMap.java index a339640271..b013f6528d 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSwitchMap.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorSwitchMap.java @@ -38,7 +38,7 @@ public NbpOperatorSwitchMap(Function apply(NbpSubscriber t) { - return new SwitchMapSubscriber(t, mapper, bufferSize); + return new SwitchMapSubscriber<>(t, mapper, bufferSize); } static final class SwitchMapSubscriber extends AtomicInteger implements NbpSubscriber, Disposable { @@ -56,11 +56,11 @@ static final class SwitchMapSubscriber extends AtomicInteger implements Nb Disposable s; - final AtomicReference> active = new AtomicReference>(); + final AtomicReference> active = new AtomicReference<>(); static final SwitchMapInnerSubscriber CANCELLED; static { - CANCELLED = new SwitchMapInnerSubscriber(null, -1L, 1); + CANCELLED = new SwitchMapInnerSubscriber<>(null, -1L, 1); CANCELLED.cancel(); } @@ -106,7 +106,7 @@ public void onNext(T t) { return; } - SwitchMapInnerSubscriber nextInner = new SwitchMapInnerSubscriber(this, c, bufferSize); + SwitchMapInnerSubscriber nextInner = new SwitchMapInnerSubscriber<>(this, c, bufferSize); for (;;) { inner = active.get(); @@ -290,10 +290,7 @@ static final class SwitchMapInnerSubscriber extends AtomicReference { }; public SwitchMapInnerSubscriber(SwitchMapSubscriber parent, long index, int bufferSize) { this.parent = parent; @@ -301,9 +298,9 @@ public SwitchMapInnerSubscriber(SwitchMapSubscriber parent, long index, in this.bufferSize = bufferSize; Queue q; if (Pow2.isPowerOfTwo(bufferSize)) { - q = new SpscArrayQueue(bufferSize); + q = new SpscArrayQueue<>(bufferSize); } else { - q = new SpscExactArrayQueue(bufferSize); + q = new SpscExactArrayQueue<>(bufferSize); } this.queue = q; } diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTake.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTake.java similarity index 98% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTake.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTake.java index f12cce772c..f6fef88dd9 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTake.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTake.java @@ -25,7 +25,7 @@ public NbpOperatorTake(long limit) { @Override public NbpSubscriber apply(NbpSubscriber t) { - return new TakeSubscriber(t, limit); + return new TakeSubscriber<>(t, limit); } static final class TakeSubscriber implements NbpSubscriber { diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeLast.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeLast.java similarity index 98% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeLast.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeLast.java index 91802515c6..0c2f33f5f2 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeLast.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeLast.java @@ -28,7 +28,7 @@ public NbpOperatorTakeLast(int count) { @Override public NbpSubscriber apply(NbpSubscriber t) { - return new TakeLastSubscriber(t, count); + return new TakeLastSubscriber<>(t, count); } static final class TakeLastSubscriber extends ArrayDeque implements NbpSubscriber, Disposable { diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeLastOne.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeLastOne.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeLastOne.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeLastOne.java index 587ec0f84e..dd986eb384 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeLastOne.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeLastOne.java @@ -27,7 +27,7 @@ public static NbpOperator instance() { @Override public NbpSubscriber apply(NbpSubscriber s) { - return new TakeLastOneSubscriber(s); + return new TakeLastOneSubscriber<>(s); } static final class TakeLastOneSubscriber implements NbpSubscriber, Disposable { diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeLastTimed.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeLastTimed.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeLastTimed.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeLastTimed.java index 404de39b66..6c3bd41020 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeLastTimed.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeLastTimed.java @@ -42,7 +42,7 @@ public NbpOperatorTakeLastTimed(long count, long time, TimeUnit unit, Scheduler @Override public NbpSubscriber apply(NbpSubscriber t) { - return new TakeLastTimedSubscriber(t, count, time, unit, scheduler, bufferSize, delayError); + return new TakeLastTimedSubscriber<>(t, count, time, unit, scheduler, bufferSize, delayError); } static final class TakeLastTimedSubscriber extends AtomicInteger implements NbpSubscriber, Disposable { @@ -69,7 +69,7 @@ public TakeLastTimedSubscriber(NbpSubscriber actual, long count, long this.time = time; this.unit = unit; this.scheduler = scheduler; - this.queue = new SpscLinkedArrayQueue(bufferSize); + this.queue = new SpscLinkedArrayQueue<>(bufferSize); this.delayError = delayError; } diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeUntil.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeUntil.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeUntil.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeUntil.java index fc9e998a22..d9906c217c 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeUntil.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeUntil.java @@ -29,11 +29,11 @@ public NbpOperatorTakeUntil(NbpObservable other) { } @Override public NbpSubscriber apply(NbpSubscriber child) { - final NbpSerializedSubscriber serial = new NbpSerializedSubscriber(child); + final NbpSerializedSubscriber serial = new NbpSerializedSubscriber<>(child); - final ArrayCompositeResource frc = new ArrayCompositeResource(2, Disposables.consumeAndDispose()); + final ArrayCompositeResource frc = new ArrayCompositeResource<>(2, Disposables.consumeAndDispose()); - final TakeUntilSubscriber tus = new TakeUntilSubscriber(serial, frc); + final TakeUntilSubscriber tus = new TakeUntilSubscriber<>(serial, frc); other.subscribe(new NbpSubscriber() { @Override diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeUntilPredicate.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeUntilPredicate.java similarity index 98% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeUntilPredicate.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeUntilPredicate.java index 090554a076..7c015c65d9 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeUntilPredicate.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeUntilPredicate.java @@ -26,7 +26,7 @@ public NbpOperatorTakeUntilPredicate(Predicate predicate) { @Override public NbpSubscriber apply(NbpSubscriber s) { - return new InnerSubscriber(s, predicate); + return new InnerSubscriber<>(s, predicate); } static final class InnerSubscriber implements NbpSubscriber { diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeWhile.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeWhile.java similarity index 98% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeWhile.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeWhile.java index 474edae06f..9ef67eb090 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeWhile.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeWhile.java @@ -26,7 +26,7 @@ public NbpOperatorTakeWhile(Predicate predicate) { @Override public NbpSubscriber apply(NbpSubscriber t) { - return new TakeWhileSubscriber(t, predicate); + return new TakeWhileSubscriber<>(t, predicate); } static final class TakeWhileSubscriber implements NbpSubscriber { diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorThrottleFirstTimed.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorThrottleFirstTimed.java similarity index 90% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorThrottleFirstTimed.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorThrottleFirstTimed.java index 609b5b5786..bd88bdcaca 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorThrottleFirstTimed.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorThrottleFirstTimed.java @@ -37,9 +37,9 @@ public NbpOperatorThrottleFirstTimed(long timeout, TimeUnit unit, Scheduler sche @Override public NbpSubscriber apply(NbpSubscriber t) { - return new DebounceTimedSubscriber( - new NbpSerializedSubscriber(t), - timeout, unit, scheduler.createWorker()); + return new DebounceTimedSubscriber<>( + new NbpSerializedSubscriber<>(t), + timeout, unit, scheduler.createWorker()); } static final class DebounceTimedSubscriber @@ -51,17 +51,11 @@ static final class DebounceTimedSubscriber Disposable s; - final AtomicReference timer = new AtomicReference(); + final AtomicReference timer = new AtomicReference<>(); - static final Disposable CANCELLED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable CANCELLED = () -> { }; - static final Disposable NEW_TIMER = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable NEW_TIMER = () -> { }; volatile boolean gate; diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTimeInterval.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTimeInterval.java similarity index 94% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTimeInterval.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTimeInterval.java index 82b30836b2..f2edc9b697 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTimeInterval.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTimeInterval.java @@ -31,7 +31,7 @@ public NbpOperatorTimeInterval(TimeUnit unit, Scheduler scheduler) { @Override public NbpSubscriber apply(NbpSubscriber> t) { - return new TimeIntervalSubscriber(t, unit, scheduler); + return new TimeIntervalSubscriber<>(t, unit, scheduler); } static final class TimeIntervalSubscriber implements NbpSubscriber { @@ -59,7 +59,7 @@ public void onNext(T t) { long last = lastTime; lastTime = now; long delta = now - last; - actual.onNext(new Timed(t, delta, unit)); + actual.onNext(new Timed<>(t, delta, unit)); } @Override diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTimeout.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTimeout.java similarity index 92% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTimeout.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTimeout.java index a6b0d136f2..039166cb16 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTimeout.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTimeout.java @@ -42,11 +42,11 @@ public NbpOperatorTimeout(Supplier> firstTimeoutSelec @Override public NbpSubscriber apply(NbpSubscriber t) { if (other == null) { - return new TimeoutSubscriber( - new NbpSerializedSubscriber(t), - firstTimeoutSelector, timeoutSelector); + return new TimeoutSubscriber<>( + new NbpSerializedSubscriber<>(t), + firstTimeoutSelector, timeoutSelector); } - return new TimeoutOtherSubscriber(t, firstTimeoutSelector, timeoutSelector, other); + return new TimeoutOtherSubscriber<>(t, firstTimeoutSelector, timeoutSelector, other); } static final class TimeoutSubscriber implements NbpSubscriber, Disposable, OnTimeout { @@ -60,12 +60,9 @@ static final class TimeoutSubscriber implements NbpSubscriber, Dispo volatile long index; - final AtomicReference timeout = new AtomicReference(); + final AtomicReference timeout = new AtomicReference<>(); - static final Disposable CANCELLED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable CANCELLED = () -> { }; public TimeoutSubscriber(NbpSubscriber actual, Supplier> firstTimeoutSelector, @@ -101,7 +98,7 @@ public void onSubscribe(Disposable s) { return; } - TimeoutInnerSubscriber tis = new TimeoutInnerSubscriber(this, 0); + TimeoutInnerSubscriber tis = new TimeoutInnerSubscriber<>(this, 0); if (timeout.compareAndSet(null, tis)) { a.onSubscribe(s); @@ -140,7 +137,7 @@ public void onNext(T t) { return; } - TimeoutInnerSubscriber tis = new TimeoutInnerSubscriber(this, idx); + TimeoutInnerSubscriber tis = new TimeoutInnerSubscriber<>(this, idx); if (timeout.compareAndSet(d, tis)) { p.subscribe(tis); @@ -241,12 +238,9 @@ static final class TimeoutOtherSubscriber implements NbpSubscriber, volatile long index; - final AtomicReference timeout = new AtomicReference(); + final AtomicReference timeout = new AtomicReference<>(); - static final Disposable CANCELLED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable CANCELLED = () -> { }; public TimeoutOtherSubscriber(NbpSubscriber actual, Supplier> firstTimeoutSelector, @@ -255,7 +249,7 @@ public TimeoutOtherSubscriber(NbpSubscriber actual, this.firstTimeoutSelector = firstTimeoutSelector; this.timeoutSelector = timeoutSelector; this.other = other; - this.arbiter = new NbpFullArbiter(actual, this, 8); + this.arbiter = new NbpFullArbiter<>(actual, this, 8); } @Override @@ -287,7 +281,7 @@ public void onSubscribe(Disposable s) { return; } - TimeoutInnerSubscriber tis = new TimeoutInnerSubscriber(this, 0); + TimeoutInnerSubscriber tis = new TimeoutInnerSubscriber<>(this, 0); if (timeout.compareAndSet(null, tis)) { a.onSubscribe(arbiter); @@ -329,7 +323,7 @@ public void onNext(T t) { return; } - TimeoutInnerSubscriber tis = new TimeoutInnerSubscriber(this, idx); + TimeoutInnerSubscriber tis = new TimeoutInnerSubscriber<>(this, idx); if (timeout.compareAndSet(d, tis)) { p.subscribe(tis); @@ -377,7 +371,7 @@ public void dispose() { public void timeout(long idx) { if (idx == index) { dispose(); - other.subscribe(new NbpFullArbiterSubscriber(arbiter)); + other.subscribe(new NbpFullArbiterSubscriber<>(arbiter)); } } } diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTimeoutTimed.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTimeoutTimed.java similarity index 78% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTimeoutTimed.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTimeoutTimed.java index c068678318..5a8004e412 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTimeoutTimed.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorTimeoutTimed.java @@ -42,13 +42,13 @@ public NbpOperatorTimeoutTimed(long timeout, TimeUnit unit, Scheduler scheduler, @Override public NbpSubscriber apply(NbpSubscriber t) { if (other == null) { - return new TimeoutTimedSubscriber( - new NbpSerializedSubscriber(t), // because errors can race - timeout, unit, scheduler.createWorker()); + return new TimeoutTimedSubscriber<>( + new NbpSerializedSubscriber<>(t), // because errors can race + timeout, unit, scheduler.createWorker()); } - return new TimeoutTimedOtherSubscriber( - t, // the FullArbiter serializes - timeout, unit, scheduler.createWorker(), other); + return new TimeoutTimedOtherSubscriber<>( + t, // the FullArbiter serializes + timeout, unit, scheduler.createWorker(), other); } static final class TimeoutTimedOtherSubscriber implements NbpSubscriber, Disposable { @@ -62,17 +62,11 @@ static final class TimeoutTimedOtherSubscriber implements NbpSubscriber, D final NbpFullArbiter arbiter; - final AtomicReference timer = new AtomicReference(); + final AtomicReference timer = new AtomicReference<>(); - static final Disposable CANCELLED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable CANCELLED = () -> { }; - static final Disposable NEW_TIMER = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable NEW_TIMER = () -> { }; volatile long index; @@ -85,7 +79,7 @@ public TimeoutTimedOtherSubscriber(NbpSubscriber actual, long timeout this.unit = unit; this.worker = worker; this.other = other; - this.arbiter = new NbpFullArbiter(actual, this, 8); + this.arbiter = new NbpFullArbiter<>(actual, this, 8); } @Override @@ -122,20 +116,17 @@ void scheduleTimeout(final long idx) { } if (timer.compareAndSet(d, NEW_TIMER)) { - d = worker.schedule(new Runnable() { - @Override - public void run() { - if (idx == index) { - done = true; - s.dispose(); - disposeTimer(); - worker.dispose(); - - if (other == null) { - actual.onError(new TimeoutException()); - } else { - subscribeNext(); - } + d = worker.schedule(() -> { + if (idx == index) { + done = true; + s.dispose(); + disposeTimer(); + worker.dispose(); + + if (other == null) { + actual.onError(new TimeoutException()); + } else { + subscribeNext(); } } }, timeout, unit); @@ -147,7 +138,7 @@ public void run() { } void subscribeNext() { - other.subscribe(new NbpFullArbiterSubscriber(arbiter)); + other.subscribe(new NbpFullArbiterSubscriber<>(arbiter)); } @Override @@ -198,17 +189,11 @@ static final class TimeoutTimedSubscriber implements NbpSubscriber, Dispos Disposable s; - final AtomicReference timer = new AtomicReference(); + final AtomicReference timer = new AtomicReference<>(); - static final Disposable CANCELLED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable CANCELLED = () -> { }; - static final Disposable NEW_TIMER = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable NEW_TIMER = () -> { }; volatile long index; @@ -252,16 +237,13 @@ void scheduleTimeout(final long idx) { } if (timer.compareAndSet(d, NEW_TIMER)) { - d = worker.schedule(new Runnable() { - @Override - public void run() { - if (idx == index) { - done = true; - s.dispose(); - dispose(); - - actual.onError(new TimeoutException()); - } + d = worker.schedule(() -> { + if (idx == index) { + done = true; + s.dispose(); + dispose(); + + actual.onError(new TimeoutException()); } }, timeout, unit); diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorToList.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorToList.java similarity index 94% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorToList.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorToList.java index 79d86caa46..1c688c544f 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorToList.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorToList.java @@ -26,12 +26,7 @@ public final class NbpOperatorToList> implements NbpOperator { @SuppressWarnings({"rawtypes", "unchecked"}) - static final NbpOperatorToList DEFAULT = new NbpOperatorToList(new Supplier() { - @Override - public Object get() { - return new ArrayList(); - } - }); + static final NbpOperatorToList DEFAULT = new NbpOperatorToList(ArrayList::new); @SuppressWarnings("unchecked") public static NbpOperatorToList> defaultInstance() { @@ -53,7 +48,7 @@ public NbpSubscriber apply(NbpSubscriber t) { EmptyDisposable.error(e, t); return NbpCancelledSubscriber.INSTANCE; } - return new ToListSubscriber(t, coll); + return new ToListSubscriber<>(t, coll); } static final class ToListSubscriber> implements NbpSubscriber { diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorUnsubscribeOn.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorUnsubscribeOn.java similarity index 89% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorUnsubscribeOn.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorUnsubscribeOn.java index 6a41b27e33..41ba3c2005 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorUnsubscribeOn.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorUnsubscribeOn.java @@ -28,7 +28,7 @@ public NbpOperatorUnsubscribeOn(Scheduler scheduler) { @Override public NbpSubscriber apply(NbpSubscriber t) { - return new UnsubscribeSubscriber(t, scheduler); + return new UnsubscribeSubscriber<>(t, scheduler); } static final class UnsubscribeSubscriber extends AtomicBoolean implements NbpSubscriber, Disposable { @@ -72,12 +72,7 @@ public void onComplete() { @Override public void dispose() { if (compareAndSet(false, true)) { - scheduler.scheduleDirect(new Runnable() { - @Override - public void run() { - s.dispose(); - } - }); + scheduler.scheduleDirect(s::dispose); } } } diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorWindow.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorWindow.java similarity index 97% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorWindow.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorWindow.java index 60bdb543a4..b77d5cbd8e 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorWindow.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorWindow.java @@ -36,9 +36,9 @@ public NbpOperatorWindow(long count, long skip, int capacityHint) { @Override public NbpSubscriber apply(NbpSubscriber> t) { if (count == skip) { - return new WindowExactSubscriber(t, count, capacityHint); + return new WindowExactSubscriber<>(t, count, capacityHint); } - return new WindowSkipSubscriber(t, count, skip, capacityHint); + return new WindowSkipSubscriber<>(t, count, skip, capacityHint); } static final class WindowExactSubscriber @@ -154,7 +154,7 @@ public WindowSkipSubscriber(NbpSubscriber> actual, long this.count = count; this.skip = skip; this.capacityHint = capacityHint; - this.windows = new ArrayDeque>(); + this.windows = new ArrayDeque<>(); } @Override diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowBoundary.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowBoundary.java similarity index 95% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowBoundary.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowBoundary.java index 43b29a8588..7b8919c2cf 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowBoundary.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowBoundary.java @@ -38,7 +38,7 @@ public NbpOperatorWindowBoundary(NbpObservable other, int bufferSize) { @Override public NbpSubscriber apply(NbpSubscriber> t) { - return new WindowBoundaryMainSubscriber(new NbpSerializedSubscriber>(t), other, bufferSize); + return new WindowBoundaryMainSubscriber<>(new NbpSerializedSubscriber<>(t), other, bufferSize); } static final class WindowBoundaryMainSubscriber @@ -50,12 +50,9 @@ static final class WindowBoundaryMainSubscriber Disposable s; - final AtomicReference boundary = new AtomicReference(); + final AtomicReference boundary = new AtomicReference<>(); - static final Disposable CANCELLED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable CANCELLED = () -> { }; NbpUnicastSubject window; @@ -65,7 +62,7 @@ public void dispose() { } public WindowBoundaryMainSubscriber(NbpSubscriber> actual, NbpObservable other, int bufferSize) { - super(actual, new MpscLinkedQueue()); + super(actual, new MpscLinkedQueue<>()); this.other = other; this.bufferSize = bufferSize; windows.lazySet(1); @@ -91,7 +88,7 @@ public void onSubscribe(Disposable s) { a.onNext(w); - WindowBoundaryInnerSubscriber inner = new WindowBoundaryInnerSubscriber(this); + WindowBoundaryInnerSubscriber inner = new WindowBoundaryInnerSubscriber<>(this); if (boundary.compareAndSet(null, inner)) { windows.getAndIncrement(); diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowBoundarySelector.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowBoundarySelector.java similarity index 93% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowBoundarySelector.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowBoundarySelector.java index b37e59ab08..f72abb2188 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowBoundarySelector.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowBoundarySelector.java @@ -43,9 +43,9 @@ public NbpOperatorWindowBoundarySelector(NbpObservable open, Function apply(NbpSubscriber> t) { - return new WindowBoundaryMainSubscriber( - new NbpSerializedSubscriber>(t), - open, close, bufferSize); + return new WindowBoundaryMainSubscriber<>( + new NbpSerializedSubscriber<>(t), + open, close, bufferSize); } static final class WindowBoundaryMainSubscriber @@ -58,12 +58,9 @@ static final class WindowBoundaryMainSubscriber Disposable s; - final AtomicReference boundary = new AtomicReference(); + final AtomicReference boundary = new AtomicReference<>(); - static final Disposable CANCELLED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable CANCELLED = () -> { }; final List> ws; @@ -71,12 +68,12 @@ public void dispose() { } public WindowBoundaryMainSubscriber(NbpSubscriber> actual, NbpObservable open, Function> close, int bufferSize) { - super(actual, new MpscLinkedQueue()); + super(actual, new MpscLinkedQueue<>()); this.open = open; this.close = close; this.bufferSize = bufferSize; - this.resources = new SetCompositeResource(Disposables.consumeAndDispose()); - this.ws = new ArrayList>(); + this.resources = new SetCompositeResource<>(Disposables.consumeAndDispose()); + this.ws = new ArrayList<>(); windows.lazySet(1); } @@ -94,7 +91,7 @@ public void onSubscribe(Disposable s) { return; } - OperatorWindowBoundaryOpenSubscriber os = new OperatorWindowBoundaryOpenSubscriber(this); + OperatorWindowBoundaryOpenSubscriber os = new OperatorWindowBoundaryOpenSubscriber<>(this); if (boundary.compareAndSet(null, os)) { windows.getAndIncrement(); @@ -274,7 +271,7 @@ void drainLoop() { continue; } - OperatorWindowBoundaryCloseSubscriber cl = new OperatorWindowBoundaryCloseSubscriber(this, w); + OperatorWindowBoundaryCloseSubscriber cl = new OperatorWindowBoundaryCloseSubscriber<>(this, w); if (resources.add(cl)) { windows.getAndIncrement(); @@ -302,7 +299,7 @@ public void accept(NbpSubscriber> a, Object v) { } void open(B b) { - queue.offer(new WindowOperation(null, b)); + queue.offer(new WindowOperation<>(null, b)); if (enter()) { drainLoop(); } @@ -310,7 +307,7 @@ void open(B b) { void close(OperatorWindowBoundaryCloseSubscriber w) { resources.delete(w); - queue.offer(new WindowOperation(w.w, null)); + queue.offer(new WindowOperation<>(w.w, null)); if (enter()) { drainLoop(); } diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowBoundarySupplier.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowBoundarySupplier.java similarity index 95% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowBoundarySupplier.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowBoundarySupplier.java index 4a6c6420f3..2a2afef20a 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowBoundarySupplier.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowBoundarySupplier.java @@ -39,7 +39,7 @@ public NbpOperatorWindowBoundarySupplier(Supplier> ot @Override public NbpSubscriber apply(NbpSubscriber> t) { - return new WindowBoundaryMainSubscriber(new NbpSerializedSubscriber>(t), other, bufferSize); + return new WindowBoundaryMainSubscriber<>(new NbpSerializedSubscriber<>(t), other, bufferSize); } static final class WindowBoundaryMainSubscriber @@ -51,12 +51,9 @@ static final class WindowBoundaryMainSubscriber Disposable s; - final AtomicReference boundary = new AtomicReference(); + final AtomicReference boundary = new AtomicReference<>(); - static final Disposable CANCELLED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable CANCELLED = () -> { }; NbpUnicastSubject window; @@ -66,7 +63,7 @@ public void dispose() { } public WindowBoundaryMainSubscriber(NbpSubscriber> actual, Supplier> other, int bufferSize) { - super(actual, new MpscLinkedQueue()); + super(actual, new MpscLinkedQueue<>()); this.other = other; this.bufferSize = bufferSize; windows.lazySet(1); @@ -108,7 +105,7 @@ public void onSubscribe(Disposable s) { a.onNext(w); - WindowBoundaryInnerSubscriber inner = new WindowBoundaryInnerSubscriber(this); + WindowBoundaryInnerSubscriber inner = new WindowBoundaryInnerSubscriber<>(this); if (boundary.compareAndSet(null, inner)) { windows.getAndIncrement(); @@ -254,7 +251,7 @@ void drainLoop() { a.onNext(w); - WindowBoundaryInnerSubscriber b = new WindowBoundaryInnerSubscriber(this); + WindowBoundaryInnerSubscriber b = new WindowBoundaryInnerSubscriber<>(this); if (boundary.compareAndSet(boundary.get(), b)) { p.subscribe(b); diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowTimed.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowTimed.java similarity index 93% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowTimed.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowTimed.java index 101006106b..0ea6aec0b1 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowTimed.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowTimed.java @@ -51,21 +51,21 @@ public NbpOperatorWindowTimed(long timespan, long timeskip, TimeUnit unit, Sched @Override public NbpSubscriber apply(NbpSubscriber> t) { - NbpSerializedSubscriber> actual = new NbpSerializedSubscriber>(t); + NbpSerializedSubscriber> actual = new NbpSerializedSubscriber<>(t); if (timespan == timeskip) { if (maxSize == Long.MAX_VALUE) { - return new WindowExactUnboundedSubscriber( - actual, - timespan, unit, scheduler, bufferSize); + return new WindowExactUnboundedSubscriber<>( + actual, + timespan, unit, scheduler, bufferSize); } - return new WindowExactBoundedSubscriber( - actual, - timespan, unit, scheduler, - bufferSize, maxSize, restartTimerOnMaxSize); + return new WindowExactBoundedSubscriber<>( + actual, + timespan, unit, scheduler, + bufferSize, maxSize, restartTimerOnMaxSize); } - return new WindowSkipSubscriber(actual, - timespan, timeskip, unit, scheduler.createWorker(), bufferSize); + return new WindowSkipSubscriber<>(actual, + timespan, timeskip, unit, scheduler.createWorker(), bufferSize); } static final class WindowExactUnboundedSubscriber @@ -82,12 +82,9 @@ static final class WindowExactUnboundedSubscriber NbpUnicastSubject window; - final AtomicReference timer = new AtomicReference(); + final AtomicReference timer = new AtomicReference<>(); - static final Disposable CANCELLED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable CANCELLED = () -> { }; static final Object NEXT = new Object(); @@ -95,7 +92,7 @@ public void dispose() { } public WindowExactUnboundedSubscriber(NbpSubscriber> actual, long timespan, TimeUnit unit, Scheduler scheduler, int bufferSize) { - super(actual, new MpscLinkedQueue()); + super(actual, new MpscLinkedQueue<>()); this.timespan = timespan; this.unit = unit; this.scheduler = scheduler; @@ -288,18 +285,15 @@ static final class WindowExactBoundedSubscriber volatile boolean terminated; - final AtomicReference timer = new AtomicReference(); + final AtomicReference timer = new AtomicReference<>(); - static final Disposable CANCELLED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable CANCELLED = () -> { }; public WindowExactBoundedSubscriber( NbpSubscriber> actual, long timespan, TimeUnit unit, Scheduler scheduler, int bufferSize, long maxSize, boolean restartTimerOnMaxSize) { - super(actual, new MpscLinkedQueue()); + super(actual, new MpscLinkedQueue<>()); this.timespan = timespan; this.unit = unit; this.scheduler = scheduler; @@ -570,13 +564,13 @@ static final class WindowSkipSubscriber public WindowSkipSubscriber(NbpSubscriber> actual, long timespan, long timeskip, TimeUnit unit, Worker worker, int bufferSize) { - super(actual, new MpscLinkedQueue()); + super(actual, new MpscLinkedQueue<>()); this.timespan = timespan; this.timeskip = timeskip; this.unit = unit; this.worker = worker; this.bufferSize = bufferSize; - this.windows = new LinkedList>(); + this.windows = new LinkedList<>(); } @Override @@ -597,12 +591,7 @@ public void onSubscribe(Disposable s) { windows.add(w); actual.onNext(w); - worker.schedule(new Runnable() { - @Override - public void run() { - complete(w); - } - }, timespan, unit); + worker.schedule(() -> complete(w), timespan, unit); worker.schedulePeriodically(this, timeskip, timeskip, unit); } @@ -665,7 +654,7 @@ public void accept(NbpSubscriber> a, Object v) { } void complete(NbpUnicastSubject w) { - queue.offer(new SubjectWork(w, false)); + queue.offer(new SubjectWork<>(w, false)); if (enter()) { drainLoop(); } @@ -730,12 +719,7 @@ void drainLoop() { ws.add(w); a.onNext(w); - worker.schedule(new Runnable() { - @Override - public void run() { - complete(w); - } - }, timespan, unit); + worker.schedule(() -> complete(w), timespan, unit); } else { ws.remove(work.w); work.w.onComplete(); @@ -763,7 +747,7 @@ public void run() { NbpUnicastSubject w = NbpUnicastSubject.create(bufferSize); - SubjectWork sw = new SubjectWork(w, true); + SubjectWork sw = new SubjectWork<>(w, true); if (!cancelled) { queue.offer(sw); } diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorWithLatestFrom.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorWithLatestFrom.java similarity index 95% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorWithLatestFrom.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorWithLatestFrom.java index 7a9b8bc25d..9b4cd996bc 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorWithLatestFrom.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpOperatorWithLatestFrom.java @@ -34,8 +34,8 @@ public NbpOperatorWithLatestFrom(BiFunction c @Override public NbpSubscriber apply(NbpSubscriber t) { - final NbpSerializedSubscriber serial = new NbpSerializedSubscriber(t); - final WithLatestFromSubscriber wlf = new WithLatestFromSubscriber(serial, combiner); + final NbpSerializedSubscriber serial = new NbpSerializedSubscriber<>(t); + final WithLatestFromSubscriber wlf = new WithLatestFromSubscriber<>(serial, combiner); other.subscribe(new NbpSubscriber() { @Override @@ -69,14 +69,11 @@ static final class WithLatestFromSubscriber extends AtomicReference final NbpSubscriber actual; final BiFunction combiner; - final AtomicReference s = new AtomicReference(); + final AtomicReference s = new AtomicReference<>(); - final AtomicReference other = new AtomicReference(); + final AtomicReference other = new AtomicReference<>(); - static final Disposable CANCELLED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable CANCELLED = () -> { }; public WithLatestFromSubscriber(NbpSubscriber actual, BiFunction combiner) { this.actual = actual; diff --git a/src/main/java/io/reactivex/internal/operators/nbp/NbpSubscriberResourceWrapper.java b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpSubscriberResourceWrapper.java similarity index 95% rename from src/main/java/io/reactivex/internal/operators/nbp/NbpSubscriberResourceWrapper.java rename to rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpSubscriberResourceWrapper.java index 4599a552d3..95d62a173d 100644 --- a/src/main/java/io/reactivex/internal/operators/nbp/NbpSubscriberResourceWrapper.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/nbp/NbpSubscriberResourceWrapper.java @@ -27,12 +27,9 @@ public final class NbpSubscriberResourceWrapper extends AtomicReference actual; final Consumer disposer; - final AtomicReference subscription = new AtomicReference(); + final AtomicReference subscription = new AtomicReference<>(); - static final Disposable TERMINATED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable TERMINATED = () -> { }; public NbpSubscriberResourceWrapper(NbpSubscriber actual, Consumer disposer) { this.actual = actual; diff --git a/src/main/java/io/reactivex/internal/operators/single/SingleOperatorFlatMap.java b/rxjava/src/main/java/io/reactivex/internal/operators/single/SingleOperatorFlatMap.java similarity index 98% rename from src/main/java/io/reactivex/internal/operators/single/SingleOperatorFlatMap.java rename to rxjava/src/main/java/io/reactivex/internal/operators/single/SingleOperatorFlatMap.java index 267539f232..77546b014d 100644 --- a/src/main/java/io/reactivex/internal/operators/single/SingleOperatorFlatMap.java +++ b/rxjava/src/main/java/io/reactivex/internal/operators/single/SingleOperatorFlatMap.java @@ -27,7 +27,7 @@ public SingleOperatorFlatMap(Function> @Override public SingleSubscriber apply(SingleSubscriber t) { - return new SingleFlatMapCallback(t, mapper); + return new SingleFlatMapCallback<>(t, mapper); } static final class SingleFlatMapCallback implements SingleSubscriber { diff --git a/src/main/java/io/reactivex/internal/operators/single/SingleOperatorMap.java b/rxjava/src/main/java/io/reactivex/internal/operators/single/SingleOperatorMap.java similarity index 100% rename from src/main/java/io/reactivex/internal/operators/single/SingleOperatorMap.java rename to rxjava/src/main/java/io/reactivex/internal/operators/single/SingleOperatorMap.java diff --git a/src/main/java/io/reactivex/internal/queue/BaseArrayQueue.java b/rxjava/src/main/java/io/reactivex/internal/queue/BaseArrayQueue.java similarity index 100% rename from src/main/java/io/reactivex/internal/queue/BaseArrayQueue.java rename to rxjava/src/main/java/io/reactivex/internal/queue/BaseArrayQueue.java diff --git a/src/main/java/io/reactivex/internal/queue/BaseLinkedQueue.java b/rxjava/src/main/java/io/reactivex/internal/queue/BaseLinkedQueue.java similarity index 96% rename from src/main/java/io/reactivex/internal/queue/BaseLinkedQueue.java rename to rxjava/src/main/java/io/reactivex/internal/queue/BaseLinkedQueue.java index 5c14019956..310ff13188 100644 --- a/src/main/java/io/reactivex/internal/queue/BaseLinkedQueue.java +++ b/rxjava/src/main/java/io/reactivex/internal/queue/BaseLinkedQueue.java @@ -25,8 +25,8 @@ abstract class BaseLinkedQueue extends AbstractQueue { private final AtomicReference> producerNode; private final AtomicReference> consumerNode; public BaseLinkedQueue() { - producerNode = new AtomicReference>(); - consumerNode = new AtomicReference>(); + producerNode = new AtomicReference<>(); + consumerNode = new AtomicReference<>(); } protected final LinkedQueueNode lvProducerNode() { return producerNode.get(); diff --git a/src/main/java/io/reactivex/internal/queue/LinkedQueueNode.java b/rxjava/src/main/java/io/reactivex/internal/queue/LinkedQueueNode.java similarity index 100% rename from src/main/java/io/reactivex/internal/queue/LinkedQueueNode.java rename to rxjava/src/main/java/io/reactivex/internal/queue/LinkedQueueNode.java diff --git a/src/main/java/io/reactivex/internal/queue/MpscLinkedQueue.java b/rxjava/src/main/java/io/reactivex/internal/queue/MpscLinkedQueue.java similarity index 98% rename from src/main/java/io/reactivex/internal/queue/MpscLinkedQueue.java rename to rxjava/src/main/java/io/reactivex/internal/queue/MpscLinkedQueue.java index 439c9ea9fd..d285960b8a 100644 --- a/src/main/java/io/reactivex/internal/queue/MpscLinkedQueue.java +++ b/rxjava/src/main/java/io/reactivex/internal/queue/MpscLinkedQueue.java @@ -26,7 +26,7 @@ public final class MpscLinkedQueue extends BaseLinkedQueue { public MpscLinkedQueue() { super(); - LinkedQueueNode node = new LinkedQueueNode(); + LinkedQueueNode node = new LinkedQueueNode<>(); spConsumerNode(node); xchgProducerNode(node);// this ensures correct construction: StoreLoad } @@ -47,7 +47,7 @@ public MpscLinkedQueue() { */ @Override public final boolean offer(final T nextValue) { - final LinkedQueueNode nextNode = new LinkedQueueNode(nextValue); + final LinkedQueueNode nextNode = new LinkedQueueNode<>(nextValue); final LinkedQueueNode prevProducerNode = xchgProducerNode(nextNode); // Should a producer thread get interrupted here the chain WILL be broken until that thread is resumed // and completes the store in prev.next. diff --git a/src/main/java/io/reactivex/internal/queue/SpscArrayQueue.java b/rxjava/src/main/java/io/reactivex/internal/queue/SpscArrayQueue.java similarity index 100% rename from src/main/java/io/reactivex/internal/queue/SpscArrayQueue.java rename to rxjava/src/main/java/io/reactivex/internal/queue/SpscArrayQueue.java diff --git a/src/main/java/io/reactivex/internal/queue/SpscExactArrayQueue.java b/rxjava/src/main/java/io/reactivex/internal/queue/SpscExactArrayQueue.java similarity index 100% rename from src/main/java/io/reactivex/internal/queue/SpscExactArrayQueue.java rename to rxjava/src/main/java/io/reactivex/internal/queue/SpscExactArrayQueue.java diff --git a/src/main/java/io/reactivex/internal/queue/SpscLinkedArrayQueue.java b/rxjava/src/main/java/io/reactivex/internal/queue/SpscLinkedArrayQueue.java similarity index 99% rename from src/main/java/io/reactivex/internal/queue/SpscLinkedArrayQueue.java rename to rxjava/src/main/java/io/reactivex/internal/queue/SpscLinkedArrayQueue.java index 2e7ea6593f..21e67518b2 100644 --- a/src/main/java/io/reactivex/internal/queue/SpscLinkedArrayQueue.java +++ b/rxjava/src/main/java/io/reactivex/internal/queue/SpscLinkedArrayQueue.java @@ -45,7 +45,7 @@ public final class SpscLinkedArrayQueue implements Queue { public SpscLinkedArrayQueue(final int bufferSize) { int p2capacity = Pow2.roundToPowerOfTwo(bufferSize); int mask = p2capacity - 1; - AtomicReferenceArray buffer = new AtomicReferenceArray(p2capacity + 1); + AtomicReferenceArray buffer = new AtomicReferenceArray<>(p2capacity + 1); producerBuffer = buffer; producerMask = mask; adjustLookAheadStep(p2capacity); @@ -94,7 +94,7 @@ private boolean writeToQueue(final AtomicReferenceArray buffer, final T private void resize(final AtomicReferenceArray oldBuffer, final long currIndex, final int offset, final T e, final long mask) { final int capacity = oldBuffer.length(); - final AtomicReferenceArray newBuffer = new AtomicReferenceArray(capacity); + final AtomicReferenceArray newBuffer = new AtomicReferenceArray<>(capacity); producerBuffer = newBuffer; producerLookAhead = currIndex + mask - 1; soProducerIndex(currIndex + 1);// this ensures correctness on 32bit platforms @@ -330,7 +330,7 @@ public boolean offer(T first, T second) { soElement(buffer, pi, first); } else { final int capacity = buffer.length(); - final AtomicReferenceArray newBuffer = new AtomicReferenceArray(capacity); + final AtomicReferenceArray newBuffer = new AtomicReferenceArray<>(capacity); producerBuffer = newBuffer; pi = calcWrappedOffset(p, m); diff --git a/src/main/java/io/reactivex/internal/schedulers/ComputationScheduler.java b/rxjava/src/main/java/io/reactivex/internal/schedulers/ComputationScheduler.java similarity index 94% rename from src/main/java/io/reactivex/internal/schedulers/ComputationScheduler.java rename to rxjava/src/main/java/io/reactivex/internal/schedulers/ComputationScheduler.java index 2fcb8c2b8f..53bd1b2ed3 100644 --- a/src/main/java/io/reactivex/internal/schedulers/ComputationScheduler.java +++ b/rxjava/src/main/java/io/reactivex/internal/schedulers/ComputationScheduler.java @@ -95,7 +95,7 @@ public void shutdown() { * count and using least-recent worker selection policy. */ public ComputationScheduler() { - this.pool = new AtomicReference(NONE); + this.pool = new AtomicReference<>(NONE); start(); } @@ -149,9 +149,9 @@ private static class EventLoopWorker extends Scheduler.Worker { EventLoopWorker(PoolWorker poolWorker) { this.poolWorker = poolWorker; - this.serial = new ListCompositeResource(Disposables.consumeAndDispose()); - this.timed = new SetCompositeResource(Disposables.consumeAndDispose()); - this.both = new ArrayCompositeResource(2, Disposables.consumeAndDispose()); + this.serial = new ListCompositeResource<>(Disposables.consumeAndDispose()); + this.timed = new SetCompositeResource<>(Disposables.consumeAndDispose()); + this.both = new ArrayCompositeResource<>(2, Disposables.consumeAndDispose()); this.both.lazySet(0, serial); this.both.lazySet(1, timed); } diff --git a/src/main/java/io/reactivex/internal/schedulers/ExecutorScheduler.java b/rxjava/src/main/java/io/reactivex/internal/schedulers/ExecutorScheduler.java similarity index 90% rename from src/main/java/io/reactivex/internal/schedulers/ExecutorScheduler.java rename to rxjava/src/main/java/io/reactivex/internal/schedulers/ExecutorScheduler.java index 222fb4b823..e4a0547265 100644 --- a/src/main/java/io/reactivex/internal/schedulers/ExecutorScheduler.java +++ b/rxjava/src/main/java/io/reactivex/internal/schedulers/ExecutorScheduler.java @@ -70,16 +70,11 @@ public Disposable scheduleDirect(Runnable run, long delay, TimeUnit unit) { return EmptyDisposable.INSTANCE; } } - MultipleAssignmentResource first = new MultipleAssignmentResource(Disposables.consumeAndDispose()); + MultipleAssignmentResource first = new MultipleAssignmentResource<>(Disposables.consumeAndDispose()); - final MultipleAssignmentResource mar = new MultipleAssignmentResource(Disposables.consumeAndDispose(), first); + final MultipleAssignmentResource mar = new MultipleAssignmentResource<>(Disposables.consumeAndDispose(), first); - Disposable delayed = HELPER.scheduleDirect(new Runnable() { - @Override - public void run() { - mar.setResource(scheduleDirect(decoratedRun)); - } - }, delay, unit); + Disposable delayed = HELPER.scheduleDirect(() -> mar.setResource(scheduleDirect(decoratedRun)), delay, unit); first.setResource(delayed); @@ -110,11 +105,11 @@ public static final class ExecutorWorker extends Scheduler.Worker implements Run final AtomicInteger wip = new AtomicInteger(); - final SetCompositeResource tasks = new SetCompositeResource(Disposables.consumeAndDispose()); + final SetCompositeResource tasks = new SetCompositeResource<>(Disposables.consumeAndDispose()); public ExecutorWorker(Executor executor) { this.executor = executor; - this.queue = new MpscLinkedQueue(); + this.queue = new MpscLinkedQueue<>(); } @Override @@ -152,18 +147,13 @@ public Disposable schedule(Runnable run, long delay, TimeUnit unit) { } - MultipleAssignmentResource first = new MultipleAssignmentResource(Disposables.consumeAndDispose()); + MultipleAssignmentResource first = new MultipleAssignmentResource<>(Disposables.consumeAndDispose()); - final MultipleAssignmentResource mar = new MultipleAssignmentResource(Disposables.consumeAndDispose(), first); + final MultipleAssignmentResource mar = new MultipleAssignmentResource<>(Disposables.consumeAndDispose(), first); final Runnable decoratedRun = RxJavaPlugins.onSchedule(run); - ScheduledRunnable sr = new ScheduledRunnable(new Runnable() { - @Override - public void run() { - mar.setResource(schedule(decoratedRun)); - } - }, tasks); + ScheduledRunnable sr = new ScheduledRunnable(() -> mar.setResource(schedule(decoratedRun)), tasks); tasks.add(sr); if (executor instanceof ScheduledExecutorService) { diff --git a/src/main/java/io/reactivex/internal/schedulers/IOScheduler.java b/rxjava/src/main/java/io/reactivex/internal/schedulers/IOScheduler.java similarity index 91% rename from src/main/java/io/reactivex/internal/schedulers/IOScheduler.java rename to rxjava/src/main/java/io/reactivex/internal/schedulers/IOScheduler.java index 0e69100360..8ba833af93 100644 --- a/src/main/java/io/reactivex/internal/schedulers/IOScheduler.java +++ b/rxjava/src/main/java/io/reactivex/internal/schedulers/IOScheduler.java @@ -54,22 +54,15 @@ private static final class CachedWorkerPool { CachedWorkerPool(long keepAliveTime, TimeUnit unit) { this.keepAliveTime = unit != null ? unit.toNanos(keepAliveTime) : 0L; - this.expiringWorkerQueue = new ConcurrentLinkedQueue(); - this.allWorkers = new SetCompositeResource(Disposables.consumeAndDispose()); + this.expiringWorkerQueue = new ConcurrentLinkedQueue<>(); + this.allWorkers = new SetCompositeResource<>(Disposables.consumeAndDispose()); ScheduledExecutorService evictor = null; Future task = null; if (unit != null) { evictor = Executors.newScheduledThreadPool(1, EVICTOR_THREAD_FACTORY); try { - task = evictor.scheduleWithFixedDelay( - new Runnable() { - @Override - public void run() { - evictExpiredWorkers(); - } - }, this.keepAliveTime, this.keepAliveTime, TimeUnit.NANOSECONDS - ); + task = evictor.scheduleWithFixedDelay(this::evictExpiredWorkers, this.keepAliveTime, this.keepAliveTime, TimeUnit.NANOSECONDS); } catch (RejectedExecutionException ex) { RxJavaPlugins.onError(ex); } @@ -147,7 +140,7 @@ void shutdown() { } public IOScheduler() { - this.pool = new AtomicReference(NONE); + this.pool = new AtomicReference<>(NONE); start(); } @@ -190,7 +183,7 @@ private static final class EventLoopWorker extends Scheduler.Worker { EventLoopWorker(CachedWorkerPool pool) { this.pool = pool; - this.tasks = new SetCompositeResource(Disposables.consumeAndDispose()); + this.tasks = new SetCompositeResource<>(Disposables.consumeAndDispose()); this.threadWorker = pool.get(); } diff --git a/src/main/java/io/reactivex/internal/schedulers/NewThreadScheduler.java b/rxjava/src/main/java/io/reactivex/internal/schedulers/NewThreadScheduler.java similarity index 100% rename from src/main/java/io/reactivex/internal/schedulers/NewThreadScheduler.java rename to rxjava/src/main/java/io/reactivex/internal/schedulers/NewThreadScheduler.java diff --git a/src/main/java/io/reactivex/internal/schedulers/NewThreadWorker.java b/rxjava/src/main/java/io/reactivex/internal/schedulers/NewThreadWorker.java similarity index 100% rename from src/main/java/io/reactivex/internal/schedulers/NewThreadWorker.java rename to rxjava/src/main/java/io/reactivex/internal/schedulers/NewThreadWorker.java diff --git a/src/main/java/io/reactivex/internal/schedulers/RxThreadFactory.java b/rxjava/src/main/java/io/reactivex/internal/schedulers/RxThreadFactory.java similarity index 100% rename from src/main/java/io/reactivex/internal/schedulers/RxThreadFactory.java rename to rxjava/src/main/java/io/reactivex/internal/schedulers/RxThreadFactory.java diff --git a/src/main/java/io/reactivex/internal/schedulers/ScheduledRunnable.java b/rxjava/src/main/java/io/reactivex/internal/schedulers/ScheduledRunnable.java similarity index 100% rename from src/main/java/io/reactivex/internal/schedulers/ScheduledRunnable.java rename to rxjava/src/main/java/io/reactivex/internal/schedulers/ScheduledRunnable.java diff --git a/src/main/java/io/reactivex/internal/schedulers/SchedulerLifecycle.java b/rxjava/src/main/java/io/reactivex/internal/schedulers/SchedulerLifecycle.java similarity index 100% rename from src/main/java/io/reactivex/internal/schedulers/SchedulerLifecycle.java rename to rxjava/src/main/java/io/reactivex/internal/schedulers/SchedulerLifecycle.java diff --git a/src/main/java/io/reactivex/internal/schedulers/SchedulerPoolFactory.java b/rxjava/src/main/java/io/reactivex/internal/schedulers/SchedulerPoolFactory.java similarity index 80% rename from src/main/java/io/reactivex/internal/schedulers/SchedulerPoolFactory.java rename to rxjava/src/main/java/io/reactivex/internal/schedulers/SchedulerPoolFactory.java index c0650603eb..fdd4017c7d 100644 --- a/src/main/java/io/reactivex/internal/schedulers/SchedulerPoolFactory.java +++ b/rxjava/src/main/java/io/reactivex/internal/schedulers/SchedulerPoolFactory.java @@ -42,11 +42,11 @@ public enum SchedulerPoolFactory { */ public static final int PURGE_PERIOD_SECONDS; - static final AtomicReference PURGE_THREAD = - new AtomicReference(); + static final AtomicReference PURGE_THREAD = + new AtomicReference<>(); - static final ConcurrentHashMap POOLS = - new ConcurrentHashMap(); + static final ConcurrentMap POOLS = + new ConcurrentHashMap<>(); /** * Starts the purge thread if not already started. @@ -60,20 +60,17 @@ public static void start() { ScheduledExecutorService next = Executors.newScheduledThreadPool(1, new RxThreadFactory("RxSchedulerPurge-")); if (PURGE_THREAD.compareAndSet(curr, next)) { - next.scheduleAtFixedRate(new Runnable() { - @Override - public void run() { - try { - for (ScheduledThreadPoolExecutor e : new ArrayList(POOLS.keySet())) { - if (e.isShutdown()) { - POOLS.remove(e); - } else { - e.purge(); - } + next.scheduleAtFixedRate(() -> { + try { + for (ScheduledThreadPoolExecutor e : new ArrayList<>(POOLS.keySet())) { + if (e.isShutdown()) { + POOLS.remove(e); + } else { + e.purge(); } - } catch (Throwable e) { - RxJavaPlugins.onError(e); } + } catch (Throwable e) { + RxJavaPlugins.onError(e); } }, PURGE_PERIOD_SECONDS, PURGE_PERIOD_SECONDS, TimeUnit.SECONDS); diff --git a/src/main/java/io/reactivex/internal/schedulers/SingleScheduler.java b/rxjava/src/main/java/io/reactivex/internal/schedulers/SingleScheduler.java similarity index 97% rename from src/main/java/io/reactivex/internal/schedulers/SingleScheduler.java rename to rxjava/src/main/java/io/reactivex/internal/schedulers/SingleScheduler.java index 2d7252889b..820f363349 100644 --- a/src/main/java/io/reactivex/internal/schedulers/SingleScheduler.java +++ b/rxjava/src/main/java/io/reactivex/internal/schedulers/SingleScheduler.java @@ -22,7 +22,7 @@ public final class SingleScheduler extends Scheduler { - final AtomicReference executor = new AtomicReference(); + final AtomicReference executor = new AtomicReference<>(); static final ScheduledExecutorService SHUTDOWN; static { @@ -115,7 +115,7 @@ static final class ScheduledWorker extends Scheduler.Worker { public ScheduledWorker(ScheduledExecutorService executor) { this.executor = executor; - this.tasks = new SetCompositeResource(Disposables.consumeAndDispose()); + this.tasks = new SetCompositeResource<>(Disposables.consumeAndDispose()); } @Override diff --git a/src/main/java/io/reactivex/internal/schedulers/TrampolineScheduler.java b/rxjava/src/main/java/io/reactivex/internal/schedulers/TrampolineScheduler.java similarity index 95% rename from src/main/java/io/reactivex/internal/schedulers/TrampolineScheduler.java rename to rxjava/src/main/java/io/reactivex/internal/schedulers/TrampolineScheduler.java index 944c2618e7..7cfa8ada3f 100644 --- a/src/main/java/io/reactivex/internal/schedulers/TrampolineScheduler.java +++ b/rxjava/src/main/java/io/reactivex/internal/schedulers/TrampolineScheduler.java @@ -62,7 +62,7 @@ public Disposable scheduleDirect(Runnable run, long delay, TimeUnit unit) { } static final class TrampolineWorker extends Scheduler.Worker implements Disposable { - private final PriorityBlockingQueue queue = new PriorityBlockingQueue(); + private final PriorityBlockingQueue queue = new PriorityBlockingQueue<>(); private final AtomicInteger wip = new AtomicInteger(); @@ -110,12 +110,9 @@ private Disposable enqueue(Runnable action, long execTime) { return EmptyDisposable.INSTANCE; } else { // queue wasn't empty, a parent is already processing so we just add to the end of the queue - return new Disposable() { - @Override - public void dispose() { - timedRunnable.disposed = true; - queue.remove(timedRunnable); - } + return () -> { + timedRunnable.disposed = true; + queue.remove(timedRunnable); }; } } diff --git a/src/main/java/io/reactivex/internal/subscribers/BlockingSubscriber.java b/rxjava/src/main/java/io/reactivex/internal/subscribers/BlockingSubscriber.java similarity index 100% rename from src/main/java/io/reactivex/internal/subscribers/BlockingSubscriber.java rename to rxjava/src/main/java/io/reactivex/internal/subscribers/BlockingSubscriber.java diff --git a/src/main/java/io/reactivex/internal/subscribers/CancelledSubscriber.java b/rxjava/src/main/java/io/reactivex/internal/subscribers/CancelledSubscriber.java similarity index 100% rename from src/main/java/io/reactivex/internal/subscribers/CancelledSubscriber.java rename to rxjava/src/main/java/io/reactivex/internal/subscribers/CancelledSubscriber.java diff --git a/src/main/java/io/reactivex/internal/subscribers/ConditionalSubscriber.java b/rxjava/src/main/java/io/reactivex/internal/subscribers/ConditionalSubscriber.java similarity index 100% rename from src/main/java/io/reactivex/internal/subscribers/ConditionalSubscriber.java rename to rxjava/src/main/java/io/reactivex/internal/subscribers/ConditionalSubscriber.java diff --git a/src/main/java/io/reactivex/internal/subscribers/DisposableSubscriber.java b/rxjava/src/main/java/io/reactivex/internal/subscribers/DisposableSubscriber.java similarity index 99% rename from src/main/java/io/reactivex/internal/subscribers/DisposableSubscriber.java rename to rxjava/src/main/java/io/reactivex/internal/subscribers/DisposableSubscriber.java index cb6adfcdc3..4791560776 100644 --- a/src/main/java/io/reactivex/internal/subscribers/DisposableSubscriber.java +++ b/rxjava/src/main/java/io/reactivex/internal/subscribers/DisposableSubscriber.java @@ -26,7 +26,7 @@ * @param */ public abstract class DisposableSubscriber implements Subscriber, Disposable { - final AtomicReference s = new AtomicReference(); + final AtomicReference s = new AtomicReference<>(); static final Subscription CANCELLED = new Subscription() { @Override diff --git a/src/main/java/io/reactivex/internal/subscribers/EmptySubscriber.java b/rxjava/src/main/java/io/reactivex/internal/subscribers/EmptySubscriber.java similarity index 100% rename from src/main/java/io/reactivex/internal/subscribers/EmptySubscriber.java rename to rxjava/src/main/java/io/reactivex/internal/subscribers/EmptySubscriber.java diff --git a/src/main/java/io/reactivex/internal/subscribers/FullArbiterSubscriber.java b/rxjava/src/main/java/io/reactivex/internal/subscribers/FullArbiterSubscriber.java similarity index 100% rename from src/main/java/io/reactivex/internal/subscribers/FullArbiterSubscriber.java rename to rxjava/src/main/java/io/reactivex/internal/subscribers/FullArbiterSubscriber.java diff --git a/src/main/java/io/reactivex/internal/subscribers/LambdaSubscriber.java b/rxjava/src/main/java/io/reactivex/internal/subscribers/LambdaSubscriber.java similarity index 100% rename from src/main/java/io/reactivex/internal/subscribers/LambdaSubscriber.java rename to rxjava/src/main/java/io/reactivex/internal/subscribers/LambdaSubscriber.java diff --git a/src/main/java/io/reactivex/internal/subscribers/NbpFullArbiterSubscriber.java b/rxjava/src/main/java/io/reactivex/internal/subscribers/NbpFullArbiterSubscriber.java similarity index 100% rename from src/main/java/io/reactivex/internal/subscribers/NbpFullArbiterSubscriber.java rename to rxjava/src/main/java/io/reactivex/internal/subscribers/NbpFullArbiterSubscriber.java diff --git a/src/main/java/io/reactivex/internal/subscribers/QueueDrainSubscriber.java b/rxjava/src/main/java/io/reactivex/internal/subscribers/QueueDrainSubscriber.java similarity index 100% rename from src/main/java/io/reactivex/internal/subscribers/QueueDrainSubscriber.java rename to rxjava/src/main/java/io/reactivex/internal/subscribers/QueueDrainSubscriber.java diff --git a/src/main/java/io/reactivex/internal/subscribers/SubscriptionLambdaSubscriber.java b/rxjava/src/main/java/io/reactivex/internal/subscribers/SubscriptionLambdaSubscriber.java similarity index 100% rename from src/main/java/io/reactivex/internal/subscribers/SubscriptionLambdaSubscriber.java rename to rxjava/src/main/java/io/reactivex/internal/subscribers/SubscriptionLambdaSubscriber.java diff --git a/src/main/java/io/reactivex/internal/subscribers/ToNotificationSubscriber.java b/rxjava/src/main/java/io/reactivex/internal/subscribers/ToNotificationSubscriber.java similarity index 100% rename from src/main/java/io/reactivex/internal/subscribers/ToNotificationSubscriber.java rename to rxjava/src/main/java/io/reactivex/internal/subscribers/ToNotificationSubscriber.java diff --git a/src/main/java/io/reactivex/internal/subscribers/nbp/NbpBlockingSubscriber.java b/rxjava/src/main/java/io/reactivex/internal/subscribers/nbp/NbpBlockingSubscriber.java similarity index 95% rename from src/main/java/io/reactivex/internal/subscribers/nbp/NbpBlockingSubscriber.java rename to rxjava/src/main/java/io/reactivex/internal/subscribers/nbp/NbpBlockingSubscriber.java index 8ebf82ed3f..f241964e51 100644 --- a/src/main/java/io/reactivex/internal/subscribers/nbp/NbpBlockingSubscriber.java +++ b/rxjava/src/main/java/io/reactivex/internal/subscribers/nbp/NbpBlockingSubscriber.java @@ -25,10 +25,7 @@ public final class NbpBlockingSubscriber extends AtomicReference /** */ private static final long serialVersionUID = -4875965440900746268L; - static final Disposable CANCELLED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable CANCELLED = () -> { }; public static final Object TERMINATED = new Object(); diff --git a/src/main/java/io/reactivex/internal/subscribers/nbp/NbpCancelledSubscriber.java b/rxjava/src/main/java/io/reactivex/internal/subscribers/nbp/NbpCancelledSubscriber.java similarity index 100% rename from src/main/java/io/reactivex/internal/subscribers/nbp/NbpCancelledSubscriber.java rename to rxjava/src/main/java/io/reactivex/internal/subscribers/nbp/NbpCancelledSubscriber.java diff --git a/src/main/java/io/reactivex/internal/subscribers/nbp/NbpConditionalSubscriber.java b/rxjava/src/main/java/io/reactivex/internal/subscribers/nbp/NbpConditionalSubscriber.java similarity index 100% rename from src/main/java/io/reactivex/internal/subscribers/nbp/NbpConditionalSubscriber.java rename to rxjava/src/main/java/io/reactivex/internal/subscribers/nbp/NbpConditionalSubscriber.java diff --git a/src/main/java/io/reactivex/internal/subscribers/nbp/NbpDisposableSubscriber.java b/rxjava/src/main/java/io/reactivex/internal/subscribers/nbp/NbpDisposableSubscriber.java similarity index 89% rename from src/main/java/io/reactivex/internal/subscribers/nbp/NbpDisposableSubscriber.java rename to rxjava/src/main/java/io/reactivex/internal/subscribers/nbp/NbpDisposableSubscriber.java index 19978e24ee..45942808e8 100644 --- a/src/main/java/io/reactivex/internal/subscribers/nbp/NbpDisposableSubscriber.java +++ b/rxjava/src/main/java/io/reactivex/internal/subscribers/nbp/NbpDisposableSubscriber.java @@ -25,12 +25,9 @@ * @param */ public abstract class NbpDisposableSubscriber implements NbpSubscriber, Disposable { - final AtomicReference s = new AtomicReference(); + final AtomicReference s = new AtomicReference<>(); - static final Disposable CANCELLED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable CANCELLED = () -> { }; @Override public final void onSubscribe(Disposable s) { diff --git a/src/main/java/io/reactivex/internal/subscribers/nbp/NbpEmptySubscriber.java b/rxjava/src/main/java/io/reactivex/internal/subscribers/nbp/NbpEmptySubscriber.java similarity index 100% rename from src/main/java/io/reactivex/internal/subscribers/nbp/NbpEmptySubscriber.java rename to rxjava/src/main/java/io/reactivex/internal/subscribers/nbp/NbpEmptySubscriber.java diff --git a/src/main/java/io/reactivex/internal/subscribers/nbp/NbpLambdaSubscriber.java b/rxjava/src/main/java/io/reactivex/internal/subscribers/nbp/NbpLambdaSubscriber.java similarity index 95% rename from src/main/java/io/reactivex/internal/subscribers/nbp/NbpLambdaSubscriber.java rename to rxjava/src/main/java/io/reactivex/internal/subscribers/nbp/NbpLambdaSubscriber.java index dc20060b84..0eae63a40c 100644 --- a/src/main/java/io/reactivex/internal/subscribers/nbp/NbpLambdaSubscriber.java +++ b/rxjava/src/main/java/io/reactivex/internal/subscribers/nbp/NbpLambdaSubscriber.java @@ -29,10 +29,7 @@ public final class NbpLambdaSubscriber extends AtomicReference im final Runnable onComplete; final Consumer onSubscribe; - static final Disposable CANCELLED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable CANCELLED = () -> { }; public NbpLambdaSubscriber(Consumer onNext, Consumer onError, Runnable onComplete, diff --git a/src/main/java/io/reactivex/internal/subscribers/nbp/NbpQueueDrainSubscriber.java b/rxjava/src/main/java/io/reactivex/internal/subscribers/nbp/NbpQueueDrainSubscriber.java similarity index 100% rename from src/main/java/io/reactivex/internal/subscribers/nbp/NbpQueueDrainSubscriber.java rename to rxjava/src/main/java/io/reactivex/internal/subscribers/nbp/NbpQueueDrainSubscriber.java diff --git a/src/main/java/io/reactivex/internal/subscribers/nbp/NbpSubscriptionLambdaSubscriber.java b/rxjava/src/main/java/io/reactivex/internal/subscribers/nbp/NbpSubscriptionLambdaSubscriber.java similarity index 100% rename from src/main/java/io/reactivex/internal/subscribers/nbp/NbpSubscriptionLambdaSubscriber.java rename to rxjava/src/main/java/io/reactivex/internal/subscribers/nbp/NbpSubscriptionLambdaSubscriber.java diff --git a/src/main/java/io/reactivex/internal/subscribers/nbp/NbpToNotificationSubscriber.java b/rxjava/src/main/java/io/reactivex/internal/subscribers/nbp/NbpToNotificationSubscriber.java similarity index 100% rename from src/main/java/io/reactivex/internal/subscribers/nbp/NbpToNotificationSubscriber.java rename to rxjava/src/main/java/io/reactivex/internal/subscribers/nbp/NbpToNotificationSubscriber.java diff --git a/src/main/java/io/reactivex/internal/subscriptions/AsyncSubscription.java b/rxjava/src/main/java/io/reactivex/internal/subscriptions/AsyncSubscription.java similarity index 97% rename from src/main/java/io/reactivex/internal/subscriptions/AsyncSubscription.java rename to rxjava/src/main/java/io/reactivex/internal/subscriptions/AsyncSubscription.java index 0bae5f22f3..92d3d1d298 100644 --- a/src/main/java/io/reactivex/internal/subscriptions/AsyncSubscription.java +++ b/rxjava/src/main/java/io/reactivex/internal/subscriptions/AsyncSubscription.java @@ -63,8 +63,8 @@ public String toString() { }; public AsyncSubscription() { - resource = new AtomicReference(); - actual = new AtomicReference(); + resource = new AtomicReference<>(); + actual = new AtomicReference<>(); } public AsyncSubscription(Disposable resource) { diff --git a/src/main/java/io/reactivex/internal/subscriptions/BooleanSubscription.java b/rxjava/src/main/java/io/reactivex/internal/subscriptions/BooleanSubscription.java similarity index 100% rename from src/main/java/io/reactivex/internal/subscriptions/BooleanSubscription.java rename to rxjava/src/main/java/io/reactivex/internal/subscriptions/BooleanSubscription.java diff --git a/src/main/java/io/reactivex/internal/subscriptions/DisposableSubscription.java b/rxjava/src/main/java/io/reactivex/internal/subscriptions/DisposableSubscription.java similarity index 96% rename from src/main/java/io/reactivex/internal/subscriptions/DisposableSubscription.java rename to rxjava/src/main/java/io/reactivex/internal/subscriptions/DisposableSubscription.java index 247f08003a..4b97d3e00b 100644 --- a/src/main/java/io/reactivex/internal/subscriptions/DisposableSubscription.java +++ b/rxjava/src/main/java/io/reactivex/internal/subscriptions/DisposableSubscription.java @@ -26,10 +26,7 @@ public final class DisposableSubscription extends AtomicReference im /** */ private static final long serialVersionUID = -2358839743797425727L; /** The disposed state indicator. */ - static final Disposable DISPOSED = new Disposable() { - @Override - public void dispose() { } - }; + static final Disposable DISPOSED = () -> { }; /** * Constructs an empty DisposableSubscription. diff --git a/src/main/java/io/reactivex/internal/subscriptions/EmptySubscription.java b/rxjava/src/main/java/io/reactivex/internal/subscriptions/EmptySubscription.java similarity index 100% rename from src/main/java/io/reactivex/internal/subscriptions/EmptySubscription.java rename to rxjava/src/main/java/io/reactivex/internal/subscriptions/EmptySubscription.java diff --git a/src/main/java/io/reactivex/internal/subscriptions/FullArbiter.java b/rxjava/src/main/java/io/reactivex/internal/subscriptions/FullArbiter.java similarity index 99% rename from src/main/java/io/reactivex/internal/subscriptions/FullArbiter.java rename to rxjava/src/main/java/io/reactivex/internal/subscriptions/FullArbiter.java index add78d936d..79561f21bb 100644 --- a/src/main/java/io/reactivex/internal/subscriptions/FullArbiter.java +++ b/rxjava/src/main/java/io/reactivex/internal/subscriptions/FullArbiter.java @@ -56,7 +56,7 @@ public void cancel() { public FullArbiter(Subscriber actual, Disposable resource, int capacity) { this.actual = actual; this.resource = resource; - this.queue = new SpscLinkedArrayQueue(capacity); + this.queue = new SpscLinkedArrayQueue<>(capacity); this.s = INITIAL; } diff --git a/src/main/java/io/reactivex/internal/subscriptions/ScalarAsyncSubscription.java b/rxjava/src/main/java/io/reactivex/internal/subscriptions/ScalarAsyncSubscription.java similarity index 100% rename from src/main/java/io/reactivex/internal/subscriptions/ScalarAsyncSubscription.java rename to rxjava/src/main/java/io/reactivex/internal/subscriptions/ScalarAsyncSubscription.java diff --git a/src/main/java/io/reactivex/internal/subscriptions/ScalarSubscription.java b/rxjava/src/main/java/io/reactivex/internal/subscriptions/ScalarSubscription.java similarity index 100% rename from src/main/java/io/reactivex/internal/subscriptions/ScalarSubscription.java rename to rxjava/src/main/java/io/reactivex/internal/subscriptions/ScalarSubscription.java diff --git a/src/main/java/io/reactivex/internal/subscriptions/SubscriptionArbiter.java b/rxjava/src/main/java/io/reactivex/internal/subscriptions/SubscriptionArbiter.java similarity index 99% rename from src/main/java/io/reactivex/internal/subscriptions/SubscriptionArbiter.java rename to rxjava/src/main/java/io/reactivex/internal/subscriptions/SubscriptionArbiter.java index 95922f021d..3c1ae6154b 100644 --- a/src/main/java/io/reactivex/internal/subscriptions/SubscriptionArbiter.java +++ b/rxjava/src/main/java/io/reactivex/internal/subscriptions/SubscriptionArbiter.java @@ -42,7 +42,7 @@ public final class SubscriptionArbiter extends AtomicInteger implements Subscrip /** */ private static final long serialVersionUID = -2189523197179400958L; - final Queue missedSubscription = new MpscLinkedQueue(); + final Queue missedSubscription = new MpscLinkedQueue<>(); Subscription actual; long requested; diff --git a/src/main/java/io/reactivex/internal/subscriptions/SubscriptionHelper.java b/rxjava/src/main/java/io/reactivex/internal/subscriptions/SubscriptionHelper.java similarity index 94% rename from src/main/java/io/reactivex/internal/subscriptions/SubscriptionHelper.java rename to rxjava/src/main/java/io/reactivex/internal/subscriptions/SubscriptionHelper.java index b905e08a86..99a8255e6f 100644 --- a/src/main/java/io/reactivex/internal/subscriptions/SubscriptionHelper.java +++ b/rxjava/src/main/java/io/reactivex/internal/subscriptions/SubscriptionHelper.java @@ -93,12 +93,7 @@ public static boolean validateRequest(long n) { } /** Singleton instance of a function which calls cancel on the supplied Subscription. */ - static final Consumer CONSUME_AND_CANCEL = new Consumer() { - @Override - public void accept(Subscription s) { - s.cancel(); - } - }; + static final Consumer CONSUME_AND_CANCEL = Subscription::cancel; /** * Returns a consumer which calls cancel on the supplied Subscription. diff --git a/src/main/java/io/reactivex/internal/util/AppendOnlyLinkedArrayList.java b/rxjava/src/main/java/io/reactivex/internal/util/AppendOnlyLinkedArrayList.java similarity index 100% rename from src/main/java/io/reactivex/internal/util/AppendOnlyLinkedArrayList.java rename to rxjava/src/main/java/io/reactivex/internal/util/AppendOnlyLinkedArrayList.java diff --git a/src/main/java/io/reactivex/internal/util/BackpressureHelper.java b/rxjava/src/main/java/io/reactivex/internal/util/BackpressureHelper.java similarity index 100% rename from src/main/java/io/reactivex/internal/util/BackpressureHelper.java rename to rxjava/src/main/java/io/reactivex/internal/util/BackpressureHelper.java diff --git a/src/main/java/io/reactivex/internal/util/Exceptions.java b/rxjava/src/main/java/io/reactivex/internal/util/Exceptions.java similarity index 100% rename from src/main/java/io/reactivex/internal/util/Exceptions.java rename to rxjava/src/main/java/io/reactivex/internal/util/Exceptions.java diff --git a/src/main/java/io/reactivex/internal/util/LinkedArrayList.java b/rxjava/src/main/java/io/reactivex/internal/util/LinkedArrayList.java similarity index 98% rename from src/main/java/io/reactivex/internal/util/LinkedArrayList.java rename to rxjava/src/main/java/io/reactivex/internal/util/LinkedArrayList.java index 9295f1eeab..9940847817 100644 --- a/src/main/java/io/reactivex/internal/util/LinkedArrayList.java +++ b/rxjava/src/main/java/io/reactivex/internal/util/LinkedArrayList.java @@ -110,7 +110,7 @@ public int capacityHint() { /* Test support */List toList() { final int cap = capacityHint; final int s = size; - final List list = new ArrayList(s + 1); + final List list = new ArrayList<>(s + 1); Object[] h = head(); int j = 0; diff --git a/src/main/java/io/reactivex/internal/util/NbpQueueDrain.java b/rxjava/src/main/java/io/reactivex/internal/util/NbpQueueDrain.java similarity index 100% rename from src/main/java/io/reactivex/internal/util/NbpQueueDrain.java rename to rxjava/src/main/java/io/reactivex/internal/util/NbpQueueDrain.java diff --git a/src/main/java/io/reactivex/internal/util/NotificationLite.java b/rxjava/src/main/java/io/reactivex/internal/util/NotificationLite.java similarity index 100% rename from src/main/java/io/reactivex/internal/util/NotificationLite.java rename to rxjava/src/main/java/io/reactivex/internal/util/NotificationLite.java diff --git a/src/main/java/io/reactivex/internal/util/OpenHashSet.java b/rxjava/src/main/java/io/reactivex/internal/util/OpenHashSet.java similarity index 100% rename from src/main/java/io/reactivex/internal/util/OpenHashSet.java rename to rxjava/src/main/java/io/reactivex/internal/util/OpenHashSet.java diff --git a/src/main/java/io/reactivex/internal/util/Pow2.java b/rxjava/src/main/java/io/reactivex/internal/util/Pow2.java similarity index 100% rename from src/main/java/io/reactivex/internal/util/Pow2.java rename to rxjava/src/main/java/io/reactivex/internal/util/Pow2.java diff --git a/src/main/java/io/reactivex/internal/util/QueueDrain.java b/rxjava/src/main/java/io/reactivex/internal/util/QueueDrain.java similarity index 100% rename from src/main/java/io/reactivex/internal/util/QueueDrain.java rename to rxjava/src/main/java/io/reactivex/internal/util/QueueDrain.java diff --git a/src/main/java/io/reactivex/internal/util/QueueDrainHelper.java b/rxjava/src/main/java/io/reactivex/internal/util/QueueDrainHelper.java similarity index 100% rename from src/main/java/io/reactivex/internal/util/QueueDrainHelper.java rename to rxjava/src/main/java/io/reactivex/internal/util/QueueDrainHelper.java diff --git a/src/main/java/io/reactivex/internal/util/TerminalAtomicsHelper.java b/rxjava/src/main/java/io/reactivex/internal/util/TerminalAtomicsHelper.java similarity index 100% rename from src/main/java/io/reactivex/internal/util/TerminalAtomicsHelper.java rename to rxjava/src/main/java/io/reactivex/internal/util/TerminalAtomicsHelper.java diff --git a/src/main/java/io/reactivex/observables/BlockingObservable.java b/rxjava/src/main/java/io/reactivex/observables/BlockingObservable.java similarity index 89% rename from src/main/java/io/reactivex/observables/BlockingObservable.java rename to rxjava/src/main/java/io/reactivex/observables/BlockingObservable.java index addae0669f..98e6c2e786 100644 --- a/src/main/java/io/reactivex/observables/BlockingObservable.java +++ b/rxjava/src/main/java/io/reactivex/observables/BlockingObservable.java @@ -42,7 +42,7 @@ public static BlockingObservable from(Publisher source) { if (source instanceof BlockingObservable) { return (BlockingObservable)source; } - return new BlockingObservable(source); + return new BlockingObservable<>(source); } @Override @@ -63,38 +63,18 @@ public void forEach(Consumer action) { } static final BlockingIterator iterate(Publisher p) { - final BlockingQueue queue = new LinkedBlockingQueue(); + final BlockingQueue queue = new LinkedBlockingQueue<>(); - LambdaSubscriber ls = new LambdaSubscriber( - new Consumer() { - @Override - public void accept(T v) { - queue.offer(NotificationLite.next(v)); - } - }, - new Consumer() { - @Override - public void accept(Throwable e) { - queue.offer(NotificationLite.error(e)); - } - }, - new Runnable() { - @Override - public void run() { - queue.offer(NotificationLite.complete()); - } - }, - new Consumer() { - @Override - public void accept(Subscription s) { - s.request(Long.MAX_VALUE); - } - } + LambdaSubscriber ls = new LambdaSubscriber<>( + v -> queue.offer(NotificationLite.next(v)), + e -> queue.offer(NotificationLite.error(e)), + () -> queue.offer(NotificationLite.complete()), + s -> s.request(Long.MAX_VALUE) ); p.subscribe(ls); - return new BlockingIterator(queue, ls); + return new BlockingIterator<>(queue, ls); } static final class BlockingIterator implements Iterator, Closeable, Disposable { @@ -171,8 +151,8 @@ public Optional firstOption() { } static Optional firstOption(Publisher o) { - final AtomicReference value = new AtomicReference(); - final AtomicReference error = new AtomicReference(); + final AtomicReference value = new AtomicReference<>(); + final AtomicReference error = new AtomicReference<>(); final CountDownLatch cdl = new CountDownLatch(1); final MultipleAssignmentDisposable mad = new MultipleAssignmentDisposable(); @@ -216,7 +196,7 @@ public void onComplete() { Exceptions.propagate(e); } T v = value.get(); - return v != null ? Optional.of(v) : Optional.empty(); + return v != null ? Optional.of(v) : Optional.empty(); } public T first() { @@ -240,8 +220,8 @@ public Optional lastOption() { } static Optional lastOption(Publisher o) { - final AtomicReference value = new AtomicReference(); - final AtomicReference error = new AtomicReference(); + final AtomicReference value = new AtomicReference<>(); + final AtomicReference error = new AtomicReference<>(); final CountDownLatch cdl = new CountDownLatch(1); final MultipleAssignmentDisposable mad = new MultipleAssignmentDisposable(); @@ -281,7 +261,7 @@ public void onComplete() { Exceptions.propagate(e); } T v = value.get(); - return v != null ? Optional.of(v) : Optional.empty(); + return v != null ? Optional.of(v) : Optional.empty(); } public T last() { @@ -330,8 +310,8 @@ public Iterable latest() { public Future toFuture() { final CountDownLatch cdl = new CountDownLatch(1); - final AtomicReference value = new AtomicReference(); - final AtomicReference error = new AtomicReference(); + final AtomicReference value = new AtomicReference<>(); + final AtomicReference error = new AtomicReference<>(); final MultipleAssignmentDisposable mad = new MultipleAssignmentDisposable(); o.subscribe(new Subscriber() { @@ -436,24 +416,15 @@ private void awaitForComplete(CountDownLatch latch, Disposable subscription) { public void run() { final CountDownLatch cdl = new CountDownLatch(1); final Throwable[] error = { null }; - LambdaSubscriber ls = new LambdaSubscriber(Functions.emptyConsumer(), - new Consumer() { - @Override - public void accept(Throwable e) { + LambdaSubscriber ls = new LambdaSubscriber<>( + Functions.emptyConsumer(), + e -> { error[0] = e; cdl.countDown(); - } - }, new Runnable() { - @Override - public void run() { - cdl.countDown(); - } - }, new Consumer() { - @Override - public void accept(Subscription s) { - s.request(Long.MAX_VALUE); - } - }); + }, + cdl::countDown, + s -> s.request(Long.MAX_VALUE) + ); o.subscribe(ls); @@ -476,9 +447,9 @@ public void accept(Subscription s) { */ @Override public void subscribe(Subscriber subscriber) { - final BlockingQueue queue = new LinkedBlockingQueue(); + final BlockingQueue queue = new LinkedBlockingQueue<>(); - BlockingSubscriber bs = new BlockingSubscriber(queue); + BlockingSubscriber bs = new BlockingSubscriber<>(queue); o.subscribe(bs); diff --git a/src/main/java/io/reactivex/observables/ConnectableObservable.java b/rxjava/src/main/java/io/reactivex/observables/ConnectableObservable.java similarity index 94% rename from src/main/java/io/reactivex/observables/ConnectableObservable.java rename to rxjava/src/main/java/io/reactivex/observables/ConnectableObservable.java index d7e14a222c..fc7dfa73ae 100644 --- a/src/main/java/io/reactivex/observables/ConnectableObservable.java +++ b/rxjava/src/main/java/io/reactivex/observables/ConnectableObservable.java @@ -62,12 +62,7 @@ protected ConnectableObservable(Publisher onSubscribe) { */ public final Disposable connect() { final Disposable[] connection = new Disposable[1]; - connect(new Consumer() { - @Override - public void accept(Disposable d) { - connection[0] = d; - } - }); + connect(d -> connection[0] = d); return connection[0]; } @@ -79,7 +74,7 @@ public void accept(Disposable d) { * @see ReactiveX documentation: RefCount */ public Observable refCount() { - return create(new PublisherRefCount(this)); + return create(new PublisherRefCount<>(this)); } /** @@ -125,6 +120,6 @@ public Observable autoConnect(int numberOfSubscribers, Consumer(this, numberOfSubscribers, connection)); + return create(new PublisherAutoConnect<>(this, numberOfSubscribers, connection)); } } diff --git a/src/main/java/io/reactivex/observables/GroupedObservable.java b/rxjava/src/main/java/io/reactivex/observables/GroupedObservable.java similarity index 100% rename from src/main/java/io/reactivex/observables/GroupedObservable.java rename to rxjava/src/main/java/io/reactivex/observables/GroupedObservable.java diff --git a/src/main/java/io/reactivex/observables/nbp/NbpBlockingObservable.java b/rxjava/src/main/java/io/reactivex/observables/nbp/NbpBlockingObservable.java similarity index 90% rename from src/main/java/io/reactivex/observables/nbp/NbpBlockingObservable.java rename to rxjava/src/main/java/io/reactivex/observables/nbp/NbpBlockingObservable.java index 50f8c2c76c..eb4fa7c9a6 100644 --- a/src/main/java/io/reactivex/observables/nbp/NbpBlockingObservable.java +++ b/rxjava/src/main/java/io/reactivex/observables/nbp/NbpBlockingObservable.java @@ -37,7 +37,7 @@ protected NbpBlockingObservable(NbpObservable source) { } public static NbpBlockingObservable from(NbpObservable source) { - return new NbpBlockingObservable(source); + return new NbpBlockingObservable<>(source); } @Override @@ -58,33 +58,18 @@ public void forEach(Consumer action) { } static final BlockingIterator iterate(NbpObservable p) { - final BlockingQueue queue = new LinkedBlockingQueue(); + final BlockingQueue queue = new LinkedBlockingQueue<>(); - NbpLambdaSubscriber ls = new NbpLambdaSubscriber( - new Consumer() { - @Override - public void accept(T v) { - queue.offer(NotificationLite.next(v)); - } - }, - new Consumer() { - @Override - public void accept(Throwable e) { - queue.offer(NotificationLite.error(e)); - } - }, - new Runnable() { - @Override - public void run() { - queue.offer(NotificationLite.complete()); - } - }, + NbpLambdaSubscriber ls = new NbpLambdaSubscriber<>( + v -> queue.offer(NotificationLite.next(v)), + e -> queue.offer(NotificationLite.error(e)), + () -> queue.offer(NotificationLite.complete()), Functions.emptyConsumer() ); - + p.subscribe(ls); - return new BlockingIterator(queue, ls); + return new BlockingIterator<>(queue, ls); } static final class BlockingIterator implements Iterator, Closeable, Disposable { @@ -161,8 +146,8 @@ public Optional firstOption() { } static Optional firstOption(NbpObservable o) { - final AtomicReference value = new AtomicReference(); - final AtomicReference error = new AtomicReference(); + final AtomicReference value = new AtomicReference<>(); + final AtomicReference error = new AtomicReference<>(); final CountDownLatch cdl = new CountDownLatch(1); final MultipleAssignmentDisposable mad = new MultipleAssignmentDisposable(); @@ -229,8 +214,8 @@ public Optional lastOption() { } static Optional lastOption(NbpObservable o) { - final AtomicReference value = new AtomicReference(); - final AtomicReference error = new AtomicReference(); + final AtomicReference value = new AtomicReference<>(); + final AtomicReference error = new AtomicReference<>(); final CountDownLatch cdl = new CountDownLatch(1); final MultipleAssignmentDisposable mad = new MultipleAssignmentDisposable(); @@ -319,8 +304,8 @@ public Iterable latest() { public Future toFuture() { final CountDownLatch cdl = new CountDownLatch(1); - final AtomicReference value = new AtomicReference(); - final AtomicReference error = new AtomicReference(); + final AtomicReference value = new AtomicReference<>(); + final AtomicReference error = new AtomicReference<>(); final MultipleAssignmentDisposable mad = new MultipleAssignmentDisposable(); o.subscribe(new NbpSubscriber() { @@ -424,20 +409,12 @@ private void awaitForComplete(CountDownLatch latch, Disposable subscription) { public void run() { final CountDownLatch cdl = new CountDownLatch(1); final Throwable[] error = { null }; - NbpLambdaSubscriber ls = new NbpLambdaSubscriber( - Functions.emptyConsumer(), - new Consumer() { - @Override - public void accept(Throwable e) { - error[0] = e; - cdl.countDown(); - } - }, new Runnable() { - @Override - public void run() { - cdl.countDown(); - } - }, Functions.emptyConsumer()); + NbpLambdaSubscriber ls = new NbpLambdaSubscriber<>( + Functions.emptyConsumer(), + e -> { + error[0] = e; + cdl.countDown(); + }, cdl::countDown, Functions.emptyConsumer()); o.subscribe(ls); @@ -459,9 +436,9 @@ public void run() { * @param subscriber the subscriber to forward events and calls to in the current thread */ public void subscribe(NbpSubscriber subscriber) { - final BlockingQueue queue = new LinkedBlockingQueue(); + final BlockingQueue queue = new LinkedBlockingQueue<>(); - NbpBlockingSubscriber bs = new NbpBlockingSubscriber(queue); + NbpBlockingSubscriber bs = new NbpBlockingSubscriber<>(queue); o.subscribe(bs); diff --git a/src/main/java/io/reactivex/observables/nbp/NbpConnectableObservable.java b/rxjava/src/main/java/io/reactivex/observables/nbp/NbpConnectableObservable.java similarity index 94% rename from src/main/java/io/reactivex/observables/nbp/NbpConnectableObservable.java rename to rxjava/src/main/java/io/reactivex/observables/nbp/NbpConnectableObservable.java index 16ca997b5d..6d3aa0a69f 100644 --- a/src/main/java/io/reactivex/observables/nbp/NbpConnectableObservable.java +++ b/rxjava/src/main/java/io/reactivex/observables/nbp/NbpConnectableObservable.java @@ -62,12 +62,7 @@ protected NbpConnectableObservable(NbpOnSubscribe onSubscribe) { */ public final Disposable connect() { final Disposable[] connection = new Disposable[1]; - connect(new Consumer() { - @Override - public void accept(Disposable d) { - connection[0] = d; - } - }); + connect(d -> connection[0] = d); return connection[0]; } @@ -79,7 +74,7 @@ public void accept(Disposable d) { * @see ReactiveX documentation: RefCount */ public NbpObservable refCount() { - return create(new NbpOnSubscribeRefCount(this)); + return create(new NbpOnSubscribeRefCount<>(this)); } /** @@ -125,6 +120,6 @@ public NbpObservable autoConnect(int numberOfSubscribers, Consumer(this, numberOfSubscribers, connection)); + return create(new NbpOnSubscribeAutoConnect<>(this, numberOfSubscribers, connection)); } } diff --git a/src/main/java/io/reactivex/observables/nbp/NbpGroupedObservable.java b/rxjava/src/main/java/io/reactivex/observables/nbp/NbpGroupedObservable.java similarity index 100% rename from src/main/java/io/reactivex/observables/nbp/NbpGroupedObservable.java rename to rxjava/src/main/java/io/reactivex/observables/nbp/NbpGroupedObservable.java diff --git a/src/main/java/io/reactivex/plugins/RxJavaPlugins.java b/rxjava/src/main/java/io/reactivex/plugins/RxJavaPlugins.java similarity index 99% rename from src/main/java/io/reactivex/plugins/RxJavaPlugins.java rename to rxjava/src/main/java/io/reactivex/plugins/RxJavaPlugins.java index 31ae26074b..8a98dee2f5 100644 --- a/src/main/java/io/reactivex/plugins/RxJavaPlugins.java +++ b/rxjava/src/main/java/io/reactivex/plugins/RxJavaPlugins.java @@ -406,12 +406,7 @@ public static void setNbpSubscribeHandler(Function, NbpSubs } /** Singleton consumer that calls RxJavaPlugins.onError. */ - static final Consumer CONSUME_BY_RXJAVA_PLUGIN = new Consumer() { - @Override - public void accept(Throwable e) { - RxJavaPlugins.onError(e); - } - }; + static final Consumer CONSUME_BY_RXJAVA_PLUGIN = RxJavaPlugins::onError; /** * Returns a consumer which relays the received Throwable to RxJavaPlugins.onError(). diff --git a/src/main/java/io/reactivex/schedulers/Schedulers.java b/rxjava/src/main/java/io/reactivex/schedulers/Schedulers.java similarity index 100% rename from src/main/java/io/reactivex/schedulers/Schedulers.java rename to rxjava/src/main/java/io/reactivex/schedulers/Schedulers.java diff --git a/src/main/java/io/reactivex/schedulers/TestScheduler.java b/rxjava/src/main/java/io/reactivex/schedulers/TestScheduler.java similarity index 92% rename from src/main/java/io/reactivex/schedulers/TestScheduler.java rename to rxjava/src/main/java/io/reactivex/schedulers/TestScheduler.java index 129d9c4cb3..65f8cd2f77 100644 --- a/src/main/java/io/reactivex/schedulers/TestScheduler.java +++ b/rxjava/src/main/java/io/reactivex/schedulers/TestScheduler.java @@ -28,7 +28,7 @@ */ public final class TestScheduler extends Scheduler { /** The ordered queue for the runnable tasks. */ - private final Queue queue = new PriorityQueue(11); + private final Queue queue = new PriorityQueue<>(11); /** The per-scheduler global order counter. */ long counter; @@ -141,12 +141,7 @@ public Disposable schedule(Runnable run, long delayTime, TimeUnit unit) { final TimedRunnable timedAction = new TimedRunnable(this, time + unit.toNanos(delayTime), run, counter++); queue.add(timedAction); - return new Disposable() { - @Override - public void dispose() { - queue.remove(timedAction); - } - }; + return () -> queue.remove(timedAction); } @Override @@ -156,12 +151,7 @@ public Disposable schedule(Runnable run) { } final TimedRunnable timedAction = new TimedRunnable(this, 0, run, counter++); queue.add(timedAction); - return new Disposable() { - @Override - public void dispose() { - queue.remove(timedAction); - } - }; + return () -> queue.remove(timedAction); } @Override diff --git a/src/main/java/io/reactivex/schedulers/Timed.java b/rxjava/src/main/java/io/reactivex/schedulers/Timed.java similarity index 100% rename from src/main/java/io/reactivex/schedulers/Timed.java rename to rxjava/src/main/java/io/reactivex/schedulers/Timed.java diff --git a/src/main/java/io/reactivex/subjects/AsyncSubject.java b/rxjava/src/main/java/io/reactivex/subjects/AsyncSubject.java similarity index 98% rename from src/main/java/io/reactivex/subjects/AsyncSubject.java rename to rxjava/src/main/java/io/reactivex/subjects/AsyncSubject.java index 7a8c0febff..4d1f75f2fb 100644 --- a/src/main/java/io/reactivex/subjects/AsyncSubject.java +++ b/rxjava/src/main/java/io/reactivex/subjects/AsyncSubject.java @@ -40,8 +40,8 @@ public final class AsyncSubject extends Subject { * @return the new AsyncSubject instance. */ public static AsyncSubject create() { - State state = new State(); - return new AsyncSubject(state); + State state = new State<>(); + return new AsyncSubject<>(state); } /** The state holding onto the latest value or error and the array of subscribers. */ @@ -188,7 +188,7 @@ static final class State extends AtomicReference /** The array of current subscribers. */ @SuppressWarnings("unchecked") - final AtomicReference[]> subscribers = new AtomicReference[]>(EMPTY); + final AtomicReference[]> subscribers = new AtomicReference<>(EMPTY); /** * Returns the array of current subscribers. @@ -236,7 +236,7 @@ public AsyncSubscription[] apply(int value) { @Override @SuppressWarnings("unchecked") public void subscribe(Subscriber t) { - AsyncSubscription as = new AsyncSubscription(t, this); + AsyncSubscription as = new AsyncSubscription<>(t, this); t.onSubscribe(as); if (add(as)) { diff --git a/src/main/java/io/reactivex/subjects/BehaviorSubject.java b/rxjava/src/main/java/io/reactivex/subjects/BehaviorSubject.java similarity index 97% rename from src/main/java/io/reactivex/subjects/BehaviorSubject.java rename to rxjava/src/main/java/io/reactivex/subjects/BehaviorSubject.java index 5d1c5836ec..afb70229ff 100644 --- a/src/main/java/io/reactivex/subjects/BehaviorSubject.java +++ b/rxjava/src/main/java/io/reactivex/subjects/BehaviorSubject.java @@ -28,16 +28,16 @@ public final class BehaviorSubject extends Subject { public static BehaviorSubject create() { - State state = new State(); - return new BehaviorSubject(state); + State state = new State<>(); + return new BehaviorSubject<>(state); } // TODO a plain create() would create a method ambiguity with Observable.create with javac public static BehaviorSubject createDefault(T defaultValue) { Objects.requireNonNull(defaultValue, "defaultValue is null"); - State state = new State(); + State state = new State<>(); state.lazySet(defaultValue); - return new BehaviorSubject(state); + return new BehaviorSubject<>(state); } final State state; @@ -167,7 +167,7 @@ public State() { this.lock = new ReentrantReadWriteLock(); this.readLock = lock.readLock(); this.writeLock = lock.writeLock(); - this.subscribers = new AtomicReference[]>(EMPTY); + this.subscribers = new AtomicReference<>(EMPTY); } public boolean add(BehaviorSubscription rs) { @@ -237,7 +237,7 @@ public BehaviorSubscription[] terminate(Object terminalValue) { @Override public void subscribe(Subscriber s) { - BehaviorSubscription bs = new BehaviorSubscription(s, this); + BehaviorSubscription bs = new BehaviorSubscription<>(s, this); s.onSubscribe(bs); if (!bs.cancelled) { if (add(bs)) { @@ -406,7 +406,7 @@ void emitNext(Object value, long stateIndex) { if (emitting) { AppendOnlyLinkedArrayList q = queue; if (q == null) { - q = new AppendOnlyLinkedArrayList(4); + q = new AppendOnlyLinkedArrayList<>(4); queue = q; } q.add(value); diff --git a/src/main/java/io/reactivex/subjects/PublishSubject.java b/rxjava/src/main/java/io/reactivex/subjects/PublishSubject.java similarity index 98% rename from src/main/java/io/reactivex/subjects/PublishSubject.java rename to rxjava/src/main/java/io/reactivex/subjects/PublishSubject.java index 78db4506f5..54943c847f 100644 --- a/src/main/java/io/reactivex/subjects/PublishSubject.java +++ b/rxjava/src/main/java/io/reactivex/subjects/PublishSubject.java @@ -46,8 +46,8 @@ public final class PublishSubject extends Subject { * @return the new PublishSubject */ public static PublishSubject create() { - State state = new State(); - return new PublishSubject(state); + State state = new State<>(); + return new PublishSubject<>(state); } /** Holds the terminal event and manages the array of subscribers. */ @@ -178,11 +178,11 @@ static final class State extends AtomicReference /** The array of currently subscribed subscribers. */ @SuppressWarnings("unchecked") - final AtomicReference[]> subscribers = new AtomicReference[]>(EMPTY); + final AtomicReference[]> subscribers = new AtomicReference<>(EMPTY); @Override public void subscribe(Subscriber t) { - PublishSubscriber ps = new PublishSubscriber(t, this); + PublishSubscriber ps = new PublishSubscriber<>(t, this); t.onSubscribe(ps); if (!ps.cancelled.get()) { if (add(ps)) { diff --git a/src/main/java/io/reactivex/subjects/ReplaySubject.java b/rxjava/src/main/java/io/reactivex/subjects/ReplaySubject.java similarity index 97% rename from src/main/java/io/reactivex/subjects/ReplaySubject.java rename to rxjava/src/main/java/io/reactivex/subjects/ReplaySubject.java index 698604bcf1..740f5052cf 100644 --- a/src/main/java/io/reactivex/subjects/ReplaySubject.java +++ b/rxjava/src/main/java/io/reactivex/subjects/ReplaySubject.java @@ -44,7 +44,7 @@ public static ReplaySubject create(int capacityHint) { if (capacityHint <= 0) { throw new IllegalArgumentException("capacityHint > 0 required but it was " + capacityHint); } - ReplayBuffer buffer = new UnboundedReplayBuffer(capacityHint); + ReplayBuffer buffer = new UnboundedReplayBuffer<>(capacityHint); return createWithBuffer(buffer); } @@ -52,12 +52,12 @@ public static ReplaySubject createWithSize(int size) { if (size <= 0) { throw new IllegalArgumentException("size > 0 required but it was " + size); } - SizeBoundReplayBuffer buffer = new SizeBoundReplayBuffer(size); + SizeBoundReplayBuffer buffer = new SizeBoundReplayBuffer<>(size); return createWithBuffer(buffer); } /* test */ static ReplaySubject createUnbounded() { - SizeBoundReplayBuffer buffer = new SizeBoundReplayBuffer(Integer.MAX_VALUE); + SizeBoundReplayBuffer buffer = new SizeBoundReplayBuffer<>(Integer.MAX_VALUE); return createWithBuffer(buffer); } @@ -75,13 +75,13 @@ public static ReplaySubject createWithTimeAndSize(long maxAge, TimeUnit u if (size <= 0) { throw new IllegalArgumentException("size > 0 required but it was " + size); } - SizeAndTimeBoundReplayBuffer buffer = new SizeAndTimeBoundReplayBuffer(size, maxAge, unit, scheduler); + SizeAndTimeBoundReplayBuffer buffer = new SizeAndTimeBoundReplayBuffer<>(size, maxAge, unit, scheduler); return createWithBuffer(buffer); } static ReplaySubject createWithBuffer(ReplayBuffer buffer) { - State state = new State(buffer); - return new ReplaySubject(state); + State state = new State<>(buffer); + return new ReplaySubject<>(state); } @@ -187,12 +187,12 @@ static final class State extends AtomicReference implements Publisher @SuppressWarnings("unchecked") public State(ReplayBuffer buffer) { this.buffer = buffer; - this.subscribers = new AtomicReference[]>(EMPTY); + this.subscribers = new AtomicReference<>(EMPTY); } @Override public void subscribe(Subscriber s) { - ReplaySubscription rs = new ReplaySubscription(s, this); + ReplaySubscription rs = new ReplaySubscription<>(s, this); s.onSubscribe(rs); if (!rs.cancelled) { @@ -383,7 +383,7 @@ static final class UnboundedReplayBuffer implements ReplayBuffer { volatile int size; public UnboundedReplayBuffer(int capacityHint) { - this.buffer = new ArrayList(capacityHint); + this.buffer = new ArrayList<>(capacityHint); } @Override @@ -592,7 +592,7 @@ static final class SizeBoundReplayBuffer implements ReplayBuffer { public SizeBoundReplayBuffer(int maxSize) { this.maxSize = maxSize; - Node h = new Node(null); + Node h = new Node<>(null); this.tail = h; this.head = h; } @@ -608,7 +608,7 @@ void trim() { @Override public void add(T value) { Object o = value; - Node n = new Node(o); + Node n = new Node<>(o); Node t = tail; tail = n; @@ -626,7 +626,7 @@ public void add(T value) { @Override public void addFinal(Object notificationLite) { Object o = notificationLite; - Node n = new Node(o); + Node n = new Node<>(o); Node t = tail; tail = n; @@ -819,7 +819,7 @@ public SizeAndTimeBoundReplayBuffer(int maxSize, long maxAge, TimeUnit unit, Sch this.maxAge = maxAge; this.unit = unit; this.scheduler = scheduler; - TimedNode h = new TimedNode(null, 0L); + TimedNode h = new TimedNode<>(null, 0L); this.tail = h; this.head = h; } @@ -875,7 +875,7 @@ void trimFinal() { @Override public void add(T value) { Object o = value; - TimedNode n = new TimedNode(o, scheduler.now(unit)); + TimedNode n = new TimedNode<>(o, scheduler.now(unit)); TimedNode t = tail; tail = n; @@ -893,7 +893,7 @@ public void add(T value) { @Override public void addFinal(Object notificationLite) { Object o = notificationLite; - TimedNode n = new TimedNode(o, Long.MAX_VALUE); + TimedNode n = new TimedNode<>(o, Long.MAX_VALUE); TimedNode t = tail; tail = n; diff --git a/src/main/java/io/reactivex/subjects/SerializedSubject.java b/rxjava/src/main/java/io/reactivex/subjects/SerializedSubject.java similarity index 89% rename from src/main/java/io/reactivex/subjects/SerializedSubject.java rename to rxjava/src/main/java/io/reactivex/subjects/SerializedSubject.java index cf3f41c3bf..17d8ed3e37 100644 --- a/src/main/java/io/reactivex/subjects/SerializedSubject.java +++ b/rxjava/src/main/java/io/reactivex/subjects/SerializedSubject.java @@ -41,12 +41,7 @@ * @param actual the subject wrapped */ public SerializedSubject(final Subject actual) { - super(new Publisher() { - @Override - public void subscribe(Subscriber s) { - actual.subscribe(s); - } - }); + super(actual::subscribe); this.actual = actual; } @@ -62,7 +57,7 @@ public void onSubscribe(Subscription s) { if (emitting) { AppendOnlyLinkedArrayList q = queue; if (q == null) { - q = new AppendOnlyLinkedArrayList(4); + q = new AppendOnlyLinkedArrayList<>(4); queue = q; } q.add(NotificationLite.subscription(s)); @@ -86,7 +81,7 @@ public void onNext(T t) { if (emitting) { AppendOnlyLinkedArrayList q = queue; if (q == null) { - q = new AppendOnlyLinkedArrayList(4); + q = new AppendOnlyLinkedArrayList<>(4); queue = q; } q.add(NotificationLite.next(t)); @@ -114,7 +109,7 @@ public void onError(Throwable t) { if (emitting) { AppendOnlyLinkedArrayList q = queue; if (q == null) { - q = new AppendOnlyLinkedArrayList(4); + q = new AppendOnlyLinkedArrayList<>(4); queue = q; } q.setFirst(NotificationLite.error(t)); @@ -144,7 +139,7 @@ public void onComplete() { if (emitting) { AppendOnlyLinkedArrayList q = queue; if (q == null) { - q = new AppendOnlyLinkedArrayList(4); + q = new AppendOnlyLinkedArrayList<>(4); queue = q; } q.add(NotificationLite.complete()); @@ -171,12 +166,7 @@ void emitLoop() { } } - final Predicate consumer = new Predicate() { - @Override - public boolean test(Object v) { - return SerializedSubject.this.accept(v); - } - }; + final Predicate consumer = this::accept; /** Delivers the notification to the actual subscriber. */ boolean accept(Object o) { diff --git a/src/main/java/io/reactivex/subjects/Subject.java b/rxjava/src/main/java/io/reactivex/subjects/Subject.java similarity index 98% rename from src/main/java/io/reactivex/subjects/Subject.java rename to rxjava/src/main/java/io/reactivex/subjects/Subject.java index f912b51b02..ce9ca43450 100644 --- a/src/main/java/io/reactivex/subjects/Subject.java +++ b/rxjava/src/main/java/io/reactivex/subjects/Subject.java @@ -99,7 +99,7 @@ public final Subject toSerialized() { if (this instanceof SerializedSubject) { return this; } - return new SerializedSubject(this); + return new SerializedSubject<>(this); } /** An empty array to avoid allocation in getValues(). */ diff --git a/src/main/java/io/reactivex/subjects/UnicastSubject.java b/rxjava/src/main/java/io/reactivex/subjects/UnicastSubject.java similarity index 98% rename from src/main/java/io/reactivex/subjects/UnicastSubject.java rename to rxjava/src/main/java/io/reactivex/subjects/UnicastSubject.java index ea273ce8b8..0a68f06773 100644 --- a/src/main/java/io/reactivex/subjects/UnicastSubject.java +++ b/rxjava/src/main/java/io/reactivex/subjects/UnicastSubject.java @@ -70,8 +70,8 @@ public static UnicastSubject create(int capacityHint) { * @return an UnicastSubject instance */ public static UnicastSubject create(int capacityHint, Runnable onCancelled) { - State state = new State(capacityHint, onCancelled); - return new UnicastSubject(state); + State state = new State<>(capacityHint, onCancelled); + return new UnicastSubject<>(state); } /** The subject state. */ @@ -123,7 +123,7 @@ static final class State extends StatePad1 implements Publisher, Subscript final Queue queue; /** The single subscriber. */ - final AtomicReference> subscriber = new AtomicReference>(); + final AtomicReference> subscriber = new AtomicReference<>(); /** Indicates the single subscriber has cancelled. */ volatile boolean cancelled; @@ -153,7 +153,7 @@ static final class State extends StatePad1 implements Publisher, Subscript */ public State(int capacityHint, Runnable onCancelled) { this.onCancelled = onCancelled; - queue = new SpscLinkedArrayQueue(capacityHint); + queue = new SpscLinkedArrayQueue<>(capacityHint); } @Override diff --git a/src/main/java/io/reactivex/subjects/nbp/NbpAsyncSubject.java b/rxjava/src/main/java/io/reactivex/subjects/nbp/NbpAsyncSubject.java similarity index 96% rename from src/main/java/io/reactivex/subjects/nbp/NbpAsyncSubject.java rename to rxjava/src/main/java/io/reactivex/subjects/nbp/NbpAsyncSubject.java index 9f8ccd389a..e570993835 100644 --- a/src/main/java/io/reactivex/subjects/nbp/NbpAsyncSubject.java +++ b/rxjava/src/main/java/io/reactivex/subjects/nbp/NbpAsyncSubject.java @@ -34,8 +34,8 @@ public final class NbpAsyncSubject extends NbpSubject { public static NbpAsyncSubject create() { - State state = new State(); - return new NbpAsyncSubject(state); + State state = new State<>(); + return new NbpAsyncSubject<>(state); } final State state; @@ -152,7 +152,7 @@ static final class State extends AtomicReference implements NbpOnSubs @SuppressWarnings("unchecked") public State() { - subscribers = new AtomicReference[]>(EMPTY); + subscribers = new AtomicReference<>(EMPTY); } boolean add(NbpSubscriber s) { @@ -232,12 +232,7 @@ void emit(NbpSubscriber t, Object v) { @Override public void accept(final NbpSubscriber t) { - BooleanDisposable bd = new BooleanDisposable(new Runnable() { - @Override - public void run() { - remove(t); - } - }); + BooleanDisposable bd = new BooleanDisposable(() -> remove(t)); t.onSubscribe(bd); if (add(t)) { if (bd.isDisposed()) { diff --git a/src/main/java/io/reactivex/subjects/nbp/NbpBehaviorSubject.java b/rxjava/src/main/java/io/reactivex/subjects/nbp/NbpBehaviorSubject.java similarity index 96% rename from src/main/java/io/reactivex/subjects/nbp/NbpBehaviorSubject.java rename to rxjava/src/main/java/io/reactivex/subjects/nbp/NbpBehaviorSubject.java index 10707bc80d..4c2507382d 100644 --- a/src/main/java/io/reactivex/subjects/nbp/NbpBehaviorSubject.java +++ b/rxjava/src/main/java/io/reactivex/subjects/nbp/NbpBehaviorSubject.java @@ -26,16 +26,16 @@ public final class NbpBehaviorSubject extends NbpSubject { public static NbpBehaviorSubject create() { - State state = new State(); - return new NbpBehaviorSubject(state); + State state = new State<>(); + return new NbpBehaviorSubject<>(state); } // A plain create(T) would create a method ambiguity with Observable.create with javac public static NbpBehaviorSubject createDefault(T defaultValue) { Objects.requireNonNull(defaultValue, "defaultValue is null"); - State state = new State(); + State state = new State<>(); state.lazySet(defaultValue); - return new NbpBehaviorSubject(state); + return new NbpBehaviorSubject<>(state); } final State state; @@ -165,7 +165,7 @@ public State() { this.lock = new ReentrantReadWriteLock(); this.readLock = lock.readLock(); this.writeLock = lock.writeLock(); - this.subscribers = new AtomicReference[]>(EMPTY); + this.subscribers = new AtomicReference<>(EMPTY); } public boolean add(BehaviorDisposable rs) { @@ -235,7 +235,7 @@ public BehaviorDisposable[] terminate(Object terminalValue) { @Override public void accept(NbpSubscriber s) { - BehaviorDisposable bs = new BehaviorDisposable(s, this); + BehaviorDisposable bs = new BehaviorDisposable<>(s, this); s.onSubscribe(bs); if (!bs.cancelled) { if (add(bs)) { @@ -392,7 +392,7 @@ void emitNext(Object value, long stateIndex) { if (emitting) { AppendOnlyLinkedArrayList q = queue; if (q == null) { - q = new AppendOnlyLinkedArrayList(4); + q = new AppendOnlyLinkedArrayList<>(4); queue = q; } q.add(value); diff --git a/src/main/java/io/reactivex/subjects/nbp/NbpPublishSubject.java b/rxjava/src/main/java/io/reactivex/subjects/nbp/NbpPublishSubject.java similarity index 95% rename from src/main/java/io/reactivex/subjects/nbp/NbpPublishSubject.java rename to rxjava/src/main/java/io/reactivex/subjects/nbp/NbpPublishSubject.java index 4c07c6a086..68b1e5f629 100644 --- a/src/main/java/io/reactivex/subjects/nbp/NbpPublishSubject.java +++ b/rxjava/src/main/java/io/reactivex/subjects/nbp/NbpPublishSubject.java @@ -22,8 +22,8 @@ public final class NbpPublishSubject extends NbpSubject { public static NbpPublishSubject create() { - State state = new State(); - return new NbpPublishSubject(state); + State state = new State<>(); + return new NbpPublishSubject<>(state); } final State state; @@ -101,7 +101,7 @@ static final class State extends AtomicReference implements NbpOnSubs /** */ private static final long serialVersionUID = 4876574210612691772L; - final AtomicReference[]> subscribers = new AtomicReference[]>(); + final AtomicReference[]> subscribers = new AtomicReference<>(); @SuppressWarnings("rawtypes") static final NbpSubscriber[] EMPTY = new NbpSubscriber[0]; @@ -194,12 +194,7 @@ public void accept(final NbpSubscriber t) { emit(t, v); return; } - BooleanDisposable bd = new BooleanDisposable(new Runnable() { - @Override - public void run() { - remove(t); - } - }); + BooleanDisposable bd = new BooleanDisposable(() -> remove(t)); t.onSubscribe(bd); if (add(t)) { if (bd.isDisposed()) { diff --git a/src/main/java/io/reactivex/subjects/nbp/NbpReplaySubject.java b/rxjava/src/main/java/io/reactivex/subjects/nbp/NbpReplaySubject.java similarity index 97% rename from src/main/java/io/reactivex/subjects/nbp/NbpReplaySubject.java rename to rxjava/src/main/java/io/reactivex/subjects/nbp/NbpReplaySubject.java index dc2c1a7f2d..8988fb502b 100644 --- a/src/main/java/io/reactivex/subjects/nbp/NbpReplaySubject.java +++ b/rxjava/src/main/java/io/reactivex/subjects/nbp/NbpReplaySubject.java @@ -42,7 +42,7 @@ public static NbpReplaySubject create(int capacityHint) { if (capacityHint <= 0) { throw new IllegalArgumentException("capacityHint > 0 required but it was " + capacityHint); } - ReplayBuffer buffer = new UnboundedReplayBuffer(capacityHint); + ReplayBuffer buffer = new UnboundedReplayBuffer<>(capacityHint); return createWithBuffer(buffer); } @@ -50,12 +50,12 @@ public static NbpReplaySubject createWithSize(int size) { if (size <= 0) { throw new IllegalArgumentException("size > 0 required but it was " + size); } - SizeBoundReplayBuffer buffer = new SizeBoundReplayBuffer(size); + SizeBoundReplayBuffer buffer = new SizeBoundReplayBuffer<>(size); return createWithBuffer(buffer); } /* test */ static NbpReplaySubject createUnbounded() { - SizeBoundReplayBuffer buffer = new SizeBoundReplayBuffer(Integer.MAX_VALUE); + SizeBoundReplayBuffer buffer = new SizeBoundReplayBuffer<>(Integer.MAX_VALUE); return createWithBuffer(buffer); } @@ -73,13 +73,13 @@ public static NbpReplaySubject createWithTimeAndSize(long maxAge, TimeUni if (size <= 0) { throw new IllegalArgumentException("size > 0 required but it was " + size); } - SizeAndTimeBoundReplayBuffer buffer = new SizeAndTimeBoundReplayBuffer(size, maxAge, unit, scheduler); + SizeAndTimeBoundReplayBuffer buffer = new SizeAndTimeBoundReplayBuffer<>(size, maxAge, unit, scheduler); return createWithBuffer(buffer); } static NbpReplaySubject createWithBuffer(ReplayBuffer buffer) { - State state = new State(buffer); - return new NbpReplaySubject(state); + State state = new State<>(buffer); + return new NbpReplaySubject<>(state); } @@ -174,7 +174,7 @@ static final class State extends AtomicReference implements NbpOnSubs boolean done; - final AtomicReference[]> subscribers = new AtomicReference[]>(); + final AtomicReference[]> subscribers = new AtomicReference<>(); @SuppressWarnings("rawtypes") static final ReplayDisposable[] EMPTY = new ReplayDisposable[0]; @@ -190,7 +190,7 @@ public State(ReplayBuffer buffer) { @Override public void accept(NbpSubscriber s) { - ReplayDisposable rs = new ReplayDisposable(s, this); + ReplayDisposable rs = new ReplayDisposable<>(s, this); s.onSubscribe(rs); if (!rs.cancelled) { @@ -369,7 +369,7 @@ static final class UnboundedReplayBuffer implements ReplayBuffer { volatile int size; public UnboundedReplayBuffer(int capacityHint) { - this.buffer = new ArrayList(capacityHint); + this.buffer = new ArrayList<>(capacityHint); } @Override @@ -561,7 +561,7 @@ static final class SizeBoundReplayBuffer implements ReplayBuffer { public SizeBoundReplayBuffer(int maxSize) { this.maxSize = maxSize; - Node h = new Node(null); + Node h = new Node<>(null); this.tail = h; this.head = h; } @@ -577,7 +577,7 @@ void trim() { @Override public void add(T value) { Object o = value; - Node n = new Node(o); + Node n = new Node<>(o); Node t = tail; tail = n; @@ -595,7 +595,7 @@ public void add(T value) { @Override public void addFinal(Object notificationLite) { Object o = notificationLite; - Node n = new Node(o); + Node n = new Node<>(o); Node t = tail; tail = n; @@ -769,7 +769,7 @@ public SizeAndTimeBoundReplayBuffer(int maxSize, long maxAge, TimeUnit unit, Sch this.maxAge = maxAge; this.unit = unit; this.scheduler = scheduler; - TimedNode h = new TimedNode(null, 0L); + TimedNode h = new TimedNode<>(null, 0L); this.tail = h; this.head = h; } @@ -825,7 +825,7 @@ void trimFinal() { @Override public void add(T value) { Object o = value; - TimedNode n = new TimedNode(o, scheduler.now(unit)); + TimedNode n = new TimedNode<>(o, scheduler.now(unit)); TimedNode t = tail; tail = n; @@ -843,7 +843,7 @@ public void add(T value) { @Override public void addFinal(Object notificationLite) { Object o = notificationLite; - TimedNode n = new TimedNode(o, Long.MAX_VALUE); + TimedNode n = new TimedNode<>(o, Long.MAX_VALUE); TimedNode t = tail; tail = n; diff --git a/src/main/java/io/reactivex/subjects/nbp/NbpSerializedSubject.java b/rxjava/src/main/java/io/reactivex/subjects/nbp/NbpSerializedSubject.java similarity index 89% rename from src/main/java/io/reactivex/subjects/nbp/NbpSerializedSubject.java rename to rxjava/src/main/java/io/reactivex/subjects/nbp/NbpSerializedSubject.java index ff32dadb15..9a629a9354 100644 --- a/src/main/java/io/reactivex/subjects/nbp/NbpSerializedSubject.java +++ b/rxjava/src/main/java/io/reactivex/subjects/nbp/NbpSerializedSubject.java @@ -40,12 +40,7 @@ * @param actual the subject wrapped */ public NbpSerializedSubject(final NbpSubject actual) { - super(new io.reactivex.NbpObservable.NbpOnSubscribe() { - @Override - public void accept(io.reactivex.NbpObservable.NbpSubscriber s) { - actual.subscribe(s); - } - }); + super(actual::subscribe); this.actual = actual; } @@ -66,7 +61,7 @@ public void onNext(T t) { if (emitting) { AppendOnlyLinkedArrayList q = queue; if (q == null) { - q = new AppendOnlyLinkedArrayList(4); + q = new AppendOnlyLinkedArrayList<>(4); queue = q; } q.add(NotificationLite.next(t)); @@ -94,7 +89,7 @@ public void onError(Throwable t) { if (emitting) { AppendOnlyLinkedArrayList q = queue; if (q == null) { - q = new AppendOnlyLinkedArrayList(4); + q = new AppendOnlyLinkedArrayList<>(4); queue = q; } q.setFirst(NotificationLite.error(t)); @@ -124,7 +119,7 @@ public void onComplete() { if (emitting) { AppendOnlyLinkedArrayList q = queue; if (q == null) { - q = new AppendOnlyLinkedArrayList(4); + q = new AppendOnlyLinkedArrayList<>(4); queue = q; } q.add(NotificationLite.complete()); @@ -151,12 +146,7 @@ void emitLoop() { } } - final Predicate consumer = new Predicate() { - @Override - public boolean test(Object v) { - return accept(v); - } - }; + final Predicate consumer = this::accept; /** Delivers the notification to the actual subscriber. */ boolean accept(Object o) { diff --git a/src/main/java/io/reactivex/subjects/nbp/NbpSubject.java b/rxjava/src/main/java/io/reactivex/subjects/nbp/NbpSubject.java similarity index 98% rename from src/main/java/io/reactivex/subjects/nbp/NbpSubject.java rename to rxjava/src/main/java/io/reactivex/subjects/nbp/NbpSubject.java index b30aa892d7..117da6108a 100644 --- a/src/main/java/io/reactivex/subjects/nbp/NbpSubject.java +++ b/rxjava/src/main/java/io/reactivex/subjects/nbp/NbpSubject.java @@ -98,7 +98,7 @@ public final NbpSubject toSerialized() { if (this instanceof NbpSerializedSubject) { return this; } - return new NbpSerializedSubject(this); + return new NbpSerializedSubject<>(this); } /** An empty array to avoid allocation in getValues(). */ diff --git a/src/main/java/io/reactivex/subjects/nbp/NbpUnicastSubject.java b/rxjava/src/main/java/io/reactivex/subjects/nbp/NbpUnicastSubject.java similarity index 97% rename from src/main/java/io/reactivex/subjects/nbp/NbpUnicastSubject.java rename to rxjava/src/main/java/io/reactivex/subjects/nbp/NbpUnicastSubject.java index 2efca09044..388c67f30c 100644 --- a/src/main/java/io/reactivex/subjects/nbp/NbpUnicastSubject.java +++ b/rxjava/src/main/java/io/reactivex/subjects/nbp/NbpUnicastSubject.java @@ -68,8 +68,8 @@ public static NbpUnicastSubject create(int capacityHint) { * @return an UnicastSubject instance */ public static NbpUnicastSubject create(int capacityHint, Runnable onCancelled) { - State state = new State(capacityHint, onCancelled); - return new NbpUnicastSubject(state); + State state = new State<>(capacityHint, onCancelled); + return new NbpUnicastSubject<>(state); } /** The subject state. */ @@ -103,7 +103,7 @@ static final class State extends StatePad0 implements NbpOnSubscribe, Disp final Queue queue; /** The single subscriber. */ - final AtomicReference> subscriber = new AtomicReference>(); + final AtomicReference> subscriber = new AtomicReference<>(); /** Indicates the single subscriber has cancelled. */ volatile boolean cancelled; @@ -133,7 +133,7 @@ static final class State extends StatePad0 implements NbpOnSubscribe, Disp */ public State(int capacityHint, Runnable onCancelled) { this.onCancelled = onCancelled; - queue = new SpscLinkedArrayQueue(capacityHint); + queue = new SpscLinkedArrayQueue<>(capacityHint); } @Override diff --git a/src/main/java/io/reactivex/subscribers/AsyncObserver.java b/rxjava/src/main/java/io/reactivex/subscribers/AsyncObserver.java similarity index 98% rename from src/main/java/io/reactivex/subscribers/AsyncObserver.java rename to rxjava/src/main/java/io/reactivex/subscribers/AsyncObserver.java index ffbb66b386..c3a4ea4958 100644 --- a/src/main/java/io/reactivex/subscribers/AsyncObserver.java +++ b/rxjava/src/main/java/io/reactivex/subscribers/AsyncObserver.java @@ -69,9 +69,9 @@ public AsyncObserver() { * @param withResources true if resource support should be on. */ public AsyncObserver(boolean withResources) { - this.resources = withResources ? new ListCompositeResource(Disposables.consumeAndDispose()) : null; + this.resources = withResources ? new ListCompositeResource<>(Disposables.consumeAndDispose()) : null; this.missedRequested = new AtomicLong(); - this.s = new AtomicReference(); + this.s = new AtomicReference<>(); } /** diff --git a/src/main/java/io/reactivex/subscribers/Observers.java b/rxjava/src/main/java/io/reactivex/subscribers/Observers.java similarity index 100% rename from src/main/java/io/reactivex/subscribers/Observers.java rename to rxjava/src/main/java/io/reactivex/subscribers/Observers.java diff --git a/src/main/java/io/reactivex/subscribers/SafeSubscriber.java b/rxjava/src/main/java/io/reactivex/subscribers/SafeSubscriber.java similarity index 100% rename from src/main/java/io/reactivex/subscribers/SafeSubscriber.java rename to rxjava/src/main/java/io/reactivex/subscribers/SafeSubscriber.java diff --git a/src/main/java/io/reactivex/subscribers/SerializedSubscriber.java b/rxjava/src/main/java/io/reactivex/subscribers/SerializedSubscriber.java similarity index 92% rename from src/main/java/io/reactivex/subscribers/SerializedSubscriber.java rename to rxjava/src/main/java/io/reactivex/subscribers/SerializedSubscriber.java index 4bb7ad9340..074913a83e 100644 --- a/src/main/java/io/reactivex/subscribers/SerializedSubscriber.java +++ b/rxjava/src/main/java/io/reactivex/subscribers/SerializedSubscriber.java @@ -78,7 +78,7 @@ public void onNext(T t) { if (emitting) { AppendOnlyLinkedArrayList q = queue; if (q == null) { - q = new AppendOnlyLinkedArrayList(QUEUE_LINK_SIZE); + q = new AppendOnlyLinkedArrayList<>(QUEUE_LINK_SIZE); queue = q; } q.add(NotificationLite.next(t)); @@ -107,7 +107,7 @@ public void onError(Throwable t) { done = true; AppendOnlyLinkedArrayList q = queue; if (q == null) { - q = new AppendOnlyLinkedArrayList(QUEUE_LINK_SIZE); + q = new AppendOnlyLinkedArrayList<>(QUEUE_LINK_SIZE); queue = q; } Object err = NotificationLite.error(t); @@ -145,7 +145,7 @@ public void onComplete() { if (emitting) { AppendOnlyLinkedArrayList q = queue; if (q == null) { - q = new AppendOnlyLinkedArrayList(QUEUE_LINK_SIZE); + q = new AppendOnlyLinkedArrayList<>(QUEUE_LINK_SIZE); queue = q; } q.add(NotificationLite.complete()); @@ -175,12 +175,7 @@ void emitLoop() { } } - final Predicate consumer = new Predicate() { - @Override - public boolean test(Object v) { - return accept(v); - } - }; + final Predicate consumer = this::accept; boolean accept(Object value) { return NotificationLite.accept(value, actual); diff --git a/src/main/java/io/reactivex/subscribers/Subscribers.java b/rxjava/src/main/java/io/reactivex/subscribers/Subscribers.java similarity index 97% rename from src/main/java/io/reactivex/subscribers/Subscribers.java rename to rxjava/src/main/java/io/reactivex/subscribers/Subscribers.java index 5aef09cebc..73e0c6d0bd 100644 --- a/src/main/java/io/reactivex/subscribers/Subscribers.java +++ b/rxjava/src/main/java/io/reactivex/subscribers/Subscribers.java @@ -157,12 +157,7 @@ public void onComplete() { }; } - static final Consumer REQUEST_ALL = new Consumer() { - @Override - public void accept(Subscription t) { - t.request(Long.MAX_VALUE); - } - }; + static final Consumer REQUEST_ALL = t -> t.request(Long.MAX_VALUE); public static Subscriber create( Consumer onNext diff --git a/src/main/java/io/reactivex/subscribers/TestSubscriber.java b/rxjava/src/main/java/io/reactivex/subscribers/TestSubscriber.java similarity index 98% rename from src/main/java/io/reactivex/subscribers/TestSubscriber.java rename to rxjava/src/main/java/io/reactivex/subscribers/TestSubscriber.java index cd2ed205d8..814d288bf7 100644 --- a/src/main/java/io/reactivex/subscribers/TestSubscriber.java +++ b/rxjava/src/main/java/io/reactivex/subscribers/TestSubscriber.java @@ -59,7 +59,7 @@ public class TestSubscriber implements Subscriber, Subscription, Disposabl private volatile boolean cancelled; /** Holds the current subscription if any. */ - private final AtomicReference subscription = new AtomicReference(); + private final AtomicReference subscription = new AtomicReference<>(); /** Holds the requested amount until a subscription arrives. */ private final AtomicLong missedRequested = new AtomicLong(); @@ -113,8 +113,8 @@ public TestSubscriber(Subscriber actual) { public TestSubscriber(Subscriber actual, Long initialRequest) { this.actual = actual; this.initialRequest = initialRequest; - this.values = new ArrayList(); - this.errors = new ArrayList(); + this.values = new ArrayList<>(); + this.errors = new ArrayList<>(); this.done = new CountDownLatch(1); } @@ -747,13 +747,13 @@ public void assertErrorMessage(String message) { */ @SuppressWarnings({ "rawtypes", "unchecked" }) public List> getEvents() { - List> result = new ArrayList>(); + List> result = new ArrayList<>(); result.add((List)values()); result.add((List)errors()); - List completeList = new ArrayList(); + List completeList = new ArrayList<>(); for (long i = 0; i < completions; i++) { completeList.add(Notification.complete()); } diff --git a/src/main/java/io/reactivex/subscribers/completable/CompletableSerializedSubscriber.java b/rxjava/src/main/java/io/reactivex/subscribers/completable/CompletableSerializedSubscriber.java similarity index 100% rename from src/main/java/io/reactivex/subscribers/completable/CompletableSerializedSubscriber.java rename to rxjava/src/main/java/io/reactivex/subscribers/completable/CompletableSerializedSubscriber.java diff --git a/src/main/java/io/reactivex/subscribers/nbp/NbpAsyncObserver.java b/rxjava/src/main/java/io/reactivex/subscribers/nbp/NbpAsyncObserver.java similarity index 95% rename from src/main/java/io/reactivex/subscribers/nbp/NbpAsyncObserver.java rename to rxjava/src/main/java/io/reactivex/subscribers/nbp/NbpAsyncObserver.java index 3e72165d77..4b8e23dffc 100644 --- a/src/main/java/io/reactivex/subscribers/nbp/NbpAsyncObserver.java +++ b/rxjava/src/main/java/io/reactivex/subscribers/nbp/NbpAsyncObserver.java @@ -34,16 +34,13 @@ */ public abstract class NbpAsyncObserver implements NbpSubscriber, Disposable { /** The active subscription. */ - private final AtomicReference s = new AtomicReference(); + private final AtomicReference s = new AtomicReference<>(); /** The resource composite, can be null. */ private final ListCompositeResource resources; /** The cancelled subscription indicator. */ - private static final Disposable CANCELLED = new Disposable() { - @Override - public void dispose() { } - }; + private static final Disposable CANCELLED = () -> { }; /** * Constructs an AsyncObserver with resource support. @@ -57,7 +54,7 @@ public NbpAsyncObserver() { * @param withResources true if resource support should be on. */ public NbpAsyncObserver(boolean withResources) { - this.resources = withResources ? new ListCompositeResource(Disposables.consumeAndDispose()) : null; + this.resources = withResources ? new ListCompositeResource<>(Disposables.consumeAndDispose()) : null; } /** diff --git a/src/main/java/io/reactivex/subscribers/nbp/NbpObservers.java b/rxjava/src/main/java/io/reactivex/subscribers/nbp/NbpObservers.java similarity index 100% rename from src/main/java/io/reactivex/subscribers/nbp/NbpObservers.java rename to rxjava/src/main/java/io/reactivex/subscribers/nbp/NbpObservers.java diff --git a/src/main/java/io/reactivex/subscribers/nbp/NbpSafeSubscriber.java b/rxjava/src/main/java/io/reactivex/subscribers/nbp/NbpSafeSubscriber.java similarity index 100% rename from src/main/java/io/reactivex/subscribers/nbp/NbpSafeSubscriber.java rename to rxjava/src/main/java/io/reactivex/subscribers/nbp/NbpSafeSubscriber.java diff --git a/src/main/java/io/reactivex/subscribers/nbp/NbpSerializedSubscriber.java b/rxjava/src/main/java/io/reactivex/subscribers/nbp/NbpSerializedSubscriber.java similarity index 92% rename from src/main/java/io/reactivex/subscribers/nbp/NbpSerializedSubscriber.java rename to rxjava/src/main/java/io/reactivex/subscribers/nbp/NbpSerializedSubscriber.java index 31766924e2..83637e6e85 100644 --- a/src/main/java/io/reactivex/subscribers/nbp/NbpSerializedSubscriber.java +++ b/rxjava/src/main/java/io/reactivex/subscribers/nbp/NbpSerializedSubscriber.java @@ -77,7 +77,7 @@ public void onNext(T t) { if (emitting) { AppendOnlyLinkedArrayList q = queue; if (q == null) { - q = new AppendOnlyLinkedArrayList(QUEUE_LINK_SIZE); + q = new AppendOnlyLinkedArrayList<>(QUEUE_LINK_SIZE); queue = q; } q.add(NotificationLite.next(t)); @@ -106,7 +106,7 @@ public void onError(Throwable t) { done = true; AppendOnlyLinkedArrayList q = queue; if (q == null) { - q = new AppendOnlyLinkedArrayList(QUEUE_LINK_SIZE); + q = new AppendOnlyLinkedArrayList<>(QUEUE_LINK_SIZE); queue = q; } Object err = NotificationLite.error(t); @@ -144,7 +144,7 @@ public void onComplete() { if (emitting) { AppendOnlyLinkedArrayList q = queue; if (q == null) { - q = new AppendOnlyLinkedArrayList(QUEUE_LINK_SIZE); + q = new AppendOnlyLinkedArrayList<>(QUEUE_LINK_SIZE); queue = q; } q.add(NotificationLite.complete()); @@ -174,12 +174,7 @@ void emitLoop() { } } - final Predicate consumer = new Predicate() { - @Override - public boolean test(Object v) { - return accept(v); - } - }; + final Predicate consumer = this::accept; boolean accept(Object value) { diff --git a/src/main/java/io/reactivex/subscribers/nbp/NbpSubscribers.java b/rxjava/src/main/java/io/reactivex/subscribers/nbp/NbpSubscribers.java similarity index 100% rename from src/main/java/io/reactivex/subscribers/nbp/NbpSubscribers.java rename to rxjava/src/main/java/io/reactivex/subscribers/nbp/NbpSubscribers.java diff --git a/src/main/java/io/reactivex/subscribers/nbp/NbpTestSubscriber.java b/rxjava/src/main/java/io/reactivex/subscribers/nbp/NbpTestSubscriber.java similarity index 98% rename from src/main/java/io/reactivex/subscribers/nbp/NbpTestSubscriber.java rename to rxjava/src/main/java/io/reactivex/subscribers/nbp/NbpTestSubscriber.java index 704200f41b..84ee5e2e6c 100644 --- a/src/main/java/io/reactivex/subscribers/nbp/NbpTestSubscriber.java +++ b/rxjava/src/main/java/io/reactivex/subscribers/nbp/NbpTestSubscriber.java @@ -54,13 +54,10 @@ public class NbpTestSubscriber implements NbpSubscriber, Disposable { private volatile boolean cancelled; /** Holds the current subscription if any. */ - private final AtomicReference subscription = new AtomicReference(); + private final AtomicReference subscription = new AtomicReference<>(); /** Indicates a cancelled subscription. */ - private static final Disposable CANCELLED = new Disposable() { - @Override - public void dispose() { } - }; + private static final Disposable CANCELLED = () -> { }; private boolean checkSubscriptionOnce; @@ -77,8 +74,8 @@ public NbpTestSubscriber() { */ public NbpTestSubscriber(NbpSubscriber actual) { this.actual = actual; - this.values = new ArrayList(); - this.errors = new ArrayList(); + this.values = new ArrayList<>(); + this.errors = new ArrayList<>(); this.done = new CountDownLatch(1); } @@ -680,13 +677,13 @@ public void assertErrorMessage(String message) { */ @SuppressWarnings({ "rawtypes", "unchecked" }) public List> getEvents() { - List> result = new ArrayList>(); + List> result = new ArrayList<>(); result.add((List)values()); result.add((List)errors()); - List completeList = new ArrayList(); + List completeList = new ArrayList<>(); for (long i = 0; i < completions; i++) { completeList.add(Notification.complete()); } diff --git a/src/perf/java/io/reactivex/EachTypeFlatMapPerf.java b/rxjava/src/perf/java/io/reactivex/EachTypeFlatMapPerf.java similarity index 55% rename from src/perf/java/io/reactivex/EachTypeFlatMapPerf.java rename to rxjava/src/perf/java/io/reactivex/EachTypeFlatMapPerf.java index ce567d6880..9e01235018 100644 --- a/src/perf/java/io/reactivex/EachTypeFlatMapPerf.java +++ b/rxjava/src/perf/java/io/reactivex/EachTypeFlatMapPerf.java @@ -47,73 +47,48 @@ public void setup() { bpRange = Observable.range(1, times); nbpRange = NbpObservable.range(1, times); - bpRangeMapJust = bpRange.flatMap(new Function>() { - @Override - public Publisher apply(Integer v) { - return Observable.just(v); - } - }); - nbpRangeMapJust = nbpRange.flatMap(new Function>() { - @Override - public NbpObservable apply(Integer v) { - return NbpObservable.just(v); - } - }); + bpRangeMapJust = bpRange.flatMap(Observable::just); + nbpRangeMapJust = nbpRange.flatMap(NbpObservable::just); - bpRangeMapRange = bpRange.flatMap(new Function>() { - @Override - public Publisher apply(Integer v) { - return Observable.range(v, 2); - } - }); - nbpRangeMapRange = nbpRange.flatMap(new Function>() { - @Override - public NbpObservable apply(Integer v) { - return NbpObservable.range(v, 2); - } - }); + bpRangeMapRange = bpRange.flatMap(v -> Observable.range(v, 2)); + nbpRangeMapRange = nbpRange.flatMap(v -> NbpObservable.range(v, 2)); singleJust = Single.just(1); - singleJustMapJust = singleJust.flatMap(new Function>() { - @Override - public Single apply(Integer v) { - return Single.just(v); - } - }); + singleJustMapJust = singleJust.flatMap(Single::just); } @Benchmark public void bpRange(Blackhole bh) { - bpRange.subscribe(new LatchedObserver(bh)); + bpRange.subscribe(new LatchedObserver<>(bh)); } @Benchmark public void bpRangeMapJust(Blackhole bh) { - bpRangeMapJust.subscribe(new LatchedObserver(bh)); + bpRangeMapJust.subscribe(new LatchedObserver<>(bh)); } @Benchmark public void bpRangeMapRange(Blackhole bh) { - bpRangeMapRange.subscribe(new LatchedObserver(bh)); + bpRangeMapRange.subscribe(new LatchedObserver<>(bh)); } @Benchmark public void nbpRange(Blackhole bh) { - nbpRange.subscribe(new LatchedNbpObserver(bh)); + nbpRange.subscribe(new LatchedNbpObserver<>(bh)); } @Benchmark public void nbpRangeMapJust(Blackhole bh) { - nbpRangeMapJust.subscribe(new LatchedNbpObserver(bh)); + nbpRangeMapJust.subscribe(new LatchedNbpObserver<>(bh)); } @Benchmark public void nbpRangeMapRange(Blackhole bh) { - nbpRangeMapRange.subscribe(new LatchedNbpObserver(bh)); + nbpRangeMapRange.subscribe(new LatchedNbpObserver<>(bh)); } @Benchmark public void singleJust(Blackhole bh) { - singleJust.subscribe(new LatchedSingleObserver(bh)); + singleJust.subscribe(new LatchedSingleObserver<>(bh)); } @Benchmark public void singleJustMapJust(Blackhole bh) { - singleJustMapJust.subscribe(new LatchedSingleObserver(bh)); + singleJustMapJust.subscribe(new LatchedSingleObserver<>(bh)); } } \ No newline at end of file diff --git a/src/perf/java/io/reactivex/InputWithIncrementingInteger.java b/rxjava/src/perf/java/io/reactivex/InputWithIncrementingInteger.java similarity index 69% rename from src/perf/java/io/reactivex/InputWithIncrementingInteger.java rename to rxjava/src/perf/java/io/reactivex/InputWithIncrementingInteger.java index 7ff7e5a63d..304cee8b4d 100644 --- a/src/perf/java/io/reactivex/InputWithIncrementingInteger.java +++ b/rxjava/src/perf/java/io/reactivex/InputWithIncrementingInteger.java @@ -38,47 +38,38 @@ public void setup(final Blackhole bh) { final int size = getSize(); observable = Observable.range(0, size); - firehose = Observable.create(new Publisher() { - - @Override - public void subscribe(Subscriber s) { + firehose = Observable.create(s -> { s.onSubscribe(EmptySubscription.INSTANCE); for (int i = 0; i < size; i++) { s.onNext(i); } s.onComplete(); } + ); + iterable = () -> new Iterator() { + int i = 0; + + @Override + public boolean hasNext() { + return i < size; + } - }); - iterable = new Iterable() { @Override - public Iterator iterator() { - return new Iterator() { - int i = 0; - - @Override - public boolean hasNext() { - return i < size; - } - - @Override - public Integer next() { - Blackhole.consumeCPU(10); - return i++; - } - - @Override - public void remove() { - - } - }; + public Integer next() { + Blackhole.consumeCPU(10); + return i++; + } + + @Override + public void remove() { + } }; } public LatchedObserver newLatchedObserver() { - return new LatchedObserver(bh); + return new LatchedObserver<>(bh); } public Subscriber newSubscriber() { diff --git a/src/perf/java/io/reactivex/LatchedNbpObserver.java b/rxjava/src/perf/java/io/reactivex/LatchedNbpObserver.java similarity index 100% rename from src/perf/java/io/reactivex/LatchedNbpObserver.java rename to rxjava/src/perf/java/io/reactivex/LatchedNbpObserver.java diff --git a/src/perf/java/io/reactivex/LatchedObserver.java b/rxjava/src/perf/java/io/reactivex/LatchedObserver.java similarity index 100% rename from src/perf/java/io/reactivex/LatchedObserver.java rename to rxjava/src/perf/java/io/reactivex/LatchedObserver.java diff --git a/src/perf/java/io/reactivex/LatchedSingleObserver.java b/rxjava/src/perf/java/io/reactivex/LatchedSingleObserver.java similarity index 100% rename from src/perf/java/io/reactivex/LatchedSingleObserver.java rename to rxjava/src/perf/java/io/reactivex/LatchedSingleObserver.java diff --git a/src/perf/java/io/reactivex/OperatorFlatMapPerf.java b/rxjava/src/perf/java/io/reactivex/OperatorFlatMapPerf.java similarity index 73% rename from src/perf/java/io/reactivex/OperatorFlatMapPerf.java rename to rxjava/src/perf/java/io/reactivex/OperatorFlatMapPerf.java index f8d27eeb00..f51a4f646f 100644 --- a/src/perf/java/io/reactivex/OperatorFlatMapPerf.java +++ b/rxjava/src/perf/java/io/reactivex/OperatorFlatMapPerf.java @@ -42,23 +42,13 @@ public int getSize() { @Benchmark public void flatMapIntPassthruSync(Input input) throws InterruptedException { - input.observable.flatMap(new Function>() { - @Override - public Publisher apply(Integer v) { - return Observable.just(v); - } - }).subscribe(input.newSubscriber()); + input.observable.flatMap(Observable::just).subscribe(input.newSubscriber()); } @Benchmark public void flatMapIntPassthruAsync(Input input) throws InterruptedException { LatchedObserver latchedObserver = input.newLatchedObserver(); - input.observable.flatMap(new Function>() { - @Override - public Publisher apply(Integer i) { - return Observable.just(i).subscribeOn(Schedulers.computation()); - } - }).subscribe(latchedObserver); + input.observable.flatMap(i -> Observable.just(i).subscribeOn(Schedulers.computation())).subscribe(latchedObserver); if (input.size == 1) { while (latchedObserver.latch.getCount() != 0); } else { @@ -68,12 +58,7 @@ public Publisher apply(Integer i) { @Benchmark public void flatMapTwoNestedSync(final Input input) throws InterruptedException { - Observable.range(1, 2).flatMap(new Function>() { - @Override - public Publisher apply(Integer i) { - return input.observable; - } - }).subscribe(input.newSubscriber()); + Observable.range(1, 2).flatMap(i -> input.observable).subscribe(input.newSubscriber()); } // this runs out of memory currently diff --git a/src/perf/java/io/reactivex/OperatorMergePerf.java b/rxjava/src/perf/java/io/reactivex/OperatorMergePerf.java similarity index 81% rename from src/perf/java/io/reactivex/OperatorMergePerf.java rename to rxjava/src/perf/java/io/reactivex/OperatorMergePerf.java index e8eef8b97d..1a29cf6d28 100644 --- a/src/perf/java/io/reactivex/OperatorMergePerf.java +++ b/rxjava/src/perf/java/io/reactivex/OperatorMergePerf.java @@ -30,13 +30,7 @@ public class OperatorMergePerf { // flatMap @Benchmark public void oneStreamOfNthatMergesIn1(final InputMillion input) throws InterruptedException { - Observable> os = Observable.range(1, input.size) - .map(new Function>() { - @Override - public Observable apply(Integer v) { - return Observable.just(v); - } - }); + Observable> os = Observable.range(1, input.size).map(Observable::just); LatchedObserver o = input.newLatchedObserver(); Observable.merge(os).subscribe(o); @@ -50,12 +44,7 @@ public Observable apply(Integer v) { // flatMap @Benchmark public void merge1SyncStreamOfN(final InputMillion input) throws InterruptedException { - Observable> os = Observable.just(1).map(new Function>() { - @Override - public Observable apply(Integer i) { - return Observable.range(0, input.size); - } - }); + Observable> os = Observable.just(1).map(i -> Observable.range(0, input.size)); LatchedObserver o = input.newLatchedObserver(); Observable.merge(os).subscribe(o); @@ -68,12 +57,7 @@ public Observable apply(Integer i) { @Benchmark public void mergeNSyncStreamsOfN(final InputThousand input) throws InterruptedException { - Observable> os = input.observable.map(new Function>() { - @Override - public Observable apply(Integer i) { - return Observable.range(0, input.size); - } - }); + Observable> os = input.observable.map(i -> Observable.range(0, input.size)); LatchedObserver o = input.newLatchedObserver(); Observable.merge(os).subscribe(o); if (input.size == 1) { @@ -85,12 +69,8 @@ public Observable apply(Integer i) { @Benchmark public void mergeNAsyncStreamsOfN(final InputThousand input) throws InterruptedException { - Observable> os = input.observable.map(new Function>() { - @Override - public Observable apply(Integer i) { - return Observable.range(0, input.size).subscribeOn(Schedulers.computation()); - } - }); + Observable> os = input.observable.map(i -> + Observable.range(0, input.size).subscribeOn(Schedulers.computation())); LatchedObserver o = input.newLatchedObserver(); Observable.merge(os).subscribe(o); if (input.size == 1) { @@ -135,14 +115,14 @@ public static class InputForMergeN { @Setup public void setup(final Blackhole bh) { this.bh = bh; - observables = new ArrayList>(); + observables = new ArrayList<>(); for (int i = 0; i < size; i++) { observables.add(Observable.just(i)); } } public LatchedObserver newLatchedObserver() { - return new LatchedObserver(bh); + return new LatchedObserver<>(bh); } } diff --git a/src/perf/java/io/reactivex/RangePerf.java b/rxjava/src/perf/java/io/reactivex/RangePerf.java similarity index 91% rename from src/perf/java/io/reactivex/RangePerf.java rename to rxjava/src/perf/java/io/reactivex/RangePerf.java index 768ccdb3b3..b4416c7649 100644 --- a/src/perf/java/io/reactivex/RangePerf.java +++ b/rxjava/src/perf/java/io/reactivex/RangePerf.java @@ -49,7 +49,7 @@ public void setup() { @Benchmark public Object rangeSync(Blackhole bh) { - LatchedObserver lo = new LatchedObserver(bh); + LatchedObserver lo = new LatchedObserver<>(bh); range.subscribe(lo); @@ -58,7 +58,7 @@ public Object rangeSync(Blackhole bh) { // @Benchmark public void rangeAsync(Blackhole bh) throws Exception { - LatchedObserver lo = new LatchedObserver(bh); + LatchedObserver lo = new LatchedObserver<>(bh); rangeAsync.subscribe(lo); @@ -71,7 +71,7 @@ public void rangeAsync(Blackhole bh) throws Exception { // @Benchmark public void rangePipeline(Blackhole bh) throws Exception { - LatchedObserver lo = new LatchedObserver(bh); + LatchedObserver lo = new LatchedObserver<>(bh); rangeAsyncPipeline.subscribe(lo); diff --git a/src/perf/java/io/reactivex/RxVsStreamPerf.java b/rxjava/src/perf/java/io/reactivex/RxVsStreamPerf.java similarity index 59% rename from src/perf/java/io/reactivex/RxVsStreamPerf.java rename to rxjava/src/perf/java/io/reactivex/RxVsStreamPerf.java index 67a1e86bb9..f1b7d97abd 100644 --- a/src/perf/java/io/reactivex/RxVsStreamPerf.java +++ b/rxjava/src/perf/java/io/reactivex/RxVsStreamPerf.java @@ -50,67 +50,47 @@ public class RxVsStreamPerf { public void setup() { range = Observable.range(1, times); - rangeFlatMapJust = range.flatMap(new Function>() { - @Override - public Publisher apply(Integer v) { - return Observable.just(v); - } - }); - - rangeFlatMap = range.flatMap(new Function>() { - @Override - public Publisher apply(Integer v) { - return Observable.range(v, 2); - } - }); + rangeFlatMapJust = range.flatMap(Observable::just); + + rangeFlatMap = range.flatMap(v -> Observable.range(v, 2)); rangeNbp = NbpObservable.range(1, times); - rangeNbpFlatMapJust = rangeNbp.flatMap(new Function>() { - @Override - public NbpObservable apply(Integer v) { - return NbpObservable.just(v); - } - }); + rangeNbpFlatMapJust = rangeNbp.flatMap(NbpObservable::just); - rangeNbpFlatMap = rangeNbp.flatMap(new Function>() { - @Override - public NbpObservable apply(Integer v) { - return NbpObservable.range(v, 2); - } - }); + rangeNbpFlatMap = rangeNbp.flatMap(v -> NbpObservable.range(v, 2)); values = range.toList().toBlocking().first(); } @Benchmark public void range(Blackhole bh) { - range.subscribe(new LatchedObserver(bh)); + range.subscribe(new LatchedObserver<>(bh)); } @Benchmark public void rangeNbp(Blackhole bh) { - rangeNbp.subscribe(new LatchedNbpObserver(bh)); + rangeNbp.subscribe(new LatchedNbpObserver<>(bh)); } @Benchmark public void rangeFlatMap(Blackhole bh) { - rangeFlatMap.subscribe(new LatchedObserver(bh)); + rangeFlatMap.subscribe(new LatchedObserver<>(bh)); } @Benchmark public void rangeNbpFlatMap(Blackhole bh) { - rangeNbpFlatMap.subscribe(new LatchedNbpObserver(bh)); + rangeNbpFlatMap.subscribe(new LatchedNbpObserver<>(bh)); } @Benchmark public void rangeFlatMapJust(Blackhole bh) { - rangeFlatMapJust.subscribe(new LatchedObserver(bh)); + rangeFlatMapJust.subscribe(new LatchedObserver<>(bh)); } @Benchmark public void rangeNbpFlatMapJust(Blackhole bh) { - rangeNbpFlatMapJust.subscribe(new LatchedNbpObserver(bh)); + rangeNbpFlatMapJust.subscribe(new LatchedNbpObserver<>(bh)); } } \ No newline at end of file diff --git a/src/test/java/io/reactivex/BackpressureTests.java b/rxjava/src/test/java/io/reactivex/BackpressureTests.java similarity index 81% rename from src/test/java/io/reactivex/BackpressureTests.java rename to rxjava/src/test/java/io/reactivex/BackpressureTests.java index de964ef8fa..a51676d455 100644 --- a/src/test/java/io/reactivex/BackpressureTests.java +++ b/rxjava/src/test/java/io/reactivex/BackpressureTests.java @@ -82,7 +82,7 @@ public void doAfterTest() { public void testObserveOn() { int NUM = (int) (Observable.bufferSize() * 2.1); AtomicInteger c = new AtomicInteger(); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); incrementingIntegers(c).observeOn(Schedulers.computation()).take(NUM).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); @@ -95,18 +95,15 @@ public void testObserveOn() { public void testObserveOnWithSlowConsumer() { int NUM = (int) (Observable.bufferSize() * 0.2); AtomicInteger c = new AtomicInteger(); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); incrementingIntegers(c).observeOn(Schedulers.computation()).map( - new Function() { - @Override - public Integer apply(Integer i) { - try { - Thread.sleep(1); - } catch (InterruptedException e) { - e.printStackTrace(); - } - return i; + i -> { + try { + Thread.sleep(1); + } catch (InterruptedException e) { + e.printStackTrace(); } + return i; } ).take(NUM).subscribe(ts); ts.awaitTerminalEvent(); @@ -121,7 +118,7 @@ public void testMergeSync() { int NUM = (int) (Observable.bufferSize() * 4.1); AtomicInteger c1 = new AtomicInteger(); AtomicInteger c2 = new AtomicInteger(); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable merged = Observable.merge(incrementingIntegers(c1), incrementingIntegers(c2)); merged.take(NUM).subscribe(ts); @@ -142,7 +139,7 @@ public void testMergeAsync() { int NUM = (int) (Observable.bufferSize() * 4.1); AtomicInteger c1 = new AtomicInteger(); AtomicInteger c2 = new AtomicInteger(); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable merged = Observable.merge( incrementingIntegers(c1).subscribeOn(Schedulers.computation()), incrementingIntegers(c2).subscribeOn(Schedulers.computation())); @@ -171,7 +168,7 @@ public void testMergeAsyncThenObserveOnLoop() { AtomicInteger c1 = new AtomicInteger(); AtomicInteger c2 = new AtomicInteger(); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable merged = Observable.merge( incrementingIntegers(c1).subscribeOn(Schedulers.computation()), incrementingIntegers(c2).subscribeOn(Schedulers.computation())); @@ -195,7 +192,7 @@ public void testMergeAsyncThenObserveOn() { int NUM = (int) (Observable.bufferSize() * 4.1); AtomicInteger c1 = new AtomicInteger(); AtomicInteger c2 = new AtomicInteger(); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable merged = Observable.merge( incrementingIntegers(c1).subscribeOn(Schedulers.computation()), incrementingIntegers(c2).subscribeOn(Schedulers.computation())); @@ -217,15 +214,10 @@ public void testMergeAsyncThenObserveOn() { public void testFlatMapSync() { int NUM = (int) (Observable.bufferSize() * 2.1); AtomicInteger c = new AtomicInteger(); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); incrementingIntegers(c) - .flatMap(new Function>() { - @Override - public Publisher apply(Integer i) { - return incrementingIntegers(new AtomicInteger()).take(10); - } - }) + .flatMap(i -> incrementingIntegers(new AtomicInteger()).take(10)) .take(NUM).subscribe(ts); ts.awaitTerminalEvent(); @@ -241,18 +233,13 @@ public Publisher apply(Integer i) { public void testFlatMapAsync() { int NUM = (int) (Observable.bufferSize() * 2.1); AtomicInteger c = new AtomicInteger(); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); incrementingIntegers(c) .subscribeOn(Schedulers.computation()) - .flatMap(new Function>() { - @Override - public Publisher apply(Integer i) { - return incrementingIntegers(new AtomicInteger()) - .take(10) - .subscribeOn(Schedulers.computation()); - } - } + .flatMap(i -> incrementingIntegers(new AtomicInteger()) + .take(10) + .subscribeOn(Schedulers.computation()) ) .take(NUM).subscribe(ts); @@ -271,17 +258,12 @@ public void testZipSync() { int NUM = (int) (Observable.bufferSize() * 4.1); AtomicInteger c1 = new AtomicInteger(); AtomicInteger c2 = new AtomicInteger(); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable zipped = Observable.zip( - incrementingIntegers(c1), - incrementingIntegers(c2), - new BiFunction() { - @Override - public Integer apply(Integer t1, Integer t2) { - return t1 + t2; - } - }); + incrementingIntegers(c1), + incrementingIntegers(c2), + (t1, t2) -> t1 + t2); zipped.take(NUM) .subscribe(ts); @@ -299,16 +281,11 @@ public void testZipAsync() { int NUM = (int) (Observable.bufferSize() * 2.1); AtomicInteger c1 = new AtomicInteger(); AtomicInteger c2 = new AtomicInteger(); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable zipped = Observable.zip( - incrementingIntegers(c1).subscribeOn(Schedulers.computation()), - incrementingIntegers(c2).subscribeOn(Schedulers.computation()), - new BiFunction() { - @Override - public Integer apply(Integer t1, Integer t2) { - return t1 + t2; - } - }); + incrementingIntegers(c1).subscribeOn(Schedulers.computation()), + incrementingIntegers(c2).subscribeOn(Schedulers.computation()), + (t1, t2) -> t1 + t2); zipped.take(NUM).subscribe(ts); ts.awaitTerminalEvent(); @@ -326,8 +303,8 @@ public void testSubscribeOnScheduling() { for (int i = 0; i < 100; i++) { int NUM = (int) (Observable.bufferSize() * 2.1); AtomicInteger c = new AtomicInteger(); - ConcurrentLinkedQueue threads = new ConcurrentLinkedQueue(); - TestSubscriber ts = new TestSubscriber(); + ConcurrentLinkedQueue threads = new ConcurrentLinkedQueue<>(); + TestSubscriber ts = new TestSubscriber<>(); // observeOn is there to make it async and need backpressure incrementingIntegers(c, threads).subscribeOn(Schedulers.computation()).observeOn(Schedulers.computation()).take(NUM).subscribe(ts); ts.awaitTerminalEvent(); @@ -356,15 +333,10 @@ public void testSubscribeOnScheduling() { public void testTakeFilterSkipChainAsync() { int NUM = (int) (Observable.bufferSize() * 2.1); AtomicInteger c = new AtomicInteger(); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); incrementingIntegers(c).observeOn(Schedulers.computation()) .skip(10000) - .filter(new Predicate() { - @Override - public boolean test(Integer i) { - return i > 11000; - } - }).take(NUM).subscribe(ts); + .filter(i -> i > 11000).take(NUM).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); @@ -483,19 +455,16 @@ public void onNext(Integer t) { @Test(timeout = 2000) public void testFirehoseFailsAsExpected() { AtomicInteger c = new AtomicInteger(); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); firehose(c).observeOn(Schedulers.computation()) - .map(new Function() { - @Override - public Integer apply(Integer v) { - try { - Thread.sleep(10); - } catch (Exception e) { - e.printStackTrace(); - } - return v; + .map(v -> { + try { + Thread.sleep(10); + } catch (Exception e) { + e.printStackTrace(); } + return v; }) .subscribe(ts); @@ -527,7 +496,7 @@ public void testOnBackpressureDrop() { } int NUM = (int) (Observable.bufferSize() * 1.1); // > 1 so that take doesn't prevent buffer overflow AtomicInteger c = new AtomicInteger(); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); firehose(c).onBackpressureDrop() .observeOn(Schedulers.computation()) .map(SLOW_PASS_THRU).take(NUM).subscribe(ts); @@ -552,21 +521,11 @@ public void testOnBackpressureDropWithAction() { final AtomicInteger dropCount = new AtomicInteger(); final AtomicInteger passCount = new AtomicInteger(); final int NUM = Observable.bufferSize() * 3; // > 1 so that take doesn't prevent buffer overflow - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); firehose(emitCount) - .onBackpressureDrop(new Consumer() { - @Override - public void accept(Integer v) { - dropCount.incrementAndGet(); - } - }) - .doOnNext(new Consumer() { - @Override - public void accept(Integer v) { - passCount.incrementAndGet(); - } - }) + .onBackpressureDrop(v -> dropCount.incrementAndGet()) + .doOnNext(v -> passCount.incrementAndGet()) .observeOn(Schedulers.computation()) .map(SLOW_PASS_THRU) .take(NUM).subscribe(ts); @@ -592,7 +551,7 @@ public void testOnBackpressureDropSynchronous() { for (int i = 0; i < 100; i++) { int NUM = (int) (Observable.bufferSize() * 1.1); // > 1 so that take doesn't prevent buffer overflow AtomicInteger c = new AtomicInteger(); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); firehose(c).onBackpressureDrop() .map(SLOW_PASS_THRU).take(NUM).subscribe(ts); ts.awaitTerminalEvent(); @@ -615,13 +574,8 @@ public void testOnBackpressureDropSynchronousWithAction() { final AtomicInteger dropCount = new AtomicInteger(); int NUM = (int) (Observable.bufferSize() * 1.1); // > 1 so that take doesn't prevent buffer overflow AtomicInteger c = new AtomicInteger(); - TestSubscriber ts = new TestSubscriber(); - firehose(c).onBackpressureDrop(new Consumer() { - @Override - public void accept(Integer j) { - dropCount.incrementAndGet(); - } - }) + TestSubscriber ts = new TestSubscriber<>(); + firehose(c).onBackpressureDrop(j -> dropCount.incrementAndGet()) .map(SLOW_PASS_THRU).take(NUM).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); @@ -644,14 +598,9 @@ public void accept(Integer j) { public void testOnBackpressureBuffer() { int NUM = (int) (Observable.bufferSize() * 1.1); // > 1 so that take doesn't prevent buffer overflow AtomicInteger c = new AtomicInteger(); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); - firehose(c).takeWhile(new Predicate() { - @Override - public boolean test(Integer t1) { - return t1 < 100000; - } - }) + firehose(c).takeWhile(t1 -> t1 < 100000) .onBackpressureBuffer() .observeOn(Schedulers.computation()) .map(SLOW_PASS_THRU).take(NUM).subscribe(ts); @@ -675,45 +624,40 @@ private static Observable incrementingIntegers(final AtomicInteger coun } private static Observable incrementingIntegers(final AtomicInteger counter, final ConcurrentLinkedQueue threadsSeen) { - return Observable.create(new Publisher() { + return Observable.create(s -> { + s.onSubscribe(new Subscription() { + int i = 0; - @Override - public void subscribe(final Subscriber s) { - s.onSubscribe(new Subscription() { - int i = 0; - - volatile boolean cancelled; - - final AtomicLong requested = new AtomicLong(); - - @Override - public void request(long n) { - if (SubscriptionHelper.validateRequest(n)) { - return; - } - if (threadsSeen != null) { - threadsSeen.offer(Thread.currentThread()); - } - long _c = BackpressureHelper.add(requested, n); - if (_c == 0) { - while (!cancelled) { - counter.incrementAndGet(); - s.onNext(i++); - if (requested.decrementAndGet() == 0) { - // we're done emitting the number requested so return - return; - } + volatile boolean cancelled; + + final AtomicLong requested = new AtomicLong(); + + @Override + public void request(long n) { + if (SubscriptionHelper.validateRequest(n)) { + return; + } + if (threadsSeen != null) { + threadsSeen.offer(Thread.currentThread()); + } + long _c = BackpressureHelper.add(requested, n); + if (_c == 0) { + while (!cancelled) { + counter.incrementAndGet(); + s.onNext(i++); + if (requested.decrementAndGet() == 0) { + // we're done emitting the number requested so return + return; } } } + } - @Override - public void cancel() { - cancelled = true; - } - }); - } - + @Override + public void cancel() { + cancelled = true; + } + }); }); } @@ -724,12 +668,9 @@ public void cancel() { * @return */ private static Observable firehose(final AtomicInteger counter) { - return Observable.create(new Publisher() { - @Override - public void subscribe(Subscriber s) { - Subscription s2 = new FirehoseNoBackpressure(counter, s); - s.onSubscribe(s2); - } + return Observable.create(s -> { + Subscription s2 = new FirehoseNoBackpressure(counter, s); + s.onSubscribe(s2); }); } diff --git a/rxjava/src/test/java/io/reactivex/CombineLatestTests.java b/rxjava/src/test/java/io/reactivex/CombineLatestTests.java new file mode 100644 index 0000000000..9cd68d6310 --- /dev/null +++ b/rxjava/src/test/java/io/reactivex/CombineLatestTests.java @@ -0,0 +1,60 @@ +/** + * Copyright 2016 Netflix, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package io.reactivex; + +import static io.reactivex.Observable.combineLatest; + +import org.junit.*; + +import io.reactivex.CovarianceTest.*; +import io.reactivex.functions.*; +import io.reactivex.subjects.BehaviorSubject; + +public class CombineLatestTests { + /** + * This won't compile if super/extends isn't done correctly on generics + */ + @Test + public void testCovarianceOfCombineLatest() { + Observable horrors = Observable.just(new HorrorMovie()); + Observable ratings = Observable.just(new CoolRating()); + + Observable.combineLatest(horrors, ratings, combine).toBlocking().forEach(action); + Observable.combineLatest(horrors, ratings, combine).toBlocking().forEach(action); + Observable.combineLatest(horrors, ratings, combine).toBlocking().forEach(extendedAction); + Observable.combineLatest(horrors, ratings, combine).toBlocking().forEach(action); + Observable.combineLatest(horrors, ratings, combine).toBlocking().forEach(action); + + Observable.combineLatest(horrors, ratings, combine); + } + + BiFunction combine = (m, r) -> new ExtendedResult(); + + Consumer action = t1 -> System.out.println("Result: " + t1); + + Consumer extendedAction = t1 -> System.out.println("Result: " + t1); + + @Ignore + @Test + public void testNullEmitting() throws Exception { + // FIXME this is no longer allowed + Observable nullObservable = BehaviorSubject.createDefault(null); + Observable nonNullObservable = BehaviorSubject.createDefault(true); + Observable combined = + combineLatest(nullObservable, nonNullObservable, (bool1, bool2) -> bool1 == null ? null : bool2); + combined.subscribe(Assert::assertNull); + } +} \ No newline at end of file diff --git a/src/test/java/io/reactivex/CompletableTest.java b/rxjava/src/test/java/io/reactivex/CompletableTest.java similarity index 73% rename from src/test/java/io/reactivex/CompletableTest.java rename to rxjava/src/test/java/io/reactivex/CompletableTest.java index cc1577ed46..f1dec9103e 100644 --- a/src/test/java/io/reactivex/CompletableTest.java +++ b/rxjava/src/test/java/io/reactivex/CompletableTest.java @@ -96,13 +96,10 @@ static final class NormalCompletable extends AtomicInteger { /** */ private static final long serialVersionUID = 7192337844700923752L; - public final Completable completable = Completable.create(new CompletableOnSubscribe() { - @Override - public void accept(CompletableSubscriber s) { - getAndIncrement(); - s.onSubscribe(EmptyDisposable.INSTANCE); - s.onComplete(); - } + public final Completable completable = Completable.create(s -> { + getAndIncrement(); + s.onSubscribe(EmptyDisposable.INSTANCE); + s.onComplete(); }); /** @@ -122,13 +119,10 @@ static final class ErrorCompletable extends AtomicInteger { /** */ private static final long serialVersionUID = 7192337844700923752L; - public final Completable completable = Completable.create(new CompletableOnSubscribe() { - @Override - public void accept(CompletableSubscriber s) { - getAndIncrement(); - s.onSubscribe(EmptyDisposable.INSTANCE); - s.onError(new TestException()); - } + public final Completable completable = Completable.create(s -> { + getAndIncrement(); + s.onSubscribe(EmptyDisposable.INSTANCE); + s.onError(new TestException()); }); /** @@ -206,7 +200,7 @@ public void concatMultipleOneIsNull() { @Test(timeout = 1000) public void concatIterableEmpty() { - Completable c = Completable.concat(Collections.emptyList()); + Completable c = Completable.concat(Collections.emptyList()); c.await(); } @@ -218,19 +212,14 @@ public void concatIterableNull() { @Test(timeout = 1000, expected = NullPointerException.class) public void concatIterableIteratorNull() { - Completable c = Completable.concat(new Iterable() { - @Override - public Iterator iterator() { - return null; - } - }); + Completable c = Completable.concat(() -> null); c.await(); } @Test(timeout = 1000, expected = NullPointerException.class) public void concatIterableWithNull() { - Completable c = Completable.concat(Arrays.asList(normal.completable, (Completable)null)); + Completable c = Completable.concat(Arrays.asList(normal.completable, null)); c.await(); } @@ -269,11 +258,8 @@ public void concatIterableManyOneThrows() { @Test(expected = TestException.class) public void concatIterableIterableThrows() { - Completable c = Completable.concat(new Iterable() { - @Override - public Iterator iterator() { - throw new TestException(); - } + Completable c = Completable.concat(() -> { + throw new TestException(); }); c.await(); @@ -295,20 +281,15 @@ public void concatIterableIteratorNextThrows() { @Test(timeout = 1000) public void concatObservableEmpty() { - Completable c = Completable.concat(Observable.empty()); - + Completable c = Completable.concat(Observable.empty()); + c.await(); } @Test(timeout = 1000, expected = TestException.class) public void concatObservableError() { - Completable c = Completable.concat(Observable.error(new Supplier() { - @Override - public Throwable get() { - return new TestException(); - } - })); - + Completable c = Completable.concat(Observable.error(TestException::new)); + c.await(); } @@ -346,16 +327,11 @@ public void concatObservableManyOneThrows() { @Test(timeout = 1000) public void concatObservablePrefetch() { - final List requested = new ArrayList(); + final List requested = new ArrayList<>(); Observable cs = Observable .just(normal.completable) .repeat(10) - .doOnRequest(new LongConsumer() { - @Override - public void accept(long v) { - requested.add(v); - } - }); + .doOnRequest(requested::add); Completable c = Completable.concat(cs, 5); @@ -372,10 +348,7 @@ public void createNull() { @Test(timeout = 1000, expected = NullPointerException.class) public void createOnSubscribeThrowsNPE() { - Completable c = Completable.create(new CompletableOnSubscribe() { - @Override - public void accept(CompletableSubscriber s) { throw new NullPointerException(); } - }); + Completable c = Completable.create(s -> { throw new NullPointerException(); }); c.await(); } @@ -383,11 +356,8 @@ public void createOnSubscribeThrowsNPE() { @Test(timeout = 1000) public void createOnSubscribeThrowsRuntimeException() { try { - Completable c = Completable.create(new CompletableOnSubscribe() { - @Override - public void accept(CompletableSubscriber s) { - throw new TestException(); - } + Completable c = Completable.create(s -> { + throw new TestException(); }); c.await(); @@ -403,12 +373,7 @@ public void accept(CompletableSubscriber s) { @Test(timeout = 1000) public void defer() { - Completable c = Completable.defer(new Supplier() { - @Override - public Completable get() { - return normal.completable; - } - }); + Completable c = Completable.defer(() -> normal.completable); normal.assertSubscriptions(0); @@ -424,34 +389,21 @@ public void deferNull() { @Test(timeout = 1000, expected = NullPointerException.class) public void deferReturnsNull() { - Completable c = Completable.defer(new Supplier() { - @Override - public Completable get() { - return null; - } - }); + Completable c = Completable.defer(() -> null); c.await(); } @Test(timeout = 1000, expected = TestException.class) public void deferFunctionThrows() { - Completable c = Completable.defer(new Supplier() { - @Override - public Completable get() { throw new TestException(); } - }); + Completable c = Completable.defer(() -> { throw new TestException(); }); c.await(); } @Test(timeout = 1000, expected = TestException.class) public void deferErrorSource() { - Completable c = Completable.defer(new Supplier() { - @Override - public Completable get() { - return error.completable; - } - }); + Completable c = Completable.defer(() -> error.completable); c.await(); } @@ -463,34 +415,21 @@ public void errorSupplierNull() { @Test(timeout = 1000, expected = TestException.class) public void errorSupplierNormal() { - Completable c = Completable.error(new Supplier() { - @Override - public Throwable get() { - return new TestException(); - } - }); + Completable c = Completable.error(TestException::new); c.await(); } @Test(timeout = 1000, expected = NullPointerException.class) public void errorSupplierReturnsNull() { - Completable c = Completable.error(new Supplier() { - @Override - public Throwable get() { - return null; - } - }); + Completable c = Completable.error(() -> null); c.await(); } @Test(timeout = 1000, expected = TestException.class) public void errorSupplierThrows() { - Completable c = Completable.error(new Supplier() { - @Override - public Throwable get() { throw new TestException(); } - }); + Completable c = Completable.error(() -> { throw new TestException(); }); c.await(); } @@ -516,12 +455,7 @@ public void fromCallableNull() { public void fromCallableNormal() { final AtomicInteger calls = new AtomicInteger(); - Completable c = Completable.fromCallable(new Callable() { - @Override - public Object call() throws Exception { - return calls.getAndIncrement(); - } - }); + Completable c = Completable.fromCallable(calls::getAndIncrement); c.await(); @@ -530,10 +464,7 @@ public Object call() throws Exception { @Test(timeout = 1000, expected = TestException.class) public void fromCallableThrows() { - Completable c = Completable.fromCallable(new Callable() { - @Override - public Object call() throws Exception { throw new TestException(); } - }); + Completable c = Completable.fromCallable(() -> { throw new TestException(); }); c.await(); } @@ -561,12 +492,7 @@ public void fromFlowableSome() { @Test(timeout = 1000, expected = TestException.class) public void fromFlowableError() { - Completable c = Completable.fromFlowable(Observable.error(new Supplier() { - @Override - public Throwable get() { - return new TestException(); - } - })); + Completable c = Completable.fromFlowable(Observable.error(TestException::new)); c.await(); } @@ -594,12 +520,7 @@ public void fromNbpObservableSome() { @Test(timeout = 1000, expected = TestException.class) public void fromNbpObservableError() { - Completable c = Completable.fromNbpObservable(NbpObservable.error(new Supplier() { - @Override - public Throwable get() { - return new TestException(); - } - })); + Completable c = Completable.fromNbpObservable(NbpObservable.error(TestException::new)); c.await(); } @@ -613,12 +534,7 @@ public void fromRunnableNull() { public void fromRunnableNormal() { final AtomicInteger calls = new AtomicInteger(); - Completable c = Completable.fromRunnable(new Runnable() { - @Override - public void run() { - calls.getAndIncrement(); - } - }); + Completable c = Completable.fromRunnable(calls::getAndIncrement); c.await(); @@ -627,10 +543,7 @@ public void run() { @Test(timeout = 1000, expected = TestException.class) public void fromRunnableThrows() { - Completable c = Completable.fromRunnable(new Runnable() { - @Override - public void run() { throw new TestException(); } - }); + Completable c = Completable.fromRunnable(() -> { throw new TestException(); }); c.await(); } @@ -649,12 +562,7 @@ public void fromSingleNormal() { @Test(timeout = 1000, expected = TestException.class) public void fromSingleThrows() { - Completable c = Completable.fromSingle(Single.error(new Supplier() { - @Override - public Throwable get() { - return new TestException(); - } - })); + Completable c = Completable.fromSingle(Single.error(TestException::new)); c.await(); } @@ -712,7 +620,7 @@ public void mergeMultipleOneIsNull() { @Test(timeout = 1000) public void mergeIterableEmpty() { - Completable c = Completable.merge(Collections.emptyList()); + Completable c = Completable.merge(Collections.emptyList()); c.await(); } @@ -724,19 +632,14 @@ public void mergeIterableNull() { @Test(timeout = 1000, expected = NullPointerException.class) public void mergeIterableIteratorNull() { - Completable c = Completable.merge(new Iterable() { - @Override - public Iterator iterator() { - return null; - } - }); + Completable c = Completable.merge(() -> null); c.await(); } @Test(timeout = 1000, expected = NullPointerException.class) public void mergeIterableWithNull() { - Completable c = Completable.merge(Arrays.asList(normal.completable, (Completable)null)); + Completable c = Completable.merge(Arrays.asList(normal.completable, null)); c.await(); } @@ -775,11 +678,8 @@ public void mergeIterableManyOneThrows() { @Test(expected = TestException.class) public void mergeIterableIterableThrows() { - Completable c = Completable.merge(new Iterable() { - @Override - public Iterator iterator() { - throw new TestException(); - } + Completable c = Completable.merge(() -> { + throw new TestException(); }); c.await(); @@ -801,19 +701,14 @@ public void mergeIterableIteratorNextThrows() { @Test(timeout = 1000) public void mergeObservableEmpty() { - Completable c = Completable.merge(Observable.empty()); + Completable c = Completable.merge(Observable.empty()); c.await(); } @Test(timeout = 1000, expected = TestException.class) public void mergeObservableError() { - Completable c = Completable.merge(Observable.error(new Supplier() { - @Override - public Throwable get() { - return new TestException(); - } - })); + Completable c = Completable.merge(Observable.error(TestException::new)); c.await(); } @@ -852,16 +747,11 @@ public void mergeObservableManyOneThrows() { @Test(timeout = 1000) public void mergeObservableMaxConcurrent() { - final List requested = new ArrayList(); + final List requested = new ArrayList<>(); Observable cs = Observable .just(normal.completable) .repeat(10) - .doOnRequest(new LongConsumer() { - @Override - public void accept(long v) { - requested.add(v); - } - }); + .doOnRequest(requested::add); Completable c = Completable.merge(cs, 5); @@ -928,7 +818,7 @@ public void mergeDelayErrorMultipleOneIsNull() { @Test(timeout = 1000) public void mergeDelayErrorIterableEmpty() { - Completable c = Completable.mergeDelayError(Collections.emptyList()); + Completable c = Completable.mergeDelayError(Collections.emptyList()); c.await(); } @@ -940,19 +830,14 @@ public void mergeDelayErrorIterableNull() { @Test(timeout = 1000, expected = NullPointerException.class) public void mergeDelayErrorIterableIteratorNull() { - Completable c = Completable.mergeDelayError(new Iterable() { - @Override - public Iterator iterator() { - return null; - } - }); + Completable c = Completable.mergeDelayError(() -> null); c.await(); } @Test(timeout = 1000, expected = NullPointerException.class) public void mergeDelayErrorIterableWithNull() { - Completable c = Completable.mergeDelayError(Arrays.asList(normal.completable, (Completable)null)); + Completable c = Completable.mergeDelayError(Arrays.asList(normal.completable, null)); c.await(); } @@ -995,11 +880,8 @@ public void mergeDelayErrorIterableManyOneThrows() { @Test(expected = TestException.class) public void mergeDelayErrorIterableIterableThrows() { - Completable c = Completable.mergeDelayError(new Iterable() { - @Override - public Iterator iterator() { - throw new TestException(); - } + Completable c = Completable.mergeDelayError(() -> { + throw new TestException(); }); c.await(); @@ -1021,19 +903,14 @@ public void mergeDelayErrorIterableIteratorNextThrows() { @Test(timeout = 1000) public void mergeDelayErrorObservableEmpty() { - Completable c = Completable.mergeDelayError(Observable.empty()); + Completable c = Completable.mergeDelayError(Observable.empty()); c.await(); } @Test(timeout = 1000, expected = TestException.class) public void mergeDelayErrorObservableError() { - Completable c = Completable.mergeDelayError(Observable.error(new Supplier() { - @Override - public Throwable get() { - return new TestException(); - } - })); + Completable c = Completable.mergeDelayError(Observable.error(TestException::new)); c.await(); } @@ -1072,16 +949,11 @@ public void mergeDelayErrorObservableManyOneThrows() { @Test(timeout = 1000) public void mergeDelayErrorObservableMaxConcurrent() { - final List requested = new ArrayList(); + final List requested = new ArrayList<>(); Observable cs = Observable .just(normal.completable) .repeat(10) - .doOnRequest(new LongConsumer() { - @Override - public void accept(long v) { - requested.add(v); - } - }); + .doOnRequest(requested::add); Completable c = Completable.mergeDelayError(cs, 5); @@ -1211,25 +1083,10 @@ public void timerSchedulerNull() { public void usingNormalEager() { final AtomicInteger dispose = new AtomicInteger(); - Completable c = Completable.using(new Supplier() { - @Override - public Integer get() { - return 1; - } - }, new Function() { - @Override - public Completable apply(Object v) { - return normal.completable; - } - }, new Consumer() { - @Override - public void accept(Integer d) { - dispose.set(d); - } - }); + Completable c = Completable.using(() -> 1, v -> normal.completable, dispose::set); final AtomicBoolean disposedFirst = new AtomicBoolean(); - final AtomicReference error = new AtomicReference(); + final AtomicReference error = new AtomicReference<>(); c.subscribe(new CompletableSubscriber() { @Override @@ -1257,25 +1114,10 @@ public void onComplete() { public void usingNormalLazy() { final AtomicInteger dispose = new AtomicInteger(); - Completable c = Completable.using(new Supplier() { - @Override - public Integer get() { - return 1; - } - }, new Function() { - @Override - public Completable apply(Integer v) { - return normal.completable; - } - }, new Consumer() { - @Override - public void accept(Integer d) { - dispose.set(d); - } - }, false); + Completable c = Completable.using(() -> 1, v -> normal.completable, dispose::set, false); final AtomicBoolean disposedFirst = new AtomicBoolean(); - final AtomicReference error = new AtomicReference(); + final AtomicReference error = new AtomicReference<>(); c.subscribe(new CompletableSubscriber() { @Override @@ -1303,22 +1145,7 @@ public void onComplete() { public void usingErrorEager() { final AtomicInteger dispose = new AtomicInteger(); - Completable c = Completable.using(new Supplier() { - @Override - public Integer get() { - return 1; - } - }, new Function() { - @Override - public Completable apply(Integer v) { - return error.completable; - } - }, new Consumer() { - @Override - public void accept(Integer d) { - dispose.set(d); - } - }); + Completable c = Completable.using(() -> 1, v -> error.completable, dispose::set); final AtomicBoolean disposedFirst = new AtomicBoolean(); final AtomicBoolean complete = new AtomicBoolean(); @@ -1349,22 +1176,7 @@ public void onComplete() { public void usingErrorLazy() { final AtomicInteger dispose = new AtomicInteger(); - Completable c = Completable.using(new Supplier() { - @Override - public Integer get() { - return 1; - } - }, new Function() { - @Override - public Completable apply(Integer v) { - return error.completable; - } - }, new Consumer() { - @Override - public void accept(Integer d) { - dispose.set(d); - } - }, false); + Completable c = Completable.using(() -> 1, v -> error.completable, dispose::set, false); final AtomicBoolean disposedFirst = new AtomicBoolean(); final AtomicBoolean complete = new AtomicBoolean(); @@ -1393,132 +1205,50 @@ public void onComplete() { @Test(expected = NullPointerException.class) public void usingResourceSupplierNull() { - Completable.using(null, new Function() { - @Override - public Completable apply(Object v) { - return normal.completable; - } - }, new Consumer() { - @Override - public void accept(Object v) { } - }); + Completable.using(null, v -> normal.completable, v -> { }); } @Test(expected = NullPointerException.class) public void usingMapperNull() { - Completable.using(new Supplier() { - @Override - public Object get() { - return 1; - } - }, null, new Consumer() { - @Override - public void accept(Object v) { } - }); + Completable.using(() -> 1, null, v -> { }); } @Test(expected = NullPointerException.class) public void usingMapperReturnsNull() { - Completable c = Completable.using(new Supplier() { - @Override - public Object get() { - return 1; - } - }, new Function() { - @Override - public Completable apply(Object v) { - return null; - } - }, new Consumer() { - @Override - public void accept(Object v) { } - }); + Completable c = Completable.using(() -> 1, v -> null, v -> { }); c.await(); } @Test(expected = NullPointerException.class) public void usingDisposeNull() { - Completable.using(new Supplier() { - @Override - public Object get() { - return 1; - } - }, new Function() { - @Override - public Completable apply(Object v) { - return normal.completable; - } - }, null); + Completable.using(() -> 1, v -> normal.completable, null); } @Test(expected = TestException.class) public void usingResourceThrows() { - Completable c = Completable.using(new Supplier() { - @Override - public Object get() { throw new TestException(); } - }, - new Function() { - @Override - public Completable apply(Object v) { - return normal.completable; - } - }, new Consumer() { - @Override - public void accept(Object v) { } - }); + Completable c = Completable.using(() -> { throw new TestException(); }, v -> normal.completable, v -> { }); c.await(); } @Test(expected = TestException.class) public void usingMapperThrows() { - Completable c = Completable.using(new Supplier() { - @Override - public Object get() { - return 1; - } - }, - new Function() { - @Override - public Completable apply(Object v) { throw new TestException(); } - }, new Consumer() { - @Override - public void accept(Object v) { } - }); + Completable c = Completable.using(() -> 1, v -> { throw new TestException(); }, v -> { }); c.await(); } @Test(expected = TestException.class) public void usingDisposerThrows() { - Completable c = Completable.using(new Supplier() { - @Override - public Object get() { - return 1; - } - }, - new Function() { - @Override - public Completable apply(Object v) { - return normal.completable; - } - }, new Consumer() { - @Override - public void accept(Object v) { throw new TestException(); } - }); + Completable c = Completable.using(() -> 1, v -> normal.completable, v -> { throw new TestException(); }); c.await(); } @Test(timeout = 1000) public void composeNormal() { - Completable c = error.completable.compose(new CompletableTransformer() { - @Override - public Completable apply(Completable n) { - return n.onErrorComplete(); - } - }); + Completable c = error.completable.compose(Completable::onErrorComplete); c.await(); } @@ -1564,7 +1294,7 @@ public void delayNormal() throws InterruptedException { Completable c = normal.completable.delay(250, TimeUnit.MILLISECONDS); final AtomicBoolean done = new AtomicBoolean(); - final AtomicReference error = new AtomicReference(); + final AtomicReference error = new AtomicReference<>(); c.subscribe(new CompletableSubscriber() { @Override @@ -1599,7 +1329,7 @@ public void delayErrorImmediately() throws InterruptedException { Completable c = error.completable.delay(250, TimeUnit.MILLISECONDS); final AtomicBoolean done = new AtomicBoolean(); - final AtomicReference error = new AtomicReference(); + final AtomicReference error = new AtomicReference<>(); c.subscribe(new CompletableSubscriber() { @Override @@ -1633,7 +1363,7 @@ public void delayErrorToo() throws InterruptedException { Completable c = error.completable.delay(250, TimeUnit.MILLISECONDS, Schedulers.computation(), true); final AtomicBoolean done = new AtomicBoolean(); - final AtomicReference error = new AtomicReference(); + final AtomicReference error = new AtomicReference<>(); c.subscribe(new CompletableSubscriber() { @Override @@ -1667,12 +1397,7 @@ public void onComplete() { public void doOnCompleteNormal() { final AtomicInteger calls = new AtomicInteger(); - Completable c = normal.completable.doOnComplete(new Runnable() { - @Override - public void run() { - calls.getAndIncrement(); - } - }); + Completable c = normal.completable.doOnComplete(calls::getAndIncrement); c.await(); @@ -1683,12 +1408,7 @@ public void run() { public void doOnCompleteError() { final AtomicInteger calls = new AtomicInteger(); - Completable c = error.completable.doOnComplete(new Runnable() { - @Override - public void run() { - calls.getAndIncrement(); - } - }); + Completable c = error.completable.doOnComplete(calls::getAndIncrement); try { c.await(); @@ -1707,10 +1427,7 @@ public void doOnCompleteNull() { @Test(timeout = 1000, expected = TestException.class) public void doOnCompleteThrows() { - Completable c = normal.completable.doOnComplete(new Runnable() { - @Override - public void run() { throw new TestException(); } - }); + Completable c = normal.completable.doOnComplete(() -> { throw new TestException(); }); c.await(); } @@ -1719,12 +1436,7 @@ public void doOnCompleteThrows() { public void doOnDisposeNormalDoesntCall() { final AtomicInteger calls = new AtomicInteger(); - Completable c = normal.completable.doOnDispose(new Runnable() { - @Override - public void run() { - calls.getAndIncrement(); - } - }); + Completable c = normal.completable.doOnDispose(calls::getAndIncrement); c.await(); @@ -1735,12 +1447,7 @@ public void run() { public void doOnDisposeErrorDoesntCall() { final AtomicInteger calls = new AtomicInteger(); - Completable c = error.completable.doOnDispose(new Runnable() { - @Override - public void run() { - calls.getAndIncrement(); - } - }); + Completable c = error.completable.doOnDispose(calls::getAndIncrement); try { c.await(); @@ -1755,12 +1462,7 @@ public void run() { public void doOnDisposeChildCancels() { final AtomicInteger calls = new AtomicInteger(); - Completable c = normal.completable.doOnDispose(new Runnable() { - @Override - public void run() { - calls.getAndIncrement(); - } - }); + Completable c = normal.completable.doOnDispose(calls::getAndIncrement); c.subscribe(new CompletableSubscriber() { @Override @@ -1789,10 +1491,7 @@ public void doOnDisposeNull() { @Test(timeout = 1000) public void doOnDisposeThrows() { - Completable c = normal.completable.doOnDispose(new Runnable() { - @Override - public void run() { throw new TestException(); } - }); + Completable c = normal.completable.doOnDispose(() -> { throw new TestException(); }); c.subscribe(new CompletableSubscriber() { @Override @@ -1814,14 +1513,9 @@ public void onComplete() { @Test(timeout = 1000) public void doOnErrorNoError() { - final AtomicReference error = new AtomicReference(); + final AtomicReference error = new AtomicReference<>(); - Completable c = normal.completable.doOnError(new Consumer() { - @Override - public void accept(Throwable e) { - error.set(e); - } - }); + Completable c = normal.completable.doOnError(error::set); c.await(); @@ -1830,14 +1524,9 @@ public void accept(Throwable e) { @Test(timeout = 1000) public void doOnErrorHasError() { - final AtomicReference err = new AtomicReference(); + final AtomicReference err = new AtomicReference<>(); - Completable c = error.completable.doOnError(new Consumer() { - @Override - public void accept(Throwable e) { - err.set(e); - } - }); + Completable c = error.completable.doOnError(err::set); try { c.await(); @@ -1856,10 +1545,7 @@ public void doOnErrorNull() { @Test(timeout = 1000) public void doOnErrorThrows() { - Completable c = error.completable.doOnError(new Consumer() { - @Override - public void accept(Throwable e) { throw new IllegalStateException(); } - }); + Completable c = error.completable.doOnError(e -> { throw new IllegalStateException(); }); try { c.await(); @@ -1875,12 +1561,7 @@ public void doOnErrorThrows() { public void doOnSubscribeNormal() { final AtomicInteger calls = new AtomicInteger(); - Completable c = normal.completable.doOnSubscribe(new Consumer() { - @Override - public void accept(Disposable s) { - calls.getAndIncrement(); - } - }); + Completable c = normal.completable.doOnSubscribe(s -> calls.getAndIncrement()); for (int i = 0; i < 10; i++) { c.await(); @@ -1896,10 +1577,7 @@ public void doOnSubscribeNull() { @Test(expected = TestException.class) public void doOnSubscribeThrows() { - Completable c = normal.completable.doOnSubscribe(new Consumer() { - @Override - public void accept(Disposable d) { throw new TestException(); } - }); + Completable c = normal.completable.doOnSubscribe(d -> { throw new TestException(); }); c.await(); } @@ -1908,12 +1586,7 @@ public void doOnSubscribeThrows() { public void doOnTerminateNormal() { final AtomicInteger calls = new AtomicInteger(); - Completable c = normal.completable.doOnTerminate(new Runnable() { - @Override - public void run() { - calls.getAndIncrement(); - } - }); + Completable c = normal.completable.doOnTerminate(calls::getAndIncrement); c.await(); @@ -1924,12 +1597,7 @@ public void run() { public void doOnTerminateError() { final AtomicInteger calls = new AtomicInteger(); - Completable c = error.completable.doOnTerminate(new Runnable() { - @Override - public void run() { - calls.getAndIncrement(); - } - }); + Completable c = error.completable.doOnTerminate(calls::getAndIncrement); try { c.await(); @@ -1946,12 +1614,7 @@ public void finallyDoNormal() { final AtomicBoolean doneAfter = new AtomicBoolean(); final AtomicBoolean complete = new AtomicBoolean(); - Completable c = normal.completable.finallyDo(new Runnable() { - @Override - public void run() { - doneAfter.set(complete.get()); - } - }); + Completable c = normal.completable.finallyDo(() -> doneAfter.set(complete.get())); c.subscribe(new CompletableSubscriber() { @Override @@ -1980,12 +1643,7 @@ public void onComplete() { public void finallyDoWithError() { final AtomicBoolean doneAfter = new AtomicBoolean(); - Completable c = error.completable.finallyDo(new Runnable() { - @Override - public void run() { - doneAfter.set(true); - } - }); + Completable c = error.completable.finallyDo(() -> doneAfter.set(true)); try { c.await(); @@ -2035,12 +1693,7 @@ public void liftNull() { @Test(timeout = 1000, expected = NullPointerException.class) public void liftReturnsNull() { - Completable c = normal.completable.lift(new CompletableOperator() { - @Override - public CompletableSubscriber apply(CompletableSubscriber v) { - return null; - } - }); + Completable c = normal.completable.lift(v -> null); c.await(); } @@ -2103,8 +1756,8 @@ public void observeOnNull() { @Test(timeout = 1000) public void observeOnNormal() throws InterruptedException { - final AtomicReference name = new AtomicReference(); - final AtomicReference err = new AtomicReference(); + final AtomicReference name = new AtomicReference<>(); + final AtomicReference err = new AtomicReference<>(); final CountDownLatch cdl = new CountDownLatch(1); Completable c = normal.completable.observeOn(Schedulers.computation()); @@ -2136,8 +1789,8 @@ public void onError(Throwable e) { @Test(timeout = 1000) public void observeOnError() throws InterruptedException { - final AtomicReference name = new AtomicReference(); - final AtomicReference err = new AtomicReference(); + final AtomicReference name = new AtomicReference<>(); + final AtomicReference err = new AtomicReference<>(); final CountDownLatch cdl = new CountDownLatch(1); Completable c = error.completable.observeOn(Schedulers.computation()); @@ -2177,12 +1830,7 @@ public void onErrorComplete() { @Test(timeout = 1000, expected = TestException.class) public void onErrorCompleteFalse() { - Completable c = error.completable.onErrorComplete(new Predicate() { - @Override - public boolean test(Throwable e) { - return e instanceof IllegalStateException; - } - }); + Completable c = error.completable.onErrorComplete(e -> e instanceof IllegalStateException); c.await(); } @@ -2199,12 +1847,7 @@ public void onErrorResumeNextNull() { @Test(timeout = 1000) public void onErrorResumeNextFunctionReturnsNull() { - Completable c = error.completable.onErrorResumeNext(new Function() { - @Override - public Completable apply(Throwable e) { - return null; - } - }); + Completable c = error.completable.onErrorResumeNext(e -> null); try { c.await(); @@ -2216,10 +1859,7 @@ public Completable apply(Throwable e) { @Test(timeout = 1000) public void onErrorResumeNextFunctionThrows() { - Completable c = error.completable.onErrorResumeNext(new Function() { - @Override - public Completable apply(Throwable e) { throw new TestException(); } - }); + Completable c = error.completable.onErrorResumeNext(e -> { throw new TestException(); }); try { c.await(); @@ -2235,51 +1875,33 @@ public void onErrorResumeNextFunctionThrows() { @Test(timeout = 1000) public void onErrorResumeNextNormal() { - Completable c = error.completable.onErrorResumeNext(new Function() { - @Override - public Completable apply(Throwable v) { - return normal.completable; - } - }); + Completable c = error.completable.onErrorResumeNext(v -> normal.completable); c.await(); } @Test(timeout = 1000, expected = TestException.class) public void onErrorResumeNextError() { - Completable c = error.completable.onErrorResumeNext(new Function() { - @Override - public Completable apply(Throwable v) { - return error.completable; - } - }); + Completable c = error.completable.onErrorResumeNext(v -> error.completable); c.await(); } @Test(timeout = 2000) public void repeatNormal() { - final AtomicReference err = new AtomicReference(); + final AtomicReference err = new AtomicReference<>(); final AtomicInteger calls = new AtomicInteger(); - Completable c = Completable.fromCallable(new Callable() { - @Override - public Object call() throws Exception { - calls.getAndIncrement(); - Thread.sleep(100); - return null; - } + Completable c = Completable.fromCallable(() -> { + calls.getAndIncrement(); + Thread.sleep(100); + return null; }).repeat(); c.subscribe(new CompletableSubscriber() { @Override public void onSubscribe(final Disposable d) { - Schedulers.single().scheduleDirect(new Runnable() { - @Override - public void run() { - d.dispose(); - } - }, 550, TimeUnit.MILLISECONDS); + Schedulers.single().scheduleDirect(d::dispose, 550, TimeUnit.MILLISECONDS); } @Override @@ -2308,12 +1930,9 @@ public void repeatError() { public void repeat5Times() { final AtomicInteger calls = new AtomicInteger(); - Completable c = Completable.fromCallable(new Callable() { - @Override - public Object call() throws Exception { - calls.getAndIncrement(); - return null; - } + Completable c = Completable.fromCallable(() -> { + calls.getAndIncrement(); + return null; }).repeat(5); c.await(); @@ -2325,12 +1944,9 @@ public Object call() throws Exception { public void repeat1Time() { final AtomicInteger calls = new AtomicInteger(); - Completable c = Completable.fromCallable(new Callable() { - @Override - public Object call() throws Exception { - calls.getAndIncrement(); - return null; - } + Completable c = Completable.fromCallable(() -> { + calls.getAndIncrement(); + return null; }).repeat(1); c.await(); @@ -2342,12 +1958,9 @@ public Object call() throws Exception { public void repeat0Time() { final AtomicInteger calls = new AtomicInteger(); - Completable c = Completable.fromCallable(new Callable() { - @Override - public Object call() throws Exception { - calls.getAndIncrement(); - return null; - } + Completable c = Completable.fromCallable(() -> { + calls.getAndIncrement(); + return null; }).repeat(0); c.await(); @@ -2360,18 +1973,10 @@ public void repeatUntilNormal() { final AtomicInteger calls = new AtomicInteger(); final AtomicInteger times = new AtomicInteger(5); - Completable c = Completable.fromCallable(new Callable() { - @Override - public Object call() throws Exception { - calls.getAndIncrement(); - return null; - } - }).repeatUntil(new BooleanSupplier() { - @Override - public boolean getAsBoolean() { - return times.decrementAndGet() == 0; - } - }); + Completable c = Completable.fromCallable(() -> { + calls.getAndIncrement(); + return null; + }).repeatUntil(() -> times.decrementAndGet() == 0); c.await(); @@ -2400,12 +2005,9 @@ public void retryNormal() { @Test(timeout = 1000) public void retry5Times() { final AtomicInteger calls = new AtomicInteger(5); - Completable c = Completable.fromRunnable(new Runnable() { - @Override - public void run() { - if (calls.decrementAndGet() != 0) { - throw new TestException(); - } + Completable c = Completable.fromRunnable(() -> { + if (calls.decrementAndGet() != 0) { + throw new TestException(); } }).retry(); @@ -2414,12 +2016,7 @@ public void run() { @Test(timeout = 1000, expected = TestException.class) public void retryBiPredicate5Times() { - Completable c = error.completable.retry(new BiPredicate() { - @Override - public boolean test(Integer n, Throwable e) { - return n < 5; - } - }); + Completable c = error.completable.retry((n, e) -> n < 5); c.await(); } @@ -2435,12 +2032,9 @@ public void retryTimes5Error() { public void retryTimes5Normal() { final AtomicInteger calls = new AtomicInteger(5); - Completable c = Completable.fromRunnable(new Runnable() { - @Override - public void run() { - if (calls.decrementAndGet() != 0) { - throw new TestException(); - } + Completable c = Completable.fromRunnable(() -> { + if (calls.decrementAndGet() != 0) { + throw new TestException(); } }).retry(5); @@ -2454,12 +2048,7 @@ public void retryNegativeTimes() { @Test(timeout = 1000, expected = TestException.class) public void retryPredicateError() { - Completable c = error.completable.retry(new Predicate() { - @Override - public boolean test(Throwable e) { - return false; - } - }); + Completable c = error.completable.retry(e -> false); c.await(); } @@ -2473,20 +2062,12 @@ public void retryPredicateNull() { public void retryPredicate5Times() { final AtomicInteger calls = new AtomicInteger(5); - Completable c = Completable.fromRunnable(new Runnable() { - @Override - public void run() { - if (calls.decrementAndGet() != 0) { - throw new TestException(); - } - } - }).retry(new Predicate() { - @Override - public boolean test(Throwable e) { - return true; + Completable c = Completable.fromRunnable(() -> { + if (calls.decrementAndGet() != 0) { + throw new TestException(); } - }); - + }).retry(e -> true); + c.await(); } @@ -2494,20 +2075,11 @@ public boolean test(Throwable e) { public void retryWhen5Times() { final AtomicInteger calls = new AtomicInteger(5); - Completable c = Completable.fromRunnable(new Runnable() { - @Override - public void run() { - if (calls.decrementAndGet() != 0) { - throw new TestException(); - } - } - }).retryWhen(new Function, Publisher>() { - @SuppressWarnings({ "rawtypes", "unchecked" }) - @Override - public Publisher apply(Observable o) { - return (Publisher)o; + Completable c = Completable.fromRunnable(() -> { + if (calls.decrementAndGet() != 0) { + throw new TestException(); } - }); + }).retryWhen((Publisher o) -> o); c.await(); } @@ -2518,12 +2090,7 @@ public void subscribe() throws InterruptedException { Completable c = normal.completable .delay(100, TimeUnit.MILLISECONDS) - .doOnComplete(new Runnable() { - @Override - public void run() { - complete.set(true); - } - }); + .doOnComplete(() -> complete.set(true)); c.subscribe(); @@ -2538,12 +2105,7 @@ public void subscribeDispose() throws InterruptedException { Completable c = normal.completable .delay(200, TimeUnit.MILLISECONDS) - .doOnComplete(new Runnable() { - @Override - public void run() { - complete.set(true); - } - }); + .doOnComplete(() -> complete.set(true)); Disposable d = c.subscribe(); @@ -2558,19 +2120,9 @@ public void run() { @Test(timeout = 1000) public void subscribeTwoCallbacksNormal() { - final AtomicReference err = new AtomicReference(); + final AtomicReference err = new AtomicReference<>(); final AtomicBoolean complete = new AtomicBoolean(); - normal.completable.subscribe(new Consumer() { - @Override - public void accept(Throwable e) { - err.set(e); - } - }, new Runnable() { - @Override - public void run() { - complete.set(true); - } - }); + normal.completable.subscribe(err::set, () -> complete.set(true)); Assert.assertNull(err.get()); Assert.assertTrue("Not completed", complete.get()); @@ -2578,19 +2130,9 @@ public void run() { @Test(timeout = 1000) public void subscribeTwoCallbacksError() { - final AtomicReference err = new AtomicReference(); + final AtomicReference err = new AtomicReference<>(); final AtomicBoolean complete = new AtomicBoolean(); - error.completable.subscribe(new Consumer() { - @Override - public void accept(Throwable e) { - err.set(e); - } - }, new Runnable() { - @Override - public void run() { - complete.set(true); - } - }); + error.completable.subscribe(err::set, () -> complete.set(true)); Assert.assertTrue(err.get() instanceof TestException); Assert.assertFalse("Not completed", complete.get()); @@ -2598,50 +2140,30 @@ public void run() { @Test(expected = NullPointerException.class) public void subscribeTwoCallbacksFirstNull() { - normal.completable.subscribe(null, new Runnable() { - @Override - public void run() { } - }); + normal.completable.subscribe(null, () -> { }); } @Test(expected = NullPointerException.class) public void subscribeTwoCallbacksSecondNull() { - normal.completable.subscribe(null, new Runnable() { - @Override - public void run() { } - }); + normal.completable.subscribe(null, () -> { }); } @Test(timeout = 1000) public void subscribeTwoCallbacksCompleteThrows() { - final AtomicReference err = new AtomicReference(); - normal.completable.subscribe(new Consumer() { - @Override - public void accept(Throwable e) { - err.set(e); - } - }, new Runnable() { - @Override - public void run() { throw new TestException(); } - }); + final AtomicReference err = new AtomicReference<>(); + normal.completable.subscribe(err::set, () -> { throw new TestException(); }); Assert.assertTrue(String.valueOf(err.get()), err.get() instanceof TestException); } @Test(timeout = 1000) public void subscribeTwoCallbacksOnErrorThrows() { - error.completable.subscribe(new Consumer() { - @Override - public void accept(Throwable e) { throw new TestException(); } - }, new Runnable() { - @Override - public void run() { } - }); + error.completable.subscribe(e -> { throw new TestException(); }, () -> { }); } @Test(timeout = 1000) public void subscribeNbpSubscriberNormal() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); normal.completable.subscribe(ts); @@ -2652,7 +2174,7 @@ public void subscribeNbpSubscriberNormal() { @Test(timeout = 1000) public void subscribeNbpSubscriberError() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); error.completable.subscribe(ts); @@ -2665,11 +2187,8 @@ public void subscribeNbpSubscriberError() { public void subscribeRunnableNormal() { final AtomicBoolean run = new AtomicBoolean(); - normal.completable.subscribe(new Runnable() { - @Override - public void run() { - run.set(true); - } + normal.completable.subscribe(() -> { + run.set(true); }); Assert.assertTrue("Not completed", run.get()); @@ -2679,11 +2198,8 @@ public void run() { public void subscribeRunnableError() { final AtomicBoolean run = new AtomicBoolean(); - error.completable.subscribe(new Runnable() { - @Override - public void run() { - run.set(true); - } + error.completable.subscribe(() -> { + run.set(true); }); Assert.assertFalse("Completed", run.get()); @@ -2711,7 +2227,7 @@ public void subscribeCompletableSubscriberNull() { @Test(timeout = 1000) public void subscribeSubscriberNormal() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); normal.completable.subscribe(ts); @@ -2722,7 +2238,7 @@ public void subscribeSubscriberNormal() { @Test(timeout = 1000) public void subscribeSubscriberError() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); error.completable.subscribe(ts); @@ -2738,15 +2254,12 @@ public void subscribeOnNull() { @Test(timeout = 1000) public void subscribeOnNormal() { - final AtomicReference name = new AtomicReference(); + final AtomicReference name = new AtomicReference<>(); - Completable c = Completable.create(new CompletableOnSubscribe() { - @Override - public void accept(CompletableSubscriber s) { - name.set(Thread.currentThread().getName()); - s.onSubscribe(EmptyDisposable.INSTANCE); - s.onComplete(); - } + Completable c = Completable.create(s -> { + name.set(Thread.currentThread().getName()); + s.onSubscribe(EmptyDisposable.INSTANCE); + s.onComplete(); }).subscribeOn(Schedulers.computation()); c.await(); @@ -2756,15 +2269,12 @@ public void accept(CompletableSubscriber s) { @Test(timeout = 1000) public void subscribeOnError() { - final AtomicReference name = new AtomicReference(); + final AtomicReference name = new AtomicReference<>(); - Completable c = Completable.create(new CompletableOnSubscribe() { - @Override - public void accept(CompletableSubscriber s) { - name.set(Thread.currentThread().getName()); - s.onSubscribe(EmptyDisposable.INSTANCE); - s.onError(new TestException()); - } + Completable c = Completable.create(s -> { + name.set(Thread.currentThread().getName()); + s.onSubscribe(EmptyDisposable.INSTANCE); + s.onError(new TestException()); }).subscribeOn(Schedulers.computation()); try { @@ -2795,12 +2305,9 @@ public void timeoutSwitchNormal() { @Test(timeout = 1000) public void timeoutTimerCancelled() throws InterruptedException { - Completable c = Completable.fromCallable(new Callable() { - @Override - public Object call() throws Exception { - Thread.sleep(50); - return null; - } + Completable c = Completable.fromCallable(() -> { + Thread.sleep(50); + return null; }).timeout(100, TimeUnit.MILLISECONDS, normal.completable); c.await(); @@ -2827,17 +2334,9 @@ public void timeoutOtherNull() { @Test(timeout = 1000) public void toNormal() { - Observable flow = normal.completable.to(new Function>() { - @Override - public Observable apply(Completable c) { - return c.toFlowable(); - } - }); + Observable flow = normal.completable.to(Completable::toFlowable); - flow.toBlocking().forEach(new Consumer() { - @Override - public void accept(Object e) { } - }); + flow.toBlocking().forEach((Consumer) e -> { }); } @Test(expected = NullPointerException.class) @@ -2867,22 +2366,12 @@ public void toNbpObservableError() { @Test(timeout = 1000) public void toSingleSupplierNormal() { - Assert.assertEquals(1, normal.completable.toSingle(new Supplier() { - @Override - public Object get() { - return 1; - } - }).get()); + Assert.assertEquals(Integer.valueOf(1), normal.completable.toSingle(() -> 1).get()); } @Test(timeout = 1000, expected = TestException.class) public void toSingleSupplierError() { - error.completable.toSingle(new Supplier() { - @Override - public Object get() { - return 1; - } - }).get(); + error.completable.toSingle(() -> 1).get(); } @Test(expected = NullPointerException.class) @@ -2892,20 +2381,12 @@ public void toSingleSupplierNull() { @Test(expected = NullPointerException.class) public void toSingleSupplierReturnsNull() { - normal.completable.toSingle(new Supplier() { - @Override - public Object get() { - return null; - } - }).get(); + normal.completable.toSingle(() -> null).get(); } @Test(expected = TestException.class) public void toSingleSupplierThrows() { - normal.completable.toSingle(new Supplier() { - @Override - public Object get() { throw new TestException(); } - }).get(); + normal.completable.toSingle(() -> { throw new TestException(); }).get(); } @Test(timeout = 1000, expected = TestException.class) @@ -2925,27 +2406,19 @@ public void toSingleDefaultNull() { @Test(timeout = 1000) public void unsubscribeOnNormal() throws InterruptedException { - final AtomicReference name = new AtomicReference(); + final AtomicReference name = new AtomicReference<>(); final CountDownLatch cdl = new CountDownLatch(1); normal.completable.delay(1, TimeUnit.SECONDS) - .doOnDispose(new Runnable() { - @Override - public void run() { - name.set(Thread.currentThread().getName()); - cdl.countDown(); - } + .doOnDispose(() -> { + name.set(Thread.currentThread().getName()); + cdl.countDown(); }) .unsubscribeOn(Schedulers.computation()) .subscribe(new CompletableSubscriber() { @Override public void onSubscribe(final Disposable d) { - Schedulers.single().scheduleDirect(new Runnable() { - @Override - public void run() { - d.dispose(); - } - }, 100, TimeUnit.MILLISECONDS); + Schedulers.single().scheduleDirect(d::dispose, 100, TimeUnit.MILLISECONDS); } @Override @@ -3003,11 +2476,8 @@ public void ambArrayOneFires() { final AtomicBoolean complete = new AtomicBoolean(); - c.subscribe(new Runnable() { - @Override - public void run() { - complete.set(true); - } + c.subscribe(() -> { + complete.set(true); }); Assert.assertTrue("First subject no subscribers", ps1.hasSubscribers()); @@ -3032,14 +2502,9 @@ public void ambArrayOneFiresError() { Completable c = Completable.amb(c1, c2); - final AtomicReference complete = new AtomicReference(); + final AtomicReference complete = new AtomicReference<>(); - c.subscribe(new Consumer() { - @Override - public void accept(Throwable v) { - complete.set(v); - } - }, Functions.emptyRunnable()); + c.subscribe(complete::set, Functions.emptyRunnable()); Assert.assertTrue("First subject no subscribers", ps1.hasSubscribers()); Assert.assertTrue("Second subject no subscribers", ps2.hasSubscribers()); @@ -3065,11 +2530,8 @@ public void ambArraySecondFires() { final AtomicBoolean complete = new AtomicBoolean(); - c.subscribe(new Runnable() { - @Override - public void run() { - complete.set(true); - } + c.subscribe(() -> { + complete.set(true); }); Assert.assertTrue("First subject no subscribers", ps1.hasSubscribers()); @@ -3094,14 +2556,9 @@ public void ambArraySecondFiresError() { Completable c = Completable.amb(c1, c2); - final AtomicReference complete = new AtomicReference(); + final AtomicReference complete = new AtomicReference<>(); - c.subscribe(new Consumer() { - @Override - public void accept(Throwable v) { - complete.set(v); - } - }, Functions.emptyRunnable()); + c.subscribe(complete::set, Functions.emptyRunnable()); Assert.assertTrue("First subject no subscribers", ps1.hasSubscribers()); Assert.assertTrue("Second subject no subscribers", ps2.hasSubscribers()); @@ -3123,7 +2580,7 @@ public void ambMultipleOneIsNull() { @Test(timeout = 1000) public void ambIterableEmpty() { - Completable c = Completable.amb(Collections.emptyList()); + Completable c = Completable.amb(Collections.emptyList()); c.await(); } @@ -3135,12 +2592,7 @@ public void ambIterableNull() { @Test(timeout = 1000, expected = NullPointerException.class) public void ambIterableIteratorNull() { - Completable c = Completable.amb(new Iterable() { - @Override - public Iterator iterator() { - return null; - } - }); + Completable c = Completable.amb(() -> null); c.await(); } @@ -3186,11 +2638,8 @@ public void ambIterableManyOneThrows() { @Test(expected = TestException.class) public void ambIterableIterableThrows() { - Completable c = Completable.amb(new Iterable() { - @Override - public Iterator iterator() { - throw new TestException(); - } + Completable c = Completable.amb(() -> { + throw new TestException(); }); c.await(); @@ -3228,11 +2677,8 @@ public void ambWithArrayOneFires() { final AtomicBoolean complete = new AtomicBoolean(); - c.subscribe(new Runnable() { - @Override - public void run() { - complete.set(true); - } + c.subscribe(() -> { + complete.set(true); }); Assert.assertTrue("First subject no subscribers", ps1.hasSubscribers()); @@ -3257,14 +2703,9 @@ public void ambWithArrayOneFiresError() { Completable c = c1.ambWith(c2); - final AtomicReference complete = new AtomicReference(); + final AtomicReference complete = new AtomicReference<>(); - c.subscribe(new Consumer() { - @Override - public void accept(Throwable v) { - complete.set(v); - } - }, Functions.emptyRunnable()); + c.subscribe(complete::set, Functions.emptyRunnable()); Assert.assertTrue("First subject no subscribers", ps1.hasSubscribers()); Assert.assertTrue("Second subject no subscribers", ps2.hasSubscribers()); @@ -3290,12 +2731,7 @@ public void ambWithArraySecondFires() { final AtomicBoolean complete = new AtomicBoolean(); - c.subscribe(new Runnable() { - @Override - public void run() { - complete.set(true); - } - }); + c.subscribe(() -> complete.set(true)); Assert.assertTrue("First subject no subscribers", ps1.hasSubscribers()); Assert.assertTrue("Second subject no subscribers", ps2.hasSubscribers()); @@ -3319,14 +2755,9 @@ public void ambWithArraySecondFiresError() { Completable c = c1.ambWith(c2); - final AtomicReference complete = new AtomicReference(); + final AtomicReference complete = new AtomicReference<>(); - c.subscribe(new Consumer() { - @Override - public void accept(Throwable v) { - complete.set(v); - } - }, Functions.emptyRunnable()); + c.subscribe(v -> complete.set(v), Functions.emptyRunnable()); Assert.assertTrue("First subject no subscribers", ps1.hasSubscribers()); Assert.assertTrue("Second subject no subscribers", ps2.hasSubscribers()); @@ -3343,12 +2774,9 @@ public void accept(Throwable v) { public void startWithCompletableNormal() { final AtomicBoolean run = new AtomicBoolean(); Completable c = normal.completable - .startWith(Completable.fromCallable(new Callable() { - @Override - public Object call() throws Exception { - run.set(normal.get() == 0); - return null; - } + .startWith(Completable.fromCallable(() -> { + run.set(normal.get() == 0); + return null; })); c.await(); @@ -3374,15 +2802,12 @@ public void startWithCompletableError() { public void startWithFlowableNormal() { final AtomicBoolean run = new AtomicBoolean(); Observable c = normal.completable - .startWith(Observable.fromCallable(new Callable() { - @Override - public Object call() throws Exception { - run.set(normal.get() == 0); - return 1; - } + .startWith(Observable.fromCallable(() -> { + run.set(normal.get() == 0); + return 1; })); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); c.subscribe(ts); @@ -3399,7 +2824,7 @@ public void startWithFlowableError() { Observable c = normal.completable .startWith(Observable.error(new TestException())); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); c.subscribe(ts); @@ -3414,15 +2839,12 @@ public void startWithFlowableError() { public void startWithNbpObservableNormal() { final AtomicBoolean run = new AtomicBoolean(); NbpObservable c = normal.completable - .startWith(NbpObservable.fromCallable(new Callable() { - @Override - public Object call() throws Exception { - run.set(normal.get() == 0); - return 1; - } + .startWith(NbpObservable.fromCallable(() -> { + run.set(normal.get() == 0); + return 1; })); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); c.subscribe(ts); @@ -3439,7 +2861,7 @@ public void startWithNbpObservableError() { NbpObservable c = normal.completable .startWith(NbpObservable.error(new TestException())); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); c.subscribe(ts); @@ -3484,12 +2906,9 @@ public void endWithNbpObservableNull() { public void endWithCompletableNormal() { final AtomicBoolean run = new AtomicBoolean(); Completable c = normal.completable - .endWith(Completable.fromCallable(new Callable() { - @Override - public Object call() throws Exception { - run.set(normal.get() == 0); - return null; - } + .endWith(Completable.fromCallable(() -> { + run.set(normal.get() == 0); + return null; })); c.await(); @@ -3515,15 +2934,12 @@ public void endWithCompletableError() { public void endWithFlowableNormal() { final AtomicBoolean run = new AtomicBoolean(); Observable c = normal.completable - .endWith(Observable.fromCallable(new Callable() { - @Override - public Object call() throws Exception { - run.set(normal.get() == 0); - return 1; - } + .endWith(Observable.fromCallable(() -> { + run.set(normal.get() == 0); + return 1; })); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); c.subscribe(ts); @@ -3540,7 +2956,7 @@ public void endWithFlowableError() { Observable c = normal.completable .endWith(Observable.error(new TestException())); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); c.subscribe(ts); @@ -3555,15 +2971,12 @@ public void endWithFlowableError() { public void endWithNbpObservableNormal() { final AtomicBoolean run = new AtomicBoolean(); NbpObservable c = normal.completable - .endWith(NbpObservable.fromCallable(new Callable() { - @Override - public Object call() throws Exception { - run.set(normal.get() == 0); - return 1; - } + .endWith(NbpObservable.fromCallable(() -> { + run.set(normal.get() == 0); + return 1; })); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); c.subscribe(ts); @@ -3580,7 +2993,7 @@ public void endWithNbpObservableError() { NbpObservable c = normal.completable .endWith(NbpObservable.error(new TestException())); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); c.subscribe(ts); diff --git a/src/test/java/io/reactivex/ConcatTests.java b/rxjava/src/test/java/io/reactivex/ConcatTests.java similarity index 100% rename from src/test/java/io/reactivex/ConcatTests.java rename to rxjava/src/test/java/io/reactivex/ConcatTests.java diff --git a/rxjava/src/test/java/io/reactivex/CovarianceTest.java b/rxjava/src/test/java/io/reactivex/CovarianceTest.java new file mode 100644 index 0000000000..939c233d12 --- /dev/null +++ b/rxjava/src/test/java/io/reactivex/CovarianceTest.java @@ -0,0 +1,182 @@ +/** + * Copyright 2016 Netflix, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.reactivex; + +import static org.junit.Assert.assertEquals; + +import java.util.*; + +import org.junit.Test; +import org.reactivestreams.Publisher; + +import io.reactivex.Observable; +import io.reactivex.Observable.Transformer; +import io.reactivex.functions.*; +import io.reactivex.observables.GroupedObservable; +import io.reactivex.subscribers.TestSubscriber; + +/** + * Test super/extends of generics. + * + * See https://github.com/Netflix/RxJava/pull/331 + */ +public class CovarianceTest { + + /** + * This won't compile if super/extends isn't done correctly on generics + */ + @Test + public void testCovarianceOfFrom() { + Observable. just(new HorrorMovie()); + Observable. fromIterable(new ArrayList()); + // Observable.from(new Movie()); // may not compile + } + + @Test + public void testSortedList() { + Comparator SORT_FUNCTION = (t1, t2) -> 1; + + // this one would work without the covariance generics + Observable o = Observable.just(new Movie(), new TVSeason(), new Album()); + o.toSortedList(SORT_FUNCTION); + + // this one would NOT work without the covariance generics + Observable o2 = Observable.just(new Movie(), new ActionMovie(), new HorrorMovie()); + o2.toSortedList(SORT_FUNCTION); + } + + @Test + public void testGroupByCompose() { + Observable movies = Observable.just(new HorrorMovie(), new ActionMovie(), new Movie()); + TestSubscriber ts = new TestSubscriber<>(); + + movies + .groupBy(Object::getClass) + .doOnNext(g -> System.out.println(g.key())) + .flatMap(g -> + g.doOnNext(System.out::println) + .compose(m -> m.concatWith(Observable.just(new ActionMovie()))) + .map(Object::toString)) + .subscribe(ts); + ts.assertTerminated(); + ts.assertNoErrors(); + //System.out.println(ts.getOnNextEvents()); + assertEquals(6, ts.valueCount()); + } + + @SuppressWarnings("unused") + @Test + public void testCovarianceOfCompose() { + Observable movie = Observable.just(new HorrorMovie()); + Observable movie2 = movie.compose(t -> Observable.just(new Movie())); + } + + @SuppressWarnings("unused") + @Test + public void testCovarianceOfCompose2() { + Observable movie = Observable.just(new HorrorMovie()); + Observable movie2 = movie.compose(t -> Observable.just(new HorrorMovie())); + } + + @SuppressWarnings("unused") + @Test + public void testCovarianceOfCompose3() { + Observable movie = Observable.just(new HorrorMovie()); + Observable movie2 = movie.compose(t -> Observable.just(new HorrorMovie()).map(v -> v) + ); + } + + @SuppressWarnings("unused") + @Test + public void testCovarianceOfCompose4() { + Observable movie = Observable.just(new HorrorMovie()); + Observable movie2 = movie.compose(t1 -> t1.map(v -> v)); + } + + @Test + public void testComposeWithDeltaLogic() { + List list1 = Arrays.asList(new Movie(), new HorrorMovie(), new ActionMovie()); + List list2 = Arrays.asList(new ActionMovie(), new Movie(), new HorrorMovie(), new ActionMovie()); + Observable> movies = Observable.just(list1, list2); + movies.compose(deltaTransformer); + } + + static Function>, Observable> calculateDelta = listOfLists -> { + if (listOfLists.size() == 1) { + return Observable.fromIterable(listOfLists.get(0)); + } else { + // diff the two + List newList = listOfLists.get(1); + List oldList = new ArrayList<>(listOfLists.get(0)); + + Set delta = new LinkedHashSet<>(); + delta.addAll(newList); + // remove all that match in old + delta.removeAll(oldList); + + // filter oldList to those that aren't in the newList + oldList.removeAll(newList); + + // for all left in the oldList we'll create DROP events + for (@SuppressWarnings("unused") Movie old : oldList) { + delta.add(new Movie()); + } + + return Observable.fromIterable(delta); + } + }; + + static Transformer, Movie> deltaTransformer = movieList -> movieList + .startWith(new ArrayList()) + .buffer(2, 1) + .skip(1) + .flatMap(calculateDelta); + + /* + * Most tests are moved into their applicable classes such as [Operator]Tests.java + */ + + static class Media { + } + + static class Movie extends Media { + } + + static class HorrorMovie extends Movie { + } + + static class ActionMovie extends Movie { + } + + static class Album extends Media { + } + + static class TVSeason extends Media { + } + + static class Rating { + } + + static class CoolRating extends Rating { + } + + static class Result { + } + + static class ExtendedResult extends Result { + } +} diff --git a/src/test/java/io/reactivex/ErrorHandlingTests.java b/rxjava/src/test/java/io/reactivex/ErrorHandlingTests.java similarity index 98% rename from src/test/java/io/reactivex/ErrorHandlingTests.java rename to rxjava/src/test/java/io/reactivex/ErrorHandlingTests.java index b538fe216e..5111082af1 100644 --- a/src/test/java/io/reactivex/ErrorHandlingTests.java +++ b/rxjava/src/test/java/io/reactivex/ErrorHandlingTests.java @@ -32,7 +32,7 @@ public class ErrorHandlingTests { @Test public void testOnNextError() throws InterruptedException { final CountDownLatch latch = new CountDownLatch(1); - final AtomicReference caughtError = new AtomicReference(); + final AtomicReference caughtError = new AtomicReference<>(); Observable o = Observable.interval(50, TimeUnit.MILLISECONDS); Subscriber observer = new Observer() { @@ -68,7 +68,7 @@ public void onNext(Long args) { @Test public void testOnNextErrorAcrossThread() throws InterruptedException { final CountDownLatch latch = new CountDownLatch(1); - final AtomicReference caughtError = new AtomicReference(); + final AtomicReference caughtError = new AtomicReference<>(); Observable o = Observable.interval(50, TimeUnit.MILLISECONDS); Subscriber observer = new Observer() { diff --git a/src/test/java/io/reactivex/EventStream.java b/rxjava/src/test/java/io/reactivex/EventStream.java similarity index 81% rename from src/test/java/io/reactivex/EventStream.java rename to rxjava/src/test/java/io/reactivex/EventStream.java index 45a3e3992c..f5361e0a2a 100644 --- a/src/test/java/io/reactivex/EventStream.java +++ b/rxjava/src/test/java/io/reactivex/EventStream.java @@ -30,23 +30,20 @@ private EventStream() { } public static Observable getEventStream(final String type, final int numInstances) { - return Observable.generate(new Consumer>() { - @Override - public void accept(Subscriber s) { - s.onNext(randomEvent(type, numInstances)); - try { - // slow it down somewhat - Thread.sleep(50); - } catch (InterruptedException e) { - Thread.currentThread().interrupt(); - s.onError(e); - } + return Observable.generate(s -> { + s.onNext(randomEvent(type, numInstances)); + try { + // slow it down somewhat + Thread.sleep(50); + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + s.onError(e); } }).subscribeOn(Schedulers.newThread()); } public static Event randomEvent(String type, int numInstances) { - Map values = new LinkedHashMap(); + Map values = new LinkedHashMap<>(); values.put("count200", randomIntFrom0to(4000)); values.put("count4xx", randomIntFrom0to(300)); values.put("count5xx", randomIntFrom0to(500)); diff --git a/src/test/java/io/reactivex/GroupByTests.java b/rxjava/src/test/java/io/reactivex/GroupByTests.java similarity index 53% rename from src/test/java/io/reactivex/GroupByTests.java rename to rxjava/src/test/java/io/reactivex/GroupByTests.java index 73ba84e80b..1fb5a315e0 100644 --- a/src/test/java/io/reactivex/GroupByTests.java +++ b/rxjava/src/test/java/io/reactivex/GroupByTests.java @@ -30,20 +30,12 @@ public void testTakeUnsubscribesOnGroupBy() { EventStream.getEventStream("HTTP-ClusterB", 20) ) // group by type (2 clusters) - .groupBy(new Function() { - @Override - public Object apply(Event event) { - return event.type; - } - }) + .groupBy(event -> event.type) .take(1) .toBlocking() - .forEach(new Consumer>() { - @Override - public void accept(GroupedObservable v) { - System.out.println(v); - v.take(1).subscribe(); // FIXME groups need consumption to a certain degree to cancel upstream - } + .forEach((Consumer>) v -> { + System.out.println(v); + v.take(1).subscribe(); // FIXME groups need consumption to a certain degree to cancel upstream }); System.out.println("**** finished"); @@ -56,31 +48,11 @@ public void testTakeUnsubscribesOnFlatMapOfGroupBy() { EventStream.getEventStream("HTTP-ClusterB", 20) ) // group by type (2 clusters) - .groupBy(new Function() { - @Override - public Object apply(Event event) { - return event.type; - } - }) - .flatMap(new Function, Publisher>() { - @Override - public Publisher apply(GroupedObservable g) { - return g.map(new Function() { - @Override - public Object apply(Event event) { - return event.instanceId + " - " + event.values.get("count200"); - } - }); - } - }) + .groupBy(event -> event.type) + .flatMap(g -> g.map(event -> event.instanceId + " - " + event.values.get("count200"))) .take(20) .toBlocking() - .forEach(new Consumer() { - @Override - public void accept(Object v) { - System.out.println(v); - } - }); + .forEach((Consumer) System.out::println); System.out.println("**** finished"); } diff --git a/src/test/java/io/reactivex/MergeTests.java b/rxjava/src/test/java/io/reactivex/MergeTests.java similarity index 90% rename from src/test/java/io/reactivex/MergeTests.java rename to rxjava/src/test/java/io/reactivex/MergeTests.java index 4fcc2ec74b..9276e6afe2 100644 --- a/src/test/java/io/reactivex/MergeTests.java +++ b/rxjava/src/test/java/io/reactivex/MergeTests.java @@ -76,15 +76,10 @@ public void testMergeCovariance3() { @Test public void testMergeCovariance4() { - Observable o1 = Observable.defer(new Supplier>() { - @Override - public Publisher get() { - return Observable.just( - new HorrorMovie(), - new Movie() - ); - } - }); + Observable o1 = Observable.defer(() -> Observable.just( + new HorrorMovie(), + new Movie() + )); Observable o2 = Observable.just(new Media(), new HorrorMovie()); diff --git a/src/test/java/io/reactivex/NbpObservableNullTests.java b/rxjava/src/test/java/io/reactivex/NbpObservableNullTests.java similarity index 55% rename from src/test/java/io/reactivex/NbpObservableNullTests.java rename to rxjava/src/test/java/io/reactivex/NbpObservableNullTests.java index 0de47ca4d4..04dffdcaff 100644 --- a/src/test/java/io/reactivex/NbpObservableNullTests.java +++ b/rxjava/src/test/java/io/reactivex/NbpObservableNullTests.java @@ -56,12 +56,7 @@ public void ambIterableNull() { @Test(expected = NullPointerException.class) public void ambIterableIteratorNull() { - NbpObservable.amb(new Iterable>() { - @Override - public Iterator> iterator() { - return null; - } - }).toBlocking().lastOption(); + NbpObservable.amb(() -> null).toBlocking().lastOption(); } @SuppressWarnings("unchecked") @@ -72,59 +67,29 @@ public void ambIterableOneIsNull() { @Test(expected = NullPointerException.class) public void combineLatestVarargsNull() { - NbpObservable.combineLatest(new Function() { - @Override - public Object apply(Object[] v) { - return 1; - } - }, true, 128, (NbpObservable[])null); + NbpObservable.combineLatest(v -> 1, true, 128, (NbpObservable[])null); } @SuppressWarnings("unchecked") @Test(expected = NullPointerException.class) public void combineLatestVarargsOneIsNull() { - NbpObservable.combineLatest(new Function() { - @Override - public Object apply(Object[] v) { - return 1; - } - }, true, 128, NbpObservable.never(), null).toBlocking().lastOption(); + NbpObservable.combineLatest(v -> 1, true, 128, NbpObservable.never(), null).toBlocking().lastOption(); } @Test(expected = NullPointerException.class) public void combineLatestIterableNull() { - NbpObservable.combineLatest((Iterable>)null, new Function() { - @Override - public Object apply(Object[] v) { - return 1; - } - }, true, 128); + NbpObservable.combineLatest((Iterable>)null, v -> 1, true, 128); } @Test(expected = NullPointerException.class) public void combineLatestIterableIteratorNull() { - NbpObservable.combineLatest(new Iterable>() { - @Override - public Iterator> iterator() { - return null; - } - }, new Function() { - @Override - public Object apply(Object[] v) { - return 1; - } - }, true, 128).toBlocking().lastOption(); + NbpObservable.combineLatest(() -> null, v -> 1, true, 128).toBlocking().lastOption(); } @SuppressWarnings("unchecked") @Test(expected = NullPointerException.class) public void combineLatestIterableOneIsNull() { - NbpObservable.combineLatest(Arrays.asList(NbpObservable.never(), null), new Function() { - @Override - public Object apply(Object[] v) { - return 1; - } - }, true, 128).toBlocking().lastOption(); + NbpObservable.combineLatest(Arrays.asList(NbpObservable.never(), null), v -> 1, true, 128).toBlocking().lastOption(); } @SuppressWarnings("unchecked") @@ -136,12 +101,7 @@ public void combineLatestVarargsFunctionNull() { @SuppressWarnings("unchecked") @Test(expected = NullPointerException.class) public void combineLatestVarargsFunctionReturnsNull() { - NbpObservable.combineLatest(new Function() { - @Override - public Object apply(Object[] v) { - return null; - } - }, true, 128, just1).toBlocking().lastOption(); + NbpObservable.combineLatest(v -> null, true, 128, just1).toBlocking().lastOption(); } @SuppressWarnings("unchecked") @@ -153,12 +113,7 @@ public void combineLatestIterableFunctionNull() { @SuppressWarnings("unchecked") @Test(expected = NullPointerException.class) public void combineLatestIterableFunctionReturnsNull() { - NbpObservable.combineLatest(Arrays.asList(just1), new Function() { - @Override - public Object apply(Object[] v) { - return null; - } - }, true, 128).toBlocking().lastOption(); + NbpObservable.combineLatest(Arrays.asList(just1), v -> null, true, 128).toBlocking().lastOption(); } @Test(expected = NullPointerException.class) @@ -168,12 +123,7 @@ public void concatIterableNull() { @Test(expected = NullPointerException.class) public void concatIterableIteratorNull() { - NbpObservable.concat(new Iterable>() { - @Override - public Iterator> iterator() { - return null; - } - }).toBlocking().lastOption(); + NbpObservable.concat(() -> null).toBlocking().lastOption(); } @SuppressWarnings("unchecked") @@ -211,12 +161,7 @@ public void deferFunctionNull() { @Test(expected = NullPointerException.class) public void deferFunctionReturnsNull() { - NbpObservable.defer(new Supplier>() { - @Override - public NbpObservable get() { - return null; - } - }).toBlocking().lastOption(); + NbpObservable.defer(() -> null).toBlocking().lastOption(); } @Test(expected = NullPointerException.class) @@ -226,12 +171,7 @@ public void errorFunctionNull() { @Test(expected = NullPointerException.class) public void errorFunctionReturnsNull() { - NbpObservable.error(new Supplier() { - @Override - public Throwable get() { - return null; - } - }).toBlocking().run(); + NbpObservable.error(() -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) @@ -256,12 +196,7 @@ public void fromCallableNull() { @Test(expected = NullPointerException.class) public void fromCallableReturnsNull() { - NbpObservable.fromCallable(new Callable() { - @Override - public Object call() throws Exception { - return null; - } - }).toBlocking().lastOption(); + NbpObservable.fromCallable(() -> null).toBlocking().lastOption(); } @Test(expected = NullPointerException.class) @@ -271,10 +206,10 @@ public void fromFutureNull() { @Test public void fromFutureReturnsNull() { - FutureTask f = new FutureTask(Functions.emptyRunnable(), null); + FutureTask f = new FutureTask<>(Functions.emptyRunnable(), null); f.run(); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpObservable.fromFuture(f).subscribe(ts); ts.assertNoValues(); ts.assertNotComplete(); @@ -288,24 +223,24 @@ public void fromFutureTimedFutureNull() { @Test(expected = NullPointerException.class) public void fromFutureTimedUnitNull() { - NbpObservable.fromFuture(new FutureTask(Functions.emptyRunnable(), null), 1, null); + NbpObservable.fromFuture(new FutureTask<>(Functions.emptyRunnable(), null), 1, null); } @Test(expected = NullPointerException.class) public void fromFutureTimedSchedulerNull() { - NbpObservable.fromFuture(new FutureTask(Functions.emptyRunnable(), null), 1, TimeUnit.SECONDS, null); + NbpObservable.fromFuture(new FutureTask<>(Functions.emptyRunnable(), null), 1, TimeUnit.SECONDS, null); } @Test(expected = NullPointerException.class) public void fromFutureTimedReturnsNull() { - FutureTask f = new FutureTask(Functions.emptyRunnable(), null); + FutureTask f = new FutureTask<>(Functions.emptyRunnable(), null); f.run(); NbpObservable.fromFuture(f, 1, TimeUnit.SECONDS).toBlocking().lastOption(); } @Test(expected = NullPointerException.class) public void fromFutureSchedulerNull() { - FutureTask f = new FutureTask(Functions.emptyRunnable(), null); + FutureTask f = new FutureTask<>(Functions.emptyRunnable(), null); NbpObservable.fromFuture(f, null); } @@ -316,12 +251,7 @@ public void fromIterableNull() { @Test(expected = NullPointerException.class) public void fromIterableIteratorNull() { - NbpObservable.fromIterable(new Iterable() { - @Override - public Iterator iterator() { - return null; - } - }).toBlocking().lastOption(); + NbpObservable.fromIterable(() -> null).toBlocking().lastOption(); } @Test(expected = NullPointerException.class) @@ -336,98 +266,53 @@ public void generateConsumerNull() { @Test(expected = NullPointerException.class) public void generateConsumerEmitsNull() { - NbpObservable.generate(new Consumer>() { - @Override - public void accept(NbpSubscriber s) { - s.onNext(null); - } - }).toBlocking().lastOption(); + NbpObservable.generate(s -> s.onNext(null)).toBlocking().lastOption(); } @Test(expected = NullPointerException.class) public void generateStateConsumerInitialStateNull() { - BiConsumer> generator = new BiConsumer>() { - @Override - public void accept(Integer s, NbpSubscriber o) { - o.onNext(1); - } - }; + BiConsumer> generator = (s, o) -> o.onNext(1); NbpObservable.generate(null, generator); } @Test(expected = NullPointerException.class) public void generateStateFunctionInitialStateNull() { - NbpObservable.generate(null, new BiFunction, Object>() { - @Override - public Object apply(Object s, NbpSubscriber o) { o.onNext(1); return s; } + NbpObservable.generate(null, (s, o) -> { + o.onNext(1); + return s; }); } @Test(expected = NullPointerException.class) public void generateStateConsumerNull() { - NbpObservable.generate(new Supplier() { - @Override - public Integer get() { - return 1; - } - }, (BiConsumer>)null); + NbpObservable.generate(() -> 1, (BiConsumer>)null); } @Test public void generateConsumerStateNullAllowed() { - BiConsumer> generator = new BiConsumer>() { - @Override - public void accept(Integer s, NbpSubscriber o) { - o.onComplete(); - } - }; - NbpObservable.generate(new Supplier() { - @Override - public Integer get() { - return null; - } - }, generator).toBlocking().lastOption(); + BiConsumer> generator = (s, o) -> o.onComplete(); + NbpObservable.generate(() -> null, generator).toBlocking().lastOption(); } @Test public void generateFunctionStateNullAllowed() { - NbpObservable.generate(new Supplier() { - @Override - public Object get() { - return null; - } - }, new BiFunction, Object>() { - @Override - public Object apply(Object s, NbpSubscriber o) { o.onComplete(); return s; } + NbpObservable.generate(() -> null, (s, o) -> { + o.onComplete(); + return s; }).toBlocking().lastOption(); } @Test(expected = NullPointerException.class) public void generateConsumerDisposeNull() { - BiConsumer> generator = new BiConsumer>() { - @Override - public void accept(Integer s, NbpSubscriber o) { - o.onNext(1); - } - }; - NbpObservable.generate(new Supplier() { - @Override - public Integer get() { - return 1; - } - }, generator, null); + BiConsumer> generator = (s, o) -> o.onNext(1); + NbpObservable.generate(() -> 1, generator, null); } @Test(expected = NullPointerException.class) public void generateFunctionDisposeNull() { - NbpObservable.generate(new Supplier() { - @Override - public Object get() { - return 1; - } - }, new BiFunction, Object>() { - @Override - public Object apply(Object s, NbpSubscriber o) { o.onNext(1); return s; } + NbpObservable.generate(() -> 1, (s, o) -> { + o.onNext(1); + return s; }, null); } @@ -494,12 +379,7 @@ public void mergeIterableNull() { @Test(expected = NullPointerException.class) public void mergeIterableIteratorNull() { - NbpObservable.merge(128, 128, new Iterable>() { - @Override - public Iterator> iterator() { - return null; - } - }).toBlocking().lastOption(); + NbpObservable.merge(128, 128, () -> null).toBlocking().lastOption(); } @SuppressWarnings("unchecked") @@ -526,12 +406,7 @@ public void mergeDelayErrorIterableNull() { @Test(expected = NullPointerException.class) public void mergeDelayErrorIterableIteratorNull() { - NbpObservable.mergeDelayError(128, 128, new Iterable>() { - @Override - public Iterator> iterator() { - return null; - } - }).toBlocking().lastOption(); + NbpObservable.mergeDelayError(128, 128, () -> null).toBlocking().lastOption(); } @SuppressWarnings("unchecked") @@ -583,86 +458,32 @@ public void timerSchedulerNull() { @Test(expected = NullPointerException.class) public void usingResourceSupplierNull() { - NbpObservable.using(null, new Function>() { - @Override - public NbpObservable apply(Object d) { - return just1; - } - }, new Consumer() { - @Override - public void accept(Object d) { } - }); + NbpObservable.using(null, d -> just1, d -> { }); } @Test(expected = NullPointerException.class) public void usingNbpObservableSupplierNull() { - NbpObservable.using(new Supplier() { - @Override - public Object get() { - return 1; - } - }, null, new Consumer() { - @Override - public void accept(Object d) { } - }); + NbpObservable.using(() -> 1, null, d -> { }); } @Test(expected = NullPointerException.class) public void usingNbpObservableSupplierReturnsNull() { - NbpObservable.using(new Supplier() { - @Override - public Object get() { - return 1; - } - }, new Function>() { - @Override - public NbpObservable apply(Object d) { - return null; - } - }, new Consumer() { - @Override - public void accept(Object d) { } - }).toBlocking().lastOption(); + NbpObservable.using(() -> 1, d -> null, d -> { }).toBlocking().lastOption(); } @Test(expected = NullPointerException.class) public void usingDisposeNull() { - NbpObservable.using(new Supplier() { - @Override - public Object get() { - return 1; - } - }, new Function>() { - @Override - public NbpObservable apply(Object d) { - return just1; - } - }, null); + NbpObservable.using(() -> 1, d -> just1, null); } @Test(expected = NullPointerException.class) public void zipIterableNull() { - NbpObservable.zip((Iterable>)null, new Function() { - @Override - public Object apply(Object[] v) { - return 1; - } - }); + NbpObservable.zip((Iterable>)null, v -> 1); } @Test(expected = NullPointerException.class) public void zipIterableIteratorNull() { - NbpObservable.zip(new Iterable>() { - @Override - public Iterator> iterator() { - return null; - } - }, new Function() { - @Override - public Object apply(Object[] v) { - return 1; - } - }).toBlocking().lastOption(); + NbpObservable.zip(() -> null, v -> 1).toBlocking().lastOption(); } @SuppressWarnings("unchecked") @@ -674,22 +495,12 @@ public void zipIterableFunctionNull() { @SuppressWarnings("unchecked") @Test(expected = NullPointerException.class) public void zipIterableFunctionReturnsNull() { - NbpObservable.zip(Arrays.asList(just1, just1), new Function() { - @Override - public Object apply(Object[] a) { - return null; - } - }).toBlocking().lastOption(); + NbpObservable.zip(Arrays.asList(just1, just1), a -> null).toBlocking().lastOption(); } @Test(expected = NullPointerException.class) public void zipNbpObservableNull() { - NbpObservable.zip((NbpObservable>)null, new Function() { - @Override - public Object apply(Object[] a) { - return 1; - } - }); + NbpObservable.zip((NbpObservable>)null, a -> 1); } @Test(expected = NullPointerException.class) @@ -699,37 +510,17 @@ public void zipNbpObservableFunctionNull() { @Test(expected = NullPointerException.class) public void zipNbpObservableFunctionReturnsNull() { - NbpObservable.zip((NbpObservable.just(just1)), new Function() { - @Override - public Object apply(Object[] a) { - return null; - } - }).toBlocking().lastOption(); + NbpObservable.zip((NbpObservable.just(just1)), a -> null).toBlocking().lastOption(); } @Test(expected = NullPointerException.class) public void zipIterable2Null() { - NbpObservable.zipIterable(new Function() { - @Override - public Object apply(Object[] a) { - return 1; - } - }, true, 128, (Iterable>)null); + NbpObservable.zipIterable(a -> 1, true, 128, null); } @Test(expected = NullPointerException.class) public void zipIterable2IteratorNull() { - NbpObservable.zipIterable(new Function() { - @Override - public Object apply(Object[] a) { - return 1; - } - }, true, 128, new Iterable>() { - @Override - public Iterator> iterator() { - return null; - } - }).toBlocking().lastOption(); + NbpObservable.zipIterable(a -> 1, true, 128, () -> null).toBlocking().lastOption(); } @SuppressWarnings("unchecked") @@ -741,12 +532,7 @@ public void zipIterable2FunctionNull() { @SuppressWarnings("unchecked") @Test(expected = NullPointerException.class) public void zipIterable2FunctionReturnsNull() { - NbpObservable.zipIterable(new Function() { - @Override - public Object apply(Object[] a) { - return null; - } - }, true, 128, Arrays.asList(just1, just1)).toBlocking().lastOption(); + NbpObservable.zipIterable(a -> null, true, 128, Arrays.asList(just1, just1)).toBlocking().lastOption(); } //************************************************************* @@ -775,12 +561,7 @@ public void bufferSupplierNull() { @Test(expected = NullPointerException.class) public void bufferSupplierReturnsNull() { - just1.buffer(1, 1, new Supplier>() { - @Override - public Collection get() { - return null; - } - }).toBlocking().run(); + just1.buffer(1, 1, () -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) @@ -800,22 +581,12 @@ public void bufferTimedSupplierNull() { @Test(expected = NullPointerException.class) public void bufferTimedSupplierReturnsNull() { - just1.buffer(1L, 1L, TimeUnit.SECONDS, Schedulers.single(), new Supplier>() { - @Override - public Collection get() { - return null; - } - }).toBlocking().run(); + just1.buffer(1L, 1L, TimeUnit.SECONDS, Schedulers.single(), () -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) public void bufferOpenCloseOpenNull() { - just1.buffer(null, new Function>() { - @Override - public NbpObservable apply(Object o) { - return just1; - } - }); + just1.buffer(null, o -> just1); } @Test(expected = NullPointerException.class) @@ -825,12 +596,7 @@ public void bufferOpenCloseCloseNull() { @Test(expected = NullPointerException.class) public void bufferOpenCloseCloseReturnsNull() { - just1.buffer(just1, new Function>() { - @Override - public NbpObservable apply(Integer v) { - return null; - } - }).toBlocking().run(); + just1.buffer(just1, v -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) @@ -845,12 +611,7 @@ public void bufferBoundarySupplierNull() { @Test(expected = NullPointerException.class) public void bufferBoundarySupplierReturnsNull() { - just1.buffer(just1, new Supplier>() { - @Override - public Collection get() { - return null; - } - }).toBlocking().run(); + just1.buffer(just1, () -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) @@ -860,37 +621,17 @@ public void bufferBoundarySupplier2Null() { @Test(expected = NullPointerException.class) public void bufferBoundarySupplier2ReturnsNull() { - just1.buffer(new Supplier>() { - @Override - public NbpObservable get() { - return null; - } - }).toBlocking().run(); + just1.buffer(() -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) public void bufferBoundarySupplier2SupplierNull() { - just1.buffer(new Supplier>() { - @Override - public NbpObservable get() { - return just1; - } - }, null); + just1.buffer(() -> just1, null); } @Test(expected = NullPointerException.class) public void bufferBoundarySupplier2SupplierReturnsNull() { - just1.buffer(new Supplier>() { - @Override - public NbpObservable get() { - return just1; - } - }, new Supplier>() { - @Override - public Collection get() { - return null; - } - }).toBlocking().run(); + just1.buffer(() -> just1, () -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) @@ -900,41 +641,22 @@ public void castNull() { @Test(expected = NullPointerException.class) public void collectInitialSupplierNull() { - just1.collect((Supplier)null, new BiConsumer() { - @Override - public void accept(Integer a, Integer b) { } - }); + just1.collect(null, (a, b) -> { }); } @Test(expected = NullPointerException.class) public void collectInitialSupplierReturnsNull() { - just1.collect(new Supplier() { - @Override - public Object get() { - return null; - } - }, new BiConsumer() { - @Override - public void accept(Object a, Integer b) { } - }).toBlocking().run(); + just1.collect(() -> null, (a, b) -> { }).toBlocking().run(); } @Test(expected = NullPointerException.class) public void collectInitialCollectorNull() { - just1.collect(new Supplier() { - @Override - public Object get() { - return 1; - } - }, null); + just1.collect(() -> 1, null); } @Test(expected = NullPointerException.class) public void collectIntoInitialNull() { - just1.collectInto(null, new BiConsumer() { - @Override - public void accept(Object a, Integer b) { } - }); + just1.collectInto(null, (a, b) -> { }); } @Test(expected = NullPointerException.class) @@ -954,12 +676,7 @@ public void concatMapNull() { @Test(expected = NullPointerException.class) public void concatMapReturnsNull() { - just1.concatMap(new Function>() { - @Override - public NbpObservable apply(Integer v) { - return null; - } - }).toBlocking().run(); + just1.concatMap(v -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) @@ -969,27 +686,12 @@ public void concatMapIterableNull() { @Test(expected = NullPointerException.class) public void concatMapIterableReturnNull() { - just1.concatMapIterable(new Function>() { - @Override - public Iterable apply(Integer v) { - return null; - } - }).toBlocking().run(); + just1.concatMapIterable(v -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) public void concatMapIterableIteratorNull() { - just1.concatMapIterable(new Function>() { - @Override - public Iterable apply(Integer v) { - return new Iterable() { - @Override - public Iterator iterator() { - return null; - } - }; - } - }).toBlocking().run(); + just1.concatMapIterable(v -> () -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) @@ -1009,12 +711,7 @@ public void debounceFunctionNull() { @Test(expected = NullPointerException.class) public void debounceFunctionReturnsNull() { - just1.debounce(new Function>() { - @Override - public NbpObservable apply(Integer v) { - return null; - } - }).toBlocking().run(); + just1.debounce(v -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) @@ -1039,12 +736,7 @@ public void delayWithFunctionNull() { @Test(expected = NullPointerException.class) public void delayWithFunctionReturnsNull() { - just1.delay(new Function>() { - @Override - public NbpObservable apply(Integer v) { - return null; - } - }).toBlocking().run(); + just1.delay(v -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) @@ -1079,52 +771,22 @@ public void delaySubscriptionFunctionNull() { @Test(expected = NullPointerException.class) public void delayBothInitialSupplierNull() { - just1.delay(null, new Function>() { - @Override - public NbpObservable apply(Integer v) { - return just1; - } - }); + just1.delay(null, v -> just1); } @Test(expected = NullPointerException.class) public void delayBothInitialSupplierReturnsNull() { - just1.delay(new Supplier>() { - @Override - public NbpObservable get() { - return null; - } - }, new Function>() { - @Override - public NbpObservable apply(Integer v) { - return just1; - } - }).toBlocking().run(); + just1.delay(() -> null, v -> just1).toBlocking().run(); } @Test(expected = NullPointerException.class) public void delayBothItemSupplierNull() { - just1.delay(new Supplier>() { - @Override - public NbpObservable get() { - return just1; - } - }, null); + just1.delay(() -> just1, null); } @Test(expected = NullPointerException.class) public void delayBothItemSupplierReturnsNull() { - just1.delay(new Supplier>() { - @Override - public NbpObservable get() { - return just1; - } - }, new Function>() { - @Override - public NbpObservable apply(Integer v) { - return null; - } - }).toBlocking().run(); + just1.delay(() -> just1, v -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) @@ -1134,37 +796,17 @@ public void distinctFunctionNull() { @Test(expected = NullPointerException.class) public void distinctSupplierNull() { - just1.distinct(new Function() { - @Override - public Object apply(Integer v) { - return v; - } - }, null); + just1.distinct(v -> v, null); } @Test(expected = NullPointerException.class) public void distinctSupplierReturnsNull() { - just1.distinct(new Function() { - @Override - public Object apply(Integer v) { - return v; - } - }, new Supplier>() { - @Override - public Collection get() { - return null; - } - }).toBlocking().run(); + just1.distinct(v -> v, () -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) public void distinctFunctionReturnsNull() { - just1.distinct(new Function() { - @Override - public Object apply(Integer v) { - return null; - } - }).toBlocking().run(); + just1.distinct(v -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) @@ -1174,12 +816,7 @@ public void distinctUntilChangedFunctionNull() { @Test(expected = NullPointerException.class) public void distinctUntilChangedFunctionReturnsNull() { - just1.distinctUntilChanged(new Function() { - @Override - public Object apply(Integer v) { - return null; - } - }).toBlocking().run(); + just1.distinctUntilChanged(v -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) @@ -1214,10 +851,7 @@ public void doOnLifecycleOnSubscribeNull() { @Test(expected = NullPointerException.class) public void doOnLifecycleOnCancelNull() { - just1.doOnLifecycle(new Consumer() { - @Override - public void accept(Disposable s) { } - }, null); + just1.doOnLifecycle(s -> { }, null); } @Test(expected = NullPointerException.class) @@ -1247,12 +881,7 @@ public void endWithIterableNull() { @Test(expected = NullPointerException.class) public void endWithIterableIteratorNull() { - just1.endWith(new Iterable() { - @Override - public Iterator iterator() { - return null; - } - }).toBlocking().run(); + just1.endWith(() -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) @@ -1302,167 +931,57 @@ public void flatMapNull() { @Test(expected = NullPointerException.class) public void flatMapFunctionReturnsNull() { - just1.flatMap(new Function>() { - @Override - public NbpObservable apply(Integer v) { - return null; - } - }).toBlocking().run(); + just1.flatMap(v -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) public void flatMapNotificationOnNextNull() { - just1.flatMap(null, new Function>() { - @Override - public NbpObservable apply(Throwable e) { - return just1; - } - }, new Supplier>() { - @Override - public NbpObservable get() { - return just1; - } - }); + just1.flatMap(null, e -> just1, () -> just1); } @Test(expected = NullPointerException.class) public void flatMapNotificationOnNextReturnsNull() { - just1.flatMap(new Function>() { - @Override - public NbpObservable apply(Integer v) { - return null; - } - }, new Function>() { - @Override - public NbpObservable apply(Throwable e) { - return just1; - } - }, new Supplier>() { - @Override - public NbpObservable get() { - return just1; - } - }).toBlocking().run(); + just1.flatMap(v -> null, e -> just1, () -> just1).toBlocking().run(); } @Test(expected = NullPointerException.class) public void flatMapNotificationOnErrorNull() { - just1.flatMap(new Function>() { - @Override - public NbpObservable apply(Integer v) { - return just1; - } - }, null, new Supplier>() { - @Override - public NbpObservable get() { - return just1; - } - }); + just1.flatMap(v -> just1, null, () -> just1); } @Test(expected = NullPointerException.class) public void flatMapNotificationOnErrorReturnsNull() { - NbpObservable.error(new TestException()).flatMap(new Function>() { - @Override - public NbpObservable apply(Object v) { - return just1; - } - }, new Function>() { - @Override - public NbpObservable apply(Throwable e) { - return null; - } - }, new Supplier>() { - @Override - public NbpObservable get() { - return just1; - } - }).toBlocking().run(); + NbpObservable.error(new TestException()).flatMap(v -> just1, e -> null, () -> just1).toBlocking().run(); } @Test(expected = NullPointerException.class) public void flatMapNotificationOnCompleteNull() { - just1.flatMap(new Function>() { - @Override - public NbpObservable apply(Integer v) { - return just1; - } - }, new Function>() { - @Override - public NbpObservable apply(Throwable e) { - return just1; - } - }, null); + just1.flatMap(v -> just1, e -> just1, null); } @Test(expected = NullPointerException.class) public void flatMapNotificationOnCompleteReturnsNull() { - just1.flatMap(new Function>() { - @Override - public NbpObservable apply(Integer v) { - return just1; - } - }, new Function>() { - @Override - public NbpObservable apply(Throwable e) { - return just1; - } - }, new Supplier>() { - @Override - public NbpObservable get() { - return null; - } - }).toBlocking().run(); + just1.flatMap(v -> just1, e -> just1, () -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) public void flatMapCombinerMapperNull() { - just1.flatMap(null, new BiFunction() { - @Override - public Object apply(Integer a, Object b) { - return 1; - } - }); + just1.flatMap(null, (a, b) -> 1); } @Test(expected = NullPointerException.class) public void flatMapCombinerMapperReturnsNull() { - just1.flatMap(new Function>() { - @Override - public NbpObservable apply(Integer v) { - return null; - } - }, new BiFunction() { - @Override - public Object apply(Integer a, Object b) { - return 1; - } - }).toBlocking().run(); + just1.flatMap(v -> null, (a, b) -> 1).toBlocking().run(); } @Test(expected = NullPointerException.class) public void flatMapCombinerCombinerNull() { - just1.flatMap(new Function>() { - @Override - public NbpObservable apply(Integer v) { - return just1; - } - }, null); + just1.flatMap(v -> just1, null); } @Test(expected = NullPointerException.class) public void flatMapCombinerCombinerReturnsNull() { - just1.flatMap(new Function>() { - @Override - public NbpObservable apply(Integer v) { - return just1; - } - }, new BiFunction() { - @Override - public Object apply(Integer a, Integer b) { - return null; - } - }).toBlocking().run(); + just1.flatMap(v -> just1, (a, b) -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) @@ -1472,62 +991,27 @@ public void flatMapIterableMapperNull() { @Test(expected = NullPointerException.class) public void flatMapIterableMapperReturnsNull() { - just1.flatMapIterable(new Function>() { - @Override - public Iterable apply(Integer v) { - return null; - } - }).toBlocking().run(); + just1.flatMapIterable(v -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) public void flatMapIterableMapperIteratorNull() { - just1.flatMapIterable(new Function>() { - @Override - public Iterable apply(Integer v) { - return new Iterable() { - @Override - public Iterator iterator() { - return null; - } - }; - } - }).toBlocking().run(); + just1.flatMapIterable(v -> () -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) public void flatMapIterableMapperIterableOneNull() { - just1.flatMapIterable(new Function>() { - @Override - public Iterable apply(Integer v) { - return Arrays.asList(1, null); - } - }).toBlocking().run(); + just1.flatMapIterable(v -> Arrays.asList(1, null)).toBlocking().run(); } @Test(expected = NullPointerException.class) public void flatMapIterableCombinerNull() { - just1.flatMapIterable(new Function>() { - @Override - public Iterable apply(Integer v) { - return Arrays.asList(1); - } - }, null); + just1.flatMapIterable(v -> Arrays.asList(1), null); } @Test(expected = NullPointerException.class) public void flatMapIterableCombinerReturnsNull() { - just1.flatMapIterable(new Function>() { - @Override - public Iterable apply(Integer v) { - return Arrays.asList(1); - } - }, new BiFunction() { - @Override - public Object apply(Integer a, Integer b) { - return null; - } - }).toBlocking().run(); + just1.flatMapIterable(v -> Arrays.asList(1), (a, b) -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) @@ -1542,25 +1026,12 @@ public void forEachWhileNull() { @Test(expected = NullPointerException.class) public void forEachWhileOnErrorNull() { - just1.forEachWhile(new Predicate() { - @Override - public boolean test(Integer v) { - return true; - } - }, null); + just1.forEachWhile(v -> true, null); } @Test(expected = NullPointerException.class) public void forEachWhileOnCompleteNull() { - just1.forEachWhile(new Predicate() { - @Override - public boolean test(Integer v) { - return true; - } - }, new Consumer() { - @Override - public void accept(Throwable e) { } - }, null); + just1.forEachWhile(v -> true, e -> { }, null); } @Test(expected = NullPointerException.class) @@ -1569,37 +1040,17 @@ public void groupByNull() { } public void groupByKeyNull() { - just1.groupBy(new Function() { - @Override - public Object apply(Integer v) { - return null; - } - }).toBlocking().run(); + just1.groupBy(v -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) public void groupByValueNull() { - just1.groupBy(new Function() { - @Override - public Object apply(Integer v) { - return v; - } - }, null); + just1.groupBy(v -> v, null); } @Test(expected = NullPointerException.class) public void groupByValueReturnsNull() { - just1.groupBy(new Function() { - @Override - public Object apply(Integer v) { - return v; - } - }, new Function() { - @Override - public Object apply(Integer v) { - return null; - } - }).toBlocking().run(); + just1.groupBy(v -> v, v -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) @@ -1614,12 +1065,7 @@ public void liftNull() { @Test(expected = NullPointerException.class) public void liftReturnsNull() { - just1.lift(new NbpOperator() { - @Override - public NbpSubscriber apply(NbpSubscriber s) { - return null; - } - }).toBlocking().run(); + just1.lift(s -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) @@ -1629,12 +1075,7 @@ public void mapNull() { @Test(expected = NullPointerException.class) public void mapReturnsNull() { - just1.map(new Function() { - @Override - public Object apply(Integer v) { - return null; - } - }).toBlocking().run(); + just1.map(v -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) @@ -1659,12 +1100,7 @@ public void onErrorResumeNextFunctionNull() { @Test(expected = NullPointerException.class) public void onErrorResumeNextFunctionReturnsNull() { - NbpObservable.error(new TestException()).onErrorResumeNext(new Function>() { - @Override - public NbpObservable apply(Throwable e) { - return null; - } - }).toBlocking().run(); + NbpObservable.error(new TestException()).onErrorResumeNext(e -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) @@ -1684,12 +1120,7 @@ public void onErrorReturnValueNull() { @Test(expected = NullPointerException.class) public void onErrorReturnFunctionReturnsNull() { - NbpObservable.error(new TestException()).onErrorReturn(new Function() { - @Override - public Object apply(Throwable e) { - return null; - } - }).toBlocking().run(); + NbpObservable.error(new TestException()).onErrorReturn(e -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) @@ -1704,12 +1135,7 @@ public void publishFunctionNull() { @Test(expected = NullPointerException.class) public void publishFunctionReturnsNull() { - just1.publish(new Function, NbpObservable>() { - @Override - public NbpObservable apply(NbpObservable v) { - return null; - } - }).toBlocking().run(); + just1.publish(v -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) @@ -1719,22 +1145,12 @@ public void reduceFunctionNull() { @Test(expected = NullPointerException.class) public void reduceFunctionReturnsNull() { - NbpObservable.just(1, 1).reduce(new BiFunction() { - @Override - public Integer apply(Integer a, Integer b) { - return null; - } - }).toBlocking().run(); + NbpObservable.just(1, 1).reduce((a, b) -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) public void reduceSeedNull() { - just1.reduce(null, new BiFunction() { - @Override - public Object apply(Object a, Integer b) { - return 1; - } - }); + just1.reduce(null, (a, b) -> 1); } @Test(expected = NullPointerException.class) @@ -1744,37 +1160,17 @@ public void reduceSeedFunctionNull() { @Test(expected = NullPointerException.class) public void reduceSeedFunctionReturnsNull() { - just1.reduce(1, new BiFunction() { - @Override - public Integer apply(Integer a, Integer b) { - return null; - } - }).toBlocking().run(); + just1.reduce(1, (a, b) -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) public void reduceWithSeedNull() { - just1.reduceWith(null, new BiFunction() { - @Override - public Object apply(Object a, Integer b) { - return 1; - } - }); + just1.reduceWith(null, (a, b) -> 1); } @Test(expected = NullPointerException.class) public void reduceWithSeedReturnsNull() { - just1.reduceWith(new Supplier() { - @Override - public Object get() { - return null; - } - }, new BiFunction() { - @Override - public Object apply(Object a, Integer b) { - return 1; - } - }).toBlocking().run(); + just1.reduceWith(() -> null, (a, b) -> 1).toBlocking().run(); } @Test(expected = NullPointerException.class) @@ -1789,12 +1185,7 @@ public void repeatWhenNull() { @Test(expected = NullPointerException.class) public void repeatWhenFunctionReturnsNull() { - just1.repeatWhen(new Function, NbpObservable>() { - @Override - public NbpObservable apply(NbpObservable v) { - return null; - } - }).toBlocking().run(); + just1.repeatWhen(v -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) @@ -1804,12 +1195,7 @@ public void replaySelectorNull() { @Test(expected = NullPointerException.class) public void replaySelectorReturnsNull() { - just1.replay(new Function, NbpObservable>() { - @Override - public NbpObservable apply(NbpObservable o) { - return null; - } - }).toBlocking().run(); + just1.replay(o -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) @@ -1819,12 +1205,7 @@ public void replayBoundedSelectorNull() { @Test(expected = NullPointerException.class) public void replayBoundedSelectorReturnsNull() { - just1.replay(new Function, NbpObservable>() { - @Override - public NbpObservable apply(NbpObservable v) { - return null; - } - }, 1, 1, TimeUnit.SECONDS).toBlocking().run(); + just1.replay(v -> null, 1, 1, TimeUnit.SECONDS).toBlocking().run(); } @Test(expected = NullPointerException.class) @@ -1834,22 +1215,12 @@ public void replaySchedulerNull() { @Test(expected = NullPointerException.class) public void replayBoundedUnitNull() { - just1.replay(new Function, NbpObservable>() { - @Override - public NbpObservable apply(NbpObservable v) { - return v; - } - }, 1, 1, null).toBlocking().run(); + just1.replay(v -> v, 1, 1, null).toBlocking().run(); } @Test(expected = NullPointerException.class) public void replayBoundedSchedulerNull() { - just1.replay(new Function, NbpObservable>() { - @Override - public NbpObservable apply(NbpObservable v) { - return v; - } - }, 1, 1, TimeUnit.SECONDS, null).toBlocking().run(); + just1.replay(v -> v, 1, 1, TimeUnit.SECONDS, null).toBlocking().run(); } @Test(expected = NullPointerException.class) @@ -1859,32 +1230,17 @@ public void replayTimeBoundedSelectorNull() { @Test(expected = NullPointerException.class) public void replayTimeBoundedSelectorReturnsNull() { - just1.replay(new Function, NbpObservable>() { - @Override - public NbpObservable apply(NbpObservable v) { - return null; - } - }, 1, TimeUnit.SECONDS, Schedulers.single()).toBlocking().run(); + just1.replay(v -> null, 1, TimeUnit.SECONDS, Schedulers.single()).toBlocking().run(); } @Test(expected = NullPointerException.class) public void replaySelectorTimeBoundedUnitNull() { - just1.replay(new Function, NbpObservable>() { - @Override - public NbpObservable apply(NbpObservable v) { - return v; - } - }, 1, null, Schedulers.single()); + just1.replay(v -> v, 1, null, Schedulers.single()); } @Test(expected = NullPointerException.class) public void replaySelectorTimeBoundedSchedulerNull() { - just1.replay(new Function, NbpObservable>() { - @Override - public NbpObservable apply(NbpObservable v) { - return v; - } - }, 1, TimeUnit.SECONDS, null); + just1.replay(v -> v, 1, TimeUnit.SECONDS, null); } @Test(expected = NullPointerException.class) @@ -1934,12 +1290,7 @@ public void retryWhenFunctionNull() { @Test(expected = NullPointerException.class) public void retryWhenFunctionReturnsNull() { - NbpObservable.error(new TestException()).retryWhen(new Function, NbpObservable>() { - @Override - public NbpObservable apply(NbpObservable f) { - return null; - } - }).toBlocking().run(); + NbpObservable.error(new TestException()).retryWhen(f -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) @@ -1974,22 +1325,12 @@ public void scanFunctionNull() { @Test(expected = NullPointerException.class) public void scanFunctionReturnsNull() { - NbpObservable.just(1, 1).scan(new BiFunction() { - @Override - public Integer apply(Integer a, Integer b) { - return null; - } - }).toBlocking().run(); + NbpObservable.just(1, 1).scan((a, b) -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) public void scanSeedNull() { - just1.scan(null, new BiFunction() { - @Override - public Object apply(Object a, Integer b) { - return 1; - } - }); + just1.scan(null, (a, b) -> 1); } @Test(expected = NullPointerException.class) @@ -1999,62 +1340,27 @@ public void scanSeedFunctionNull() { @Test(expected = NullPointerException.class) public void scanSeedFunctionReturnsNull() { - just1.scan(1, new BiFunction() { - @Override - public Integer apply(Integer a, Integer b) { - return null; - } - }).toBlocking().run(); + just1.scan(1, (a, b) -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) public void scanSeedSupplierNull() { - just1.scanWith(null, new BiFunction() { - @Override - public Object apply(Object a, Integer b) { - return 1; - } - }); + just1.scanWith(null, (a, b) -> 1); } @Test(expected = NullPointerException.class) public void scanSeedSupplierReturnsNull() { - just1.scanWith(new Supplier() { - @Override - public Object get() { - return null; - } - }, new BiFunction() { - @Override - public Object apply(Object a, Integer b) { - return 1; - } - }).toBlocking().run(); + just1.scanWith(() -> null, (a, b) -> 1).toBlocking().run(); } @Test(expected = NullPointerException.class) public void scanSeedSupplierFunctionNull() { - just1.scanWith(new Supplier() { - @Override - public Object get() { - return 1; - } - }, null); + just1.scanWith(() -> 1, null); } @Test(expected = NullPointerException.class) public void scanSeedSupplierFunctionReturnsNull() { - just1.scanWith(new Supplier() { - @Override - public Object get() { - return 1; - } - }, new BiFunction() { - @Override - public Object apply(Object a, Integer b) { - return null; - } - }).toBlocking().run(); + just1.scanWith(() -> 1, (a, b) -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) @@ -2099,12 +1405,7 @@ public void startWithIterableNull() { @Test(expected = NullPointerException.class) public void startWithIterableIteratorNull() { - just1.startWith(new Iterable() { - @Override - public Iterator iterator() { - return null; - } - }).toBlocking().run(); + just1.startWith(() -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) @@ -2139,32 +1440,17 @@ public void subscribeOnNextNull() { @Test(expected = NullPointerException.class) public void subscribeOnErrorNull() { - just1.subscribe(new Consumer() { - @Override - public void accept(Integer e) { } - }, null); + just1.subscribe(e -> { }, null); } @Test(expected = NullPointerException.class) public void subscribeOnCompleteNull() { - just1.subscribe(new Consumer() { - @Override - public void accept(Integer e) { } - }, new Consumer() { - @Override - public void accept(Throwable e) { } - }, null); + just1.subscribe(e -> { }, e -> { }, null); } @Test(expected = NullPointerException.class) public void subscribeOnSubscribeNull() { - just1.subscribe(new Consumer() { - @Override - public void accept(Integer e) { } - }, new Consumer() { - @Override - public void accept(Throwable e) { } - }, Functions.emptyRunnable(), null); + just1.subscribe(e -> { }, e -> { }, Functions.emptyRunnable(), null); } @Test(expected = NullPointerException.class) @@ -2189,12 +1475,7 @@ public void switchMapNull() { @Test(expected = NullPointerException.class) public void switchMapFunctionReturnsNull() { - just1.switchMap(new Function>() { - @Override - public NbpObservable apply(Integer v) { - return null; - } - }).toBlocking().run(); + just1.switchMap(v -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) @@ -2314,22 +1595,12 @@ public void timeoutSelectorNull() { @Test(expected = NullPointerException.class) public void timeoutSelectorReturnsNull() { - just1.timeout(new Function>() { - @Override - public NbpObservable apply(Integer v) { - return null; - } - }).toBlocking().run(); + just1.timeout(v -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) public void timeoutSelectorOtherNull() { - just1.timeout(new Function>() { - @Override - public NbpObservable apply(Integer v) { - return just1; - } - }, null); + just1.timeout(v -> just1, null); } @Test(expected = NullPointerException.class) @@ -2349,52 +1620,22 @@ public void timeouSchedulerNull() { @Test(expected = NullPointerException.class) public void timeoutFirstNull() { - just1.timeout((Supplier>)null, new Function>() { - @Override - public NbpObservable apply(Integer v) { - return just1; - } - }); + just1.timeout(null, v -> just1); } @Test(expected = NullPointerException.class) public void timeoutFirstReturnsNull() { - just1.timeout(new Supplier>() { - @Override - public NbpObservable get() { - return null; - } - }, new Function>() { - @Override - public NbpObservable apply(Integer v) { - return just1; - } - }).toBlocking().run(); + just1.timeout(() -> null, v -> just1).toBlocking().run(); } @Test(expected = NullPointerException.class) public void timeoutFirstItemNull() { - just1.timeout(new Supplier>() { - @Override - public NbpObservable get() { - return just1; - } - }, null); + just1.timeout(() -> just1, null); } @Test(expected = NullPointerException.class) public void timeoutFirstItemReturnsNull() { - NbpObservable.just(1, 1).timeout(new Supplier>() { - @Override - public NbpObservable get() { - return NbpObservable.never(); - } - }, new Function>() { - @Override - public NbpObservable apply(Integer v) { - return null; - } - }).toBlocking().run(); + NbpObservable.just(1, 1).timeout(NbpObservable::never, v -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) @@ -2419,12 +1660,7 @@ public void toListNull() { @Test(expected = NullPointerException.class) public void toListSupplierReturnsNull() { - just1.toList(new Supplier>() { - @Override - public Collection get() { - return null; - } - }).toBlocking().run(); + just1.toList(() -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) @@ -2439,62 +1675,22 @@ public void toMapKeyNullAllowed() { @Test(expected = NullPointerException.class) public void toMapValueNull() { - just1.toMap(new Function() { - @Override - public Object apply(Integer v) { - return v; - } - }, null); + just1.toMap(v -> v, null); } @Test public void toMapValueSelectorReturnsNull() { - just1.toMap(new Function() { - @Override - public Object apply(Integer v) { - return v; - } - }, new Function() { - @Override - public Object apply(Integer v) { - return null; - } - }).toBlocking().run(); + just1.toMap(v -> v, v -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) public void toMapMapSupplierNull() { - just1.toMap(new Function() { - @Override - public Object apply(Integer v) { - return v; - } - }, new Function() { - @Override - public Object apply(Integer v) { - return v; - } - }, null); + just1.toMap(v -> v, v -> v, null); } @Test(expected = NullPointerException.class) public void toMapMapSupplierReturnsNull() { - just1.toMap(new Function() { - @Override - public Object apply(Integer v) { - return v; - } - }, new Function() { - @Override - public Object apply(Integer v) { - return v; - } - }, new Supplier>() { - @Override - public Map get() { - return null; - } - }).toBlocking().run(); + just1.toMap(v -> v, v -> v, () -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) @@ -2504,107 +1700,32 @@ public void toMultimapKeyNull() { @Test(expected = NullPointerException.class) public void toMultimapValueNull() { - just1.toMultimap(new Function() { - @Override - public Object apply(Integer v) { - return v; - } - }, null); + just1.toMultimap(v -> v, null); } @Test public void toMultiMapValueSelectorReturnsNullAllowed() { - just1.toMap(new Function() { - @Override - public Object apply(Integer v) { - return v; - } - }, new Function() { - @Override - public Object apply(Integer v) { - return null; - } - }).toBlocking().run(); + just1.toMap(v -> v, v -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) public void toMultimapMapMapSupplierNull() { - just1.toMultimap(new Function() { - @Override - public Object apply(Integer v) { - return v; - } - }, new Function() { - @Override - public Object apply(Integer v) { - return v; - } - }, null); + just1.toMultimap(v -> v, v -> v, null); } @Test(expected = NullPointerException.class) public void toMultimapMapSupplierReturnsNull() { - just1.toMultimap(new Function() { - @Override - public Object apply(Integer v) { - return v; - } - }, new Function() { - @Override - public Object apply(Integer v) { - return v; - } - }, new Supplier>>() { - @Override - public Map> get() { - return null; - } - }).toBlocking().run(); + just1.toMultimap(v -> v, v -> v, () -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) public void toMultimapMapMapCollectionSupplierNull() { - just1.toMultimap(new Function() { - @Override - public Integer apply(Integer v) { - return v; - } - }, new Function() { - @Override - public Integer apply(Integer v) { - return v; - } - }, new Supplier>>() { - @Override - public Map> get() { - return new HashMap>(); - } - }, null); + just1.toMultimap(v -> v, v -> v, () -> new HashMap<>(), null); } @Test(expected = NullPointerException.class) public void toMultimapMapCollectionSupplierReturnsNull() { - just1.toMultimap(new Function() { - @Override - public Integer apply(Integer v) { - return v; - } - }, new Function() { - @Override - public Integer apply(Integer v) { - return v; - } - }, new Supplier>>() { - @Override - public Map> get() { - return new HashMap>(); - } - }, new Function>() { - @Override - public Collection apply(Integer v) { - return null; - } - }).toBlocking().run(); + just1.toMultimap(v -> v, v -> v, () -> new HashMap<>(), v -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) @@ -2644,12 +1765,7 @@ public void windowBoundaryNull() { @Test(expected = NullPointerException.class) public void windowOpenCloseOpenNull() { - just1.window(null, new Function>() { - @Override - public NbpObservable apply(Object v) { - return just1; - } - }); + just1.window(null, v -> just1); } @Test(expected = NullPointerException.class) @@ -2659,12 +1775,7 @@ public void windowOpenCloseCloseNull() { @Test(expected = NullPointerException.class) public void windowOpenCloseCloseReturnsNull() { - NbpObservable.never().window(just1, new Function>() { - @Override - public NbpObservable apply(Integer v) { - return null; - } - }).toBlocking().run(); + NbpObservable.never().window(just1, v -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) @@ -2674,22 +1785,12 @@ public void windowBoundarySupplierNull() { @Test(expected = NullPointerException.class) public void windowBoundarySupplierReturnsNull() { - just1.window(new Supplier>() { - @Override - public NbpObservable get() { - return null; - } - }).toBlocking().run(); + just1.window(() -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) public void withLatestFromOtherNull() { - just1.withLatestFrom(null, new BiFunction() { - @Override - public Object apply(Integer a, Object b) { - return 1; - } - }); + just1.withLatestFrom(null, (a, b) -> 1); } @Test(expected = NullPointerException.class) @@ -2699,22 +1800,12 @@ public void withLatestFromCombinerNull() { @Test(expected = NullPointerException.class) public void withLatestFromCombinerReturnsNull() { - just1.withLatestFrom(just1, new BiFunction() { - @Override - public Object apply(Integer a, Integer b) { - return null; - } - }).toBlocking().run(); + just1.withLatestFrom(just1, (a, b) -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) public void zipWithIterableNull() { - just1.zipWith((Iterable)null, new BiFunction() { - @Override - public Object apply(Integer a, Integer b) { - return 1; - } - }); + just1.zipWith((Iterable)null, (a, b) -> 1); } @Test(expected = NullPointerException.class) @@ -2724,47 +1815,22 @@ public void zipWithIterableCombinerNull() { @Test(expected = NullPointerException.class) public void zipWithIterableCombinerReturnsNull() { - just1.zipWith(Arrays.asList(1), new BiFunction() { - @Override - public Object apply(Integer a, Integer b) { - return null; - } - }).toBlocking().run(); + just1.zipWith(Arrays.asList(1), (a, b) -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) public void zipWithIterableIteratorNull() { - just1.zipWith(new Iterable() { - @Override - public Iterator iterator() { - return null; - } - }, new BiFunction() { - @Override - public Object apply(Integer a, Object b) { - return 1; - } - }).toBlocking().run(); + just1.zipWith(() -> null, (a, b) -> 1).toBlocking().run(); } @Test(expected = NullPointerException.class) public void zipWithIterableOneIsNull() { - NbpObservable.just(1, 2).zipWith(Arrays.asList(1, null), new BiFunction() { - @Override - public Object apply(Integer a, Integer b) { - return 1; - } - }).toBlocking().run(); + NbpObservable.just(1, 2).zipWith(Arrays.asList(1, null), (a, b) -> 1).toBlocking().run(); } @Test(expected = NullPointerException.class) public void zipWithNbpObservableNull() { - just1.zipWith((NbpObservable)null, new BiFunction() { - @Override - public Object apply(Integer a, Integer b) { - return 1; - } - }); + just1.zipWith((NbpObservable)null, (a, b) -> 1); } @@ -2775,12 +1841,7 @@ public void zipWithCombinerNull() { @Test(expected = NullPointerException.class) public void zipWithCombinerReturnsNull() { - just1.zipWith(just1, new BiFunction() { - @Override - public Object apply(Integer a, Integer b) { - return null; - } - }).toBlocking().run(); + just1.zipWith(just1, (a, b) -> null).toBlocking().run(); } } \ No newline at end of file diff --git a/src/test/java/io/reactivex/NbpObservableTest.java b/rxjava/src/test/java/io/reactivex/NbpObservableTest.java similarity index 76% rename from src/test/java/io/reactivex/NbpObservableTest.java rename to rxjava/src/test/java/io/reactivex/NbpObservableTest.java index f0cad9c657..9a6a650d00 100644 --- a/src/test/java/io/reactivex/NbpObservableTest.java +++ b/rxjava/src/test/java/io/reactivex/NbpObservableTest.java @@ -23,12 +23,7 @@ public class NbpObservableTest { @Test public void testFlatMap() { - List list = NbpObservable.range(1, 5).flatMap(new Function>() { - @Override - public NbpObservable apply(Integer v) { - return NbpObservable.range(v, 2); - } - }).getList(); + List list = NbpObservable.range(1, 5).flatMap(v -> NbpObservable.range(v, 2)).getList(); Assert.assertEquals(Arrays.asList(1, 2, 2, 3, 3, 4, 4, 5, 5, 6), list); } diff --git a/src/test/java/io/reactivex/NotificationTest.java b/rxjava/src/test/java/io/reactivex/NotificationTest.java similarity index 100% rename from src/test/java/io/reactivex/NotificationTest.java rename to rxjava/src/test/java/io/reactivex/NotificationTest.java diff --git a/src/test/java/io/reactivex/ObservableConversionTest.java b/rxjava/src/test/java/io/reactivex/ObservableConversionTest.java similarity index 59% rename from src/test/java/io/reactivex/ObservableConversionTest.java rename to rxjava/src/test/java/io/reactivex/ObservableConversionTest.java index dac7b15419..efa0c59db0 100644 --- a/src/test/java/io/reactivex/ObservableConversionTest.java +++ b/rxjava/src/test/java/io/reactivex/ObservableConversionTest.java @@ -42,7 +42,7 @@ public static class CylonDetectorObservable { protected Publisher onSubscribe; public static CylonDetectorObservable create(Publisher onSubscribe) { - return new CylonDetectorObservable(onSubscribe); + return new CylonDetectorObservable<>(onSubscribe); } protected CylonDetectorObservable(Publisher onSubscribe) { @@ -54,7 +54,7 @@ public void subscribe(Subscriber subscriber) { } public CylonDetectorObservable lift(Operator operator) { - return x(new RobotConversionFunc(operator)); + return x(new RobotConversionFunc<>(operator)); } public O x(Function, O> operator) { @@ -66,27 +66,25 @@ public CylonDetectorObservable compose(Function beep(Predicate predicate) { - return lift(new OperatorFilter(predicate)); + return lift(new OperatorFilter<>(predicate)); } public final CylonDetectorObservable boop(Function func) { - return lift(new OperatorMap(func)); + return lift(new OperatorMap<>(func)); } public CylonDetectorObservable DESTROY() { - return boop(new Function() { - @Override - public String apply(T t) { - Object cylon = ((Jail) t).cylon; - throwOutTheAirlock(cylon); - if (t instanceof Jail) { - String name = cylon.toString(); - return "Cylon '" + name + "' has been destroyed"; - } - else { - return "Cylon 'anonymous' has been destroyed"; - } - }}); + return boop(t -> { + Object cylon = ((Jail) t).cylon; + throwOutTheAirlock(cylon); + if (t instanceof Jail) { + String name = cylon.toString(); + return "Cylon '" + name + "' has been destroyed"; + } + else { + return "Cylon 'anonymous' has been destroyed"; + } + }); } private static void throwOutTheAirlock(Object cylon) { @@ -137,7 +135,7 @@ public Observable apply(final Publisher onSubscribe) { @Test public void testConversionBetweenObservableClasses() { - final TestSubscriber subscriber = new TestSubscriber(new Observer() { + final TestSubscriber subscriber = new TestSubscriber<>(new Observer() { @Override public void onComplete() { @@ -159,33 +157,13 @@ public void onNext(String t) { List crewOfBattlestarGalactica = Arrays.asList(new Object[] {"William Adama", "Laura Roslin", "Lee Adama", new Cylon()}); Observable.fromIterable(crewOfBattlestarGalactica) - .doOnNext(new Consumer() { - @Override - public void accept(Object pv) { - System.out.println(pv); - } - }) - .to(new ConvertToCylonDetector()) - .beep(new Predicate() { - @Override - public boolean test(Object t) { - return t instanceof Cylon; - } - }) - .boop(new Function() { - @Override - public Object apply(Object cylon) { - return new Jail(cylon); - } - }) + .doOnNext(System.out::println) + .to(new ConvertToCylonDetector<>()) + .beep(t -> t instanceof Cylon) + .boop(Jail::new) .DESTROY() - .x(new ConvertToObservable()) - .reduce("Cylon Detector finished. Report:\n", new BiFunction() { - @Override - public String apply(String a, String n) { - return a + n + "\n"; - } - }) + .x(new ConvertToObservable<>()) + .reduce("Cylon Detector finished. Report:\n", (a, n) -> a + n + "\n") .subscribe(subscriber); subscriber.assertNoErrors(); @@ -194,48 +172,37 @@ public String apply(String a, String n) { @Test public void testConvertToConcurrentQueue() { - final AtomicReference thrown = new AtomicReference(null); + final AtomicReference thrown = new AtomicReference<>(null); final AtomicBoolean isFinished = new AtomicBoolean(false); ConcurrentLinkedQueue queue = Observable.range(0,5) - .flatMap(new Function>() { - @Override - public Publisher apply(final Integer i) { - return Observable.range(0, 5) - .observeOn(Schedulers.io()) - .map(new Function() { - @Override - public Integer apply(Integer k) { - try { - Thread.sleep(System.currentTimeMillis() % 100); - } catch (InterruptedException e) { - e.printStackTrace(); - } - return i + k; - } - }); - } - }) - .to(new Function, ConcurrentLinkedQueue>() { - @Override - public ConcurrentLinkedQueue apply(Observable onSubscribe) { - final ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(); - onSubscribe.subscribe(new Observer(){ - @Override - public void onComplete() { - isFinished.set(true); - } - - @Override - public void onError(Throwable e) { - thrown.set(e); - } - - @Override - public void onNext(Integer t) { - q.add(t); - }}); - return q; - } + .flatMap(i -> Observable.range(0, 5) + .observeOn(Schedulers.io()) + .map(k -> { + try { + Thread.sleep(System.currentTimeMillis() % 100); + } catch (InterruptedException e) { + e.printStackTrace(); + } + return i + k; + })) + .to(onSubscribe -> { + final ConcurrentLinkedQueue q = new ConcurrentLinkedQueue<>(); + onSubscribe.subscribe(new Observer(){ + @Override + public void onComplete() { + isFinished.set(true); + } + + @Override + public void onError(Throwable e) { + thrown.set(e); + } + + @Override + public void onNext(Integer t) { + q.add(t); + }}); + return q; }); int x = 0; diff --git a/src/test/java/io/reactivex/ObservableDoOnTest.java b/rxjava/src/test/java/io/reactivex/ObservableDoOnTest.java similarity index 67% rename from src/test/java/io/reactivex/ObservableDoOnTest.java rename to rxjava/src/test/java/io/reactivex/ObservableDoOnTest.java index 1ad2fafd90..b6ff7129b9 100644 --- a/src/test/java/io/reactivex/ObservableDoOnTest.java +++ b/rxjava/src/test/java/io/reactivex/ObservableDoOnTest.java @@ -26,13 +26,8 @@ public class ObservableDoOnTest { @Test public void testDoOnEach() { - final AtomicReference r = new AtomicReference(); - String output = Observable.just("one").doOnNext(new Consumer() { - @Override - public void accept(String v) { - r.set(v); - } - }).toBlocking().single(); + final AtomicReference r = new AtomicReference<>(); + String output = Observable.just("one").doOnNext(r::set).toBlocking().single(); assertEquals("one", output); assertEquals("one", r.get()); @@ -40,16 +35,11 @@ public void accept(String v) { @Test public void testDoOnError() { - final AtomicReference r = new AtomicReference(); + final AtomicReference r = new AtomicReference<>(); Throwable t = null; try { Observable. error(new RuntimeException("an error")) - .doOnError(new Consumer() { - @Override - public void accept(Throwable v) { - r.set(v); - } - }).toBlocking().single(); + .doOnError(r::set).toBlocking().single(); fail("expected exception, not a return value"); } catch (Throwable e) { t = e; @@ -62,12 +52,7 @@ public void accept(Throwable v) { @Test public void testDoOnCompleted() { final AtomicBoolean r = new AtomicBoolean(); - String output = Observable.just("one").doOnComplete(new Runnable() { - @Override - public void run() { - r.set(true); - } - }).toBlocking().single(); + String output = Observable.just("one").doOnComplete(() -> r.set(true)).toBlocking().single(); assertEquals("one", output); assertTrue(r.get()); diff --git a/src/test/java/io/reactivex/ObservableNullTests.java b/rxjava/src/test/java/io/reactivex/ObservableNullTests.java similarity index 98% rename from src/test/java/io/reactivex/ObservableNullTests.java rename to rxjava/src/test/java/io/reactivex/ObservableNullTests.java index 35274c9452..1091116fb0 100644 --- a/src/test/java/io/reactivex/ObservableNullTests.java +++ b/rxjava/src/test/java/io/reactivex/ObservableNullTests.java @@ -272,10 +272,10 @@ public void fromFutureNull() { @Test public void fromFutureReturnsNull() { - FutureTask f = new FutureTask(Functions.emptyRunnable(), null); + FutureTask f = new FutureTask<>(Functions.emptyRunnable(), null); f.run(); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.fromFuture(f).subscribe(ts); ts.assertNoValues(); ts.assertNotComplete(); @@ -289,24 +289,24 @@ public void fromFutureTimedFutureNull() { @Test(expected = NullPointerException.class) public void fromFutureTimedUnitNull() { - Observable.fromFuture(new FutureTask(Functions.emptyRunnable(), null), 1, null); + Observable.fromFuture(new FutureTask<>(Functions.emptyRunnable(), null), 1, null); } @Test(expected = NullPointerException.class) public void fromFutureTimedSchedulerNull() { - Observable.fromFuture(new FutureTask(Functions.emptyRunnable(), null), 1, TimeUnit.SECONDS, null); + Observable.fromFuture(new FutureTask<>(Functions.emptyRunnable(), null), 1, TimeUnit.SECONDS, null); } @Test(expected = NullPointerException.class) public void fromFutureTimedReturnsNull() { - FutureTask f = new FutureTask(Functions.emptyRunnable(), null); + FutureTask f = new FutureTask<>(Functions.emptyRunnable(), null); f.run(); Observable.fromFuture(f, 1, TimeUnit.SECONDS).toBlocking().lastOption(); } @Test(expected = NullPointerException.class) public void fromFutureSchedulerNull() { - Observable.fromFuture(new FutureTask(Functions.emptyRunnable(), null), null); + Observable.fromFuture(new FutureTask<>(Functions.emptyRunnable(), null), null); } @Test(expected = NullPointerException.class) @@ -710,7 +710,7 @@ public void zipIterable2Null() { public Object apply(Object[] a) { return 1; } - }, true, 128, (Iterable>)null); + }, true, 128, null); } @Test(expected = NullPointerException.class) @@ -896,7 +896,7 @@ public void castNull() { @Test(expected = NullPointerException.class) public void collectInitialSupplierNull() { - just1.collect((Supplier)null, new BiConsumer() { + just1.collect(null, new BiConsumer() { @Override public void accept(Integer a, Integer b) { } }); @@ -2365,7 +2365,7 @@ public void timeouSchedulerNull() { @Test(expected = NullPointerException.class) public void timeoutFirstNull() { - just1.timeout((Supplier>)null, new Function>() { + just1.timeout(null, new Function>() { @Override public Publisher apply(Integer v) { return just1; @@ -2593,7 +2593,7 @@ public Integer apply(Integer v) { }, new Supplier>>() { @Override public Map> get() { - return new HashMap>(); + return new HashMap<>(); } }, null); } @@ -2613,7 +2613,7 @@ public Integer apply(Integer v) { }, new Supplier>>() { @Override public Map> get() { - return new HashMap>(); + return new HashMap<>(); } }, new Function>() { @Override diff --git a/src/test/java/io/reactivex/ObservableTests.java b/rxjava/src/test/java/io/reactivex/ObservableTests.java similarity index 79% rename from src/test/java/io/reactivex/ObservableTests.java rename to rxjava/src/test/java/io/reactivex/ObservableTests.java index abbab199a3..7d72da1cc2 100644 --- a/src/test/java/io/reactivex/ObservableTests.java +++ b/rxjava/src/test/java/io/reactivex/ObservableTests.java @@ -38,12 +38,7 @@ public class ObservableTests { Subscriber w; - private static final Predicate IS_EVEN = new Predicate() { - @Override - public boolean test(Integer v) { - return v % 2 == 0; - } - }; + private static final Predicate IS_EVEN = v -> v % 2 == 0; @Before public void before() { @@ -60,7 +55,7 @@ public void fromArray() { @Test public void fromIterable() { - ArrayList items = new ArrayList(); + ArrayList items = new ArrayList<>(); items.add("one"); items.add("two"); items.add("three"); @@ -129,12 +124,7 @@ public void testCountZeroItems() { @Test public void testCountError() { - Observable o = Observable.error(new Supplier() { - @Override - public Throwable get() { - return new RuntimeException(); - } - }); + Observable o = Observable.error(RuntimeException::new); o.count().subscribe(w); verify(w, never()).onNext(anyInt()); @@ -200,12 +190,7 @@ public void testFirstWithPredicateOfNoneMatchingThePredicate() { @Test public void testReduce() { Observable observable = Observable.just(1, 2, 3, 4); - observable.reduce(new BiFunction() { - @Override - public Integer apply(Integer t1, Integer t2) { - return t1 + t2; - } - }) + observable.reduce((t1, t2) -> t1 + t2) .subscribe(w); // we should be called only once verify(w, times(1)).onNext(anyInt()); @@ -218,17 +203,9 @@ public Integer apply(Integer t1, Integer t2) { @Test(expected = NoSuchElementException.class) public void testReduceWithEmptyObservable() { Observable observable = Observable.range(1, 0); - observable.reduce(new BiFunction() { - @Override - public Integer apply(Integer t1, Integer t2) { - return t1 + t2; - } - }) - .toBlocking().forEach(new Consumer() { - @Override - public void accept(Integer t1) { - // do nothing ... we expect an exception instead - } + observable.reduce((t1, t2) -> t1 + t2) + .toBlocking().forEach((Consumer) t1 -> { + // do nothing ... we expect an exception instead }); fail("Expected an exception to be thrown"); @@ -242,12 +219,7 @@ public void accept(Integer t1) { @Test public void testReduceWithEmptyObservableAndSeed() { Observable observable = Observable.range(1, 0); - int value = observable.reduce(1, new BiFunction() { - @Override - public Integer apply(Integer t1, Integer t2) { - return t1 + t2; - } - }) + int value = observable.reduce(1, (t1, t2) -> t1 + t2) .toBlocking().last(); assertEquals(1, value); @@ -256,12 +228,7 @@ public Integer apply(Integer t1, Integer t2) { @Test public void testReduceWithInitialValue() { Observable observable = Observable.just(1, 2, 3, 4); - observable.reduce(50, new BiFunction() { - @Override - public Integer apply(Integer t1, Integer t2) { - return t1 + t2; - } - }) + observable.reduce(50, (t1, t2) -> t1 + t2) .subscribe(w); // we should be called only once verify(w, times(1)).onNext(anyInt()); @@ -274,10 +241,7 @@ public void testOnSubscribeFails() { Subscriber observer = TestHelper.mockSubscriber(); final RuntimeException re = new RuntimeException("bad impl"); - Observable o = Observable.create(new Publisher() { - @Override - public void subscribe(Subscriber s) { throw re; } - }); + Observable o = Observable.create(s -> { throw re; }); o.subscribe(observer); verify(observer, times(0)).onNext(anyString()); @@ -311,7 +275,7 @@ public void testMaterializeDematerializeChaining() { public void testCustomObservableWithErrorInObserverAsynchronous() throws InterruptedException { final CountDownLatch latch = new CountDownLatch(1); final AtomicInteger count = new AtomicInteger(); - final AtomicReference error = new AtomicReference(); + final AtomicReference error = new AtomicReference<>(); // FIXME custom built??? Observable.just("1", "2", "three", "4") @@ -359,7 +323,7 @@ public void onNext(String v) { @Test public void testCustomObservableWithErrorInObserverSynchronous() { final AtomicInteger count = new AtomicInteger(); - final AtomicReference error = new AtomicReference(); + final AtomicReference error = new AtomicReference<>(); // FIXME custom built??? Observable.just("1", "2", "three", "4") @@ -402,14 +366,9 @@ public void onNext(String v) { @Test public void testCustomObservableWithErrorInObservableSynchronous() { final AtomicInteger count = new AtomicInteger(); - final AtomicReference error = new AtomicReference(); + final AtomicReference error = new AtomicReference<>(); // FIXME custom built??? - Observable.just("1", "2").concatWith(Observable.error(new Supplier() { - @Override - public Throwable get() { - return new NumberFormatException(); - } - })) + Observable.just("1", "2").concatWith(Observable.error(NumberFormatException::new)) .subscribe(new Observer() { @Override @@ -441,30 +400,21 @@ public void onNext(String v) { @Test public void testPublishLast() throws InterruptedException { final AtomicInteger count = new AtomicInteger(); - ConnectableObservable connectable = Observable.create(new Publisher() { - @Override - public void subscribe(final Subscriber observer) { - observer.onSubscribe(EmptySubscription.INSTANCE); - count.incrementAndGet(); - new Thread(new Runnable() { - @Override - public void run() { - observer.onNext("first"); - observer.onNext("last"); - observer.onComplete(); - } - }).start(); - } + ConnectableObservable connectable = Observable.create(observer -> { + observer.onSubscribe(EmptySubscription.INSTANCE); + count.incrementAndGet(); + new Thread(() -> { + observer.onNext("first"); + observer.onNext("last"); + observer.onComplete(); + }).start(); }).takeLast(1).publish(); // subscribe once final CountDownLatch latch = new CountDownLatch(1); - connectable.subscribe(new Consumer() { - @Override - public void accept(String value) { - assertEquals("last", value); - latch.countDown(); - } + connectable.subscribe(value -> { + assertEquals("last", value); + latch.countDown(); }); // subscribe twice @@ -479,20 +429,13 @@ public void accept(String value) { @Test public void testReplay() throws InterruptedException { final AtomicInteger counter = new AtomicInteger(); - ConnectableObservable o = Observable.create(new Publisher() { - @Override - public void subscribe(final Subscriber observer) { - observer.onSubscribe(EmptySubscription.INSTANCE); - new Thread(new Runnable() { - - @Override - public void run() { - counter.incrementAndGet(); - observer.onNext("one"); - observer.onComplete(); - } - }).start(); - } + ConnectableObservable o = Observable.create(observer -> { + observer.onSubscribe(EmptySubscription.INSTANCE); + new Thread(() -> { + counter.incrementAndGet(); + observer.onNext("one"); + observer.onComplete(); + }).start(); }).replay(); // we connect immediately and it will emit the value @@ -503,21 +446,15 @@ public void run() { final CountDownLatch latch = new CountDownLatch(2); // subscribe once - o.subscribe(new Consumer() { - @Override - public void accept(String v) { - assertEquals("one", v); - latch.countDown(); - } + o.subscribe(v -> { + assertEquals("one", v); + latch.countDown(); }); // subscribe again - o.subscribe(new Consumer() { - @Override - public void accept(String v) { - assertEquals("one", v); - latch.countDown(); - } + o.subscribe(v -> { + assertEquals("one", v); + latch.countDown(); }); if (!latch.await(1000, TimeUnit.MILLISECONDS)) { @@ -532,40 +469,31 @@ public void accept(String v) { @Test public void testCache() throws InterruptedException { final AtomicInteger counter = new AtomicInteger(); - Observable o = Observable.create(new Publisher() { - @Override - public void subscribe(final Subscriber observer) { - observer.onSubscribe(EmptySubscription.INSTANCE); - new Thread(new Runnable() { - @Override - public void run() { - counter.incrementAndGet(); - observer.onNext("one"); - observer.onComplete(); - } - }).start(); - } + Observable o = Observable.create(observer -> { + observer.onSubscribe(EmptySubscription.INSTANCE); + new Thread(new Runnable() { + @Override + public void run() { + counter.incrementAndGet(); + observer.onNext("one"); + observer.onComplete(); + } + }).start(); }).cache(); // we then expect the following 2 subscriptions to get that same value final CountDownLatch latch = new CountDownLatch(2); // subscribe once - o.subscribe(new Consumer() { - @Override - public void accept(String v) { - assertEquals("one", v); - latch.countDown(); - } + o.subscribe(v -> { + assertEquals("one", v); + latch.countDown(); }); // subscribe again - o.subscribe(new Consumer() { - @Override - public void accept(String v) { - assertEquals("one", v); - latch.countDown(); - } + o.subscribe(v -> { + assertEquals("one", v); + latch.countDown(); }); if (!latch.await(1000, TimeUnit.MILLISECONDS)) { @@ -577,40 +505,28 @@ public void accept(String v) { @Test public void testCacheWithCapacity() throws InterruptedException { final AtomicInteger counter = new AtomicInteger(); - Observable o = Observable.create(new Publisher() { - @Override - public void subscribe(final Subscriber observer) { - observer.onSubscribe(EmptySubscription.INSTANCE); - new Thread(new Runnable() { - @Override - public void run() { - counter.incrementAndGet(); - observer.onNext("one"); - observer.onComplete(); - } - }).start(); - } + Observable o = Observable.create(observer -> { + observer.onSubscribe(EmptySubscription.INSTANCE); + new Thread(() -> { + counter.incrementAndGet(); + observer.onNext("one"); + observer.onComplete(); + }).start(); }).cache(1); // we then expect the following 2 subscriptions to get that same value final CountDownLatch latch = new CountDownLatch(2); // subscribe once - o.subscribe(new Consumer() { - @Override - public void accept(String v) { - assertEquals("one", v); - latch.countDown(); - } + o.subscribe(v -> { + assertEquals("one", v); + latch.countDown(); }); // subscribe again - o.subscribe(new Consumer() { - @Override - public void accept(String v) { - assertEquals("one", v); - latch.countDown(); - } + o.subscribe(v -> { + assertEquals("one", v); + latch.countDown(); }); if (!latch.await(1000, TimeUnit.MILLISECONDS)) { @@ -655,24 +571,21 @@ public void testErrorThrownWithoutErrorHandlerSynchronous() { @Ignore("Subscribers can't throw") public void testErrorThrownWithoutErrorHandlerAsynchronous() throws InterruptedException { final CountDownLatch latch = new CountDownLatch(1); - final AtomicReference exception = new AtomicReference(); - Observable.create(new Publisher() { - @Override - public void subscribe(final Subscriber observer) { - observer.onSubscribe(EmptySubscription.INSTANCE); - new Thread(new Runnable() { - @Override - public void run() { - try { - observer.onError(new Error("failure")); - } catch (Throwable e) { - // without an onError handler it has to just throw on whatever thread invokes it - exception.set(e); - } - latch.countDown(); + final AtomicReference exception = new AtomicReference<>(); + Observable.create(observer -> { + observer.onSubscribe(EmptySubscription.INSTANCE); + new Thread(new Runnable() { + @Override + public void run() { + try { + observer.onError(new Error("failure")); + } catch (Throwable e) { + // without an onError handler it has to just throw on whatever thread invokes it + exception.set(e); } - }).start(); - } + latch.countDown(); + } + }).start(); }).subscribe(); // wait for exception latch.await(3000, TimeUnit.MILLISECONDS); @@ -683,7 +596,7 @@ public void run() { @Test public void testTakeWithErrorInObserver() { final AtomicInteger count = new AtomicInteger(); - final AtomicReference error = new AtomicReference(); + final AtomicReference error = new AtomicReference<>(); Observable.just("1", "2", "three", "4").take(3) .safeSubscribe(new Observer() { @@ -734,9 +647,9 @@ public void testOfType() { @Test public void testOfTypeWithPolymorphism() { - ArrayList l1 = new ArrayList(); + ArrayList l1 = new ArrayList<>(); l1.add(1); - LinkedList l2 = new LinkedList(); + LinkedList l2 = new LinkedList<>(); l2.add(2); @SuppressWarnings("rawtypes") @@ -889,17 +802,7 @@ public void testRangeWithScheduler() { @Test public void testCollectToList() { Observable> o = Observable.just(1, 2, 3) - .collect(new Supplier>() { - @Override - public List get() { - return new ArrayList(); - } - }, new BiConsumer, Integer>() { - @Override - public void accept(List list, Integer v) { - list.add(v); - } - }); + .collect(ArrayList::new, List::add); List list = o.toBlocking().last(); @@ -919,42 +822,33 @@ public void accept(List list, Integer v) { @Test public void testCollectToString() { - String value = Observable.just(1, 2, 3).collect(new Supplier() { - @Override - public StringBuilder get() { - return new StringBuilder(); + String value = Observable.just(1, 2, 3).collect(StringBuilder::new, (sb, v) -> { + if (sb.length() > 0) { + sb.append("-"); } - }, - new BiConsumer() { - @Override - public void accept(StringBuilder sb, Integer v) { - if (sb.length() > 0) { - sb.append("-"); - } - sb.append(v); - } - }).toBlocking().last().toString(); + sb.append(v); + }).toBlocking().last().toString(); assertEquals("1-2-3", value); } @Test public void testMergeWith() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.just(1).mergeWith(Observable.just(2)).subscribe(ts); ts.assertValues(1, 2); } @Test public void testConcatWith() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.just(1).concatWith(Observable.just(2)).subscribe(ts); ts.assertValues(1, 2); } @Test public void testAmbWith() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.just(1).ambWith(Observable.just(2)).subscribe(ts); ts.assertValue(1); } @@ -977,19 +871,9 @@ public void testTakeWhileToList() { for (int i = 0;i < expectedCount; i++) { Observable .just(Boolean.TRUE, Boolean.FALSE) - .takeWhile(new Predicate() { - @Override - public boolean test(Boolean v) { - return v; - } - }) + .takeWhile(v -> v) .toList() - .doOnNext(new Consumer>() { - @Override - public void accept(List booleans) { - count.incrementAndGet(); - } - }) + .doOnNext(booleans -> count.incrementAndGet()) .subscribe(); } assertEquals(expectedCount, count.get()); @@ -997,7 +881,7 @@ public void accept(List booleans) { @Test public void testCompose() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.just(1, 2, 3).compose(new Transformer() { @Override public Publisher apply(Observable t1) { @@ -1076,7 +960,7 @@ public void testForEachWithNull() { @Test public void testExtend() { - final TestSubscriber subscriber = new TestSubscriber(); + final TestSubscriber subscriber = new TestSubscriber<>(); final Object value = new Object(); Observable.just(value).to(new Function, Object>() { @Override diff --git a/src/test/java/io/reactivex/ObservableWindowTests.java b/rxjava/src/test/java/io/reactivex/ObservableWindowTests.java similarity index 68% rename from src/test/java/io/reactivex/ObservableWindowTests.java rename to rxjava/src/test/java/io/reactivex/ObservableWindowTests.java index e6f797a7c4..5b78574e02 100644 --- a/src/test/java/io/reactivex/ObservableWindowTests.java +++ b/rxjava/src/test/java/io/reactivex/ObservableWindowTests.java @@ -26,24 +26,14 @@ public class ObservableWindowTests { @Test public void testWindow() { - final ArrayList> lists = new ArrayList>(); + final ArrayList> lists = new ArrayList<>(); Observable.concat( Observable.just(1, 2, 3, 4, 5, 6) .window(3) - .map(new Function, Observable>>() { - @Override - public Observable> apply(Observable xs) { - return xs.toList(); - } - }) + .map(Observable::toList) ) - .toBlocking().forEach(new Consumer>() { - @Override - public void accept(List xs) { - lists.add(xs); - } - }); + .toBlocking().forEach(lists::add); assertArrayEquals(lists.get(0).toArray(new Integer[3]), new Integer[] { 1, 2, 3 }); assertArrayEquals(lists.get(1).toArray(new Integer[3]), new Integer[] { 4, 5, 6 }); diff --git a/src/test/java/io/reactivex/ReduceTests.java b/rxjava/src/test/java/io/reactivex/ReduceTests.java similarity index 64% rename from src/test/java/io/reactivex/ReduceTests.java rename to rxjava/src/test/java/io/reactivex/ReduceTests.java index 1abc64cf89..9f0e100e1e 100644 --- a/src/test/java/io/reactivex/ReduceTests.java +++ b/rxjava/src/test/java/io/reactivex/ReduceTests.java @@ -26,12 +26,7 @@ public class ReduceTests { @Test public void reduceInts() { Observable o = Observable.just(1, 2, 3); - int value = o.reduce(new BiFunction() { - @Override - public Integer apply(Integer t1, Integer t2) { - return t1 + t2; - } - }).toBlocking().single(); + int value = o.reduce((t1, t2) -> t1 + t2).toBlocking().single(); assertEquals(6, value); } @@ -41,19 +36,9 @@ public Integer apply(Integer t1, Integer t2) { public void reduceWithObjects() { Observable horrorMovies = Observable. just(new HorrorMovie()); - Observable reduceResult = horrorMovies.scan(new BiFunction() { - @Override - public Movie apply(Movie t1, Movie t2) { - return t2; - } - }).takeLast(1); - - Observable reduceResult2 = horrorMovies.reduce(new BiFunction() { - @Override - public Movie apply(Movie t1, Movie t2) { - return t2; - } - }); + Observable reduceResult = horrorMovies.scan((t1, t2) -> t2).takeLast(1); + + Observable reduceResult2 = horrorMovies.reduce((t1, t2) -> t2); } /** @@ -66,12 +51,7 @@ public Movie apply(Movie t1, Movie t2) { public void reduceWithCovariantObjects() { Observable horrorMovies = Observable. just(new HorrorMovie()); - Observable reduceResult2 = horrorMovies.reduce(new BiFunction() { - @Override - public Movie apply(Movie t1, Movie t2) { - return t2; - } - }); + Observable reduceResult2 = horrorMovies.reduce((t1, t2) -> t2); } /** @@ -91,12 +71,7 @@ public void reduceCovariance() { */ public void libraryFunctionActingOnMovieObservables(Observable obs) { - obs.reduce(new BiFunction() { - @Override - public Movie apply(Movie t1, Movie t2) { - return t2; - } - }); + obs.reduce((t1, t2) -> t2); } } \ No newline at end of file diff --git a/src/test/java/io/reactivex/ScanTests.java b/rxjava/src/test/java/io/reactivex/ScanTests.java similarity index 78% rename from src/test/java/io/reactivex/ScanTests.java rename to rxjava/src/test/java/io/reactivex/ScanTests.java index c5fa8a4197..2a9a9ad982 100644 --- a/src/test/java/io/reactivex/ScanTests.java +++ b/rxjava/src/test/java/io/reactivex/ScanTests.java @@ -26,7 +26,7 @@ public class ScanTests { public void testUnsubscribeScan() { EventStream.getEventStream("HTTP-ClusterB", 20) - .scan(new HashMap(), new BiFunction, Event, HashMap>() { + .scan(new HashMap<>(), new BiFunction, Event, HashMap>() { @Override public HashMap apply(HashMap accum, Event perInstanceEvent) { accum.put("instance", perInstanceEvent.instanceId); @@ -35,11 +35,6 @@ public HashMap apply(HashMap accum, Event perIns }) .take(10) .toBlocking() - .forEach(new Consumer>() { - @Override - public void accept(HashMap v) { - System.out.println(v); - } - }); + .forEach(v -> System.out.println(v)); } } \ No newline at end of file diff --git a/src/test/java/io/reactivex/SingleNullTests.java b/rxjava/src/test/java/io/reactivex/SingleNullTests.java similarity index 72% rename from src/test/java/io/reactivex/SingleNullTests.java rename to rxjava/src/test/java/io/reactivex/SingleNullTests.java index 3850e5d871..874b97888d 100644 --- a/src/test/java/io/reactivex/SingleNullTests.java +++ b/rxjava/src/test/java/io/reactivex/SingleNullTests.java @@ -39,12 +39,7 @@ public void ambIterableNull() { @Test(expected = NullPointerException.class) public void ambIterableIteratorNull() { - Single.amb(new Iterable>() { - @Override - public Iterator> iterator() { - return null; - } - }).get(); + Single.amb(() -> null).get(); } @SuppressWarnings("unchecked") @@ -71,12 +66,7 @@ public void concatIterableNull() { @Test(expected = NullPointerException.class) public void concatIterableIteratorNull() { - Single.concat(new Iterable>() { - @Override - public Iterator> iterator() { - return null; - } - }).toBlocking().run(); + Single.concat(() -> null).toBlocking().run(); } @SuppressWarnings("unchecked") @@ -154,12 +144,7 @@ public void fromCallableNull() { @Test(expected = NullPointerException.class) public void fromCallableReturnsNull() { - Single.fromCallable(new Callable() { - @Override - public Object call() throws Exception { - return null; - } - }).get(); + Single.fromCallable(() -> null).get(); } @Test(expected = NullPointerException.class) @@ -169,7 +154,7 @@ public void fromFutureNull() { @Test(expected = NullPointerException.class) public void fromFutureReturnsNull() { - FutureTask f = new FutureTask(Functions.emptyRunnable(), null); + FutureTask f = new FutureTask<>(Functions.emptyRunnable(), null); f.run(); Single.fromFuture(f).get(); } @@ -181,39 +166,24 @@ public void fromFutureTimedFutureNull() { @Test(expected = NullPointerException.class) public void fromFutureTimedUnitNull() { - Single.fromFuture(new FutureTask(new Callable() { - @Override - public Object call() throws Exception { - return null; - } - }), 1, null); + Single.fromFuture(new FutureTask<>(() -> null), 1, null); } @Test(expected = NullPointerException.class) public void fromFutureTimedSchedulerNull() { - Single.fromFuture(new FutureTask(new Callable() { - @Override - public Object call() throws Exception { - return null; - } - }), 1, TimeUnit.SECONDS, null); + Single.fromFuture(new FutureTask<>(() -> null), 1, TimeUnit.SECONDS, null); } @Test(expected = NullPointerException.class) public void fromFutureTimedReturnsNull() { - FutureTask f = new FutureTask(Functions.emptyRunnable(), null); + FutureTask f = new FutureTask<>(Functions.emptyRunnable(), null); f.run(); Single.fromFuture(f, 1, TimeUnit.SECONDS).get(); } @Test(expected = NullPointerException.class) public void fromFutureSchedulerNull() { - Single.fromFuture(new FutureTask(new Callable() { - @Override - public Object call() throws Exception { - return null; - } - }), null); + Single.fromFuture(new FutureTask<>(() -> null), null); } @Test(expected = NullPointerException.class) @@ -233,12 +203,7 @@ public void mergeIterableNull() { @Test(expected = NullPointerException.class) public void mergeIterableIteratorNull() { - Single.merge(new Iterable>() { - @Override - public Iterator> iterator() { - return null; - } - }).toBlocking().run(); + Single.merge(() -> null).toBlocking().run(); } @SuppressWarnings("unchecked") @@ -301,88 +266,38 @@ public void equalsSecondNull() { @Test(expected = NullPointerException.class) public void usingResourceSupplierNull() { - Single.using(null, new Function>() { - @Override - public Single apply(Object d) { - return just1; - } - }, Functions.emptyConsumer()); + Single.using(null, d -> just1, Functions.emptyConsumer()); } @Test(expected = NullPointerException.class) public void usingSingleSupplierNull() { - Single.using(new Supplier() { - @Override - public Object get() { - return 1; - } - }, null, Functions.emptyConsumer()); + Single.using(() -> 1, null, Functions.emptyConsumer()); } @Test(expected = NullPointerException.class) public void usingSingleSupplierReturnsNull() { - Single.using(new Supplier() { - @Override - public Object get() { - return 1; - } - }, new Function>() { - @Override - public Single apply(Object d) { - return null; - } - }, Functions.emptyConsumer()).get(); + Single.using(() -> 1, d -> null, Functions.emptyConsumer()).get(); } @Test(expected = NullPointerException.class) public void usingDisposeNull() { - Single.using(new Supplier() { - @Override - public Object get() { - return 1; - } - }, new Function>() { - @Override - public Single apply(Object d) { - return just1; - } - }, null); + Single.using(() -> 1, d -> just1, null); } @Test(expected = NullPointerException.class) public void zipIterableNull() { - Single.zip((Iterable>)null, new Function() { - @Override - public Object apply(Object[] v) { - return 1; - } - }); + Single.zip(null, v -> 1); } @Test(expected = NullPointerException.class) public void zipIterableIteratorNull() { - Single.zip(new Iterable>() { - @Override - public Iterator> iterator() { - return null; - } - }, new Function() { - @Override - public Object apply(Object[] v) { - return 1; - } - }).get(); + Single.zip(() -> null, v -> 1).get(); } @SuppressWarnings("unchecked") @Test(expected = NullPointerException.class) public void zipIterableOneIsNull() { - Single.zip(Arrays.asList(null, just1), new Function() { - @Override - public Object apply(Object[] v) { - return 1; - } - }).get(); + Single.zip(Arrays.asList(null, just1), v -> 1).get(); } @SuppressWarnings("unchecked") @@ -394,12 +309,7 @@ public void zipIterableOneFunctionNull() { @SuppressWarnings("unchecked") @Test(expected = NullPointerException.class) public void zipIterableOneFunctionReturnsNull() { - Single.zip(Arrays.asList(just1, just1), new Function() { - @Override - public Object apply(Object[] v) { - return null; - } - }).get(); + Single.zip(Arrays.asList(just1, just1), v -> null).get(); } @SuppressWarnings("unchecked") @@ -417,12 +327,7 @@ public void zipNull() throws Exception { Object[] values = new Object[argCount + 1]; Arrays.fill(values, just1); values[argNull - 1] = null; - values[argCount] = Proxy.newProxyInstance(getClass().getClassLoader(), new Class[] { fniClass }, new InvocationHandler() { - @Override - public Object invoke(Object o, Method m, Object[] a) throws Throwable { - return 1; - } - }); + values[argCount] = Proxy.newProxyInstance(getClass().getClassLoader(), new Class[] { fniClass }, (o, m, a) -> 1); Method m = clazz.getMethod("zip", params); @@ -435,12 +340,7 @@ public Object invoke(Object o, Method m, Object[] a) throws Throwable { } } - values[argCount] = Proxy.newProxyInstance(getClass().getClassLoader(), new Class[] { fniClass }, new InvocationHandler() { - @Override - public Object invoke(Object o, Method m1, Object[] a) throws Throwable { - return null; - } - }); + values[argCount] = Proxy.newProxyInstance(getClass().getClassLoader(), new Class[] { fniClass }, (o, m1, a) -> null); try { ((Single)m.invoke(null, values)).get(); Assert.fail("No exception for argCount " + argCount + " / argNull " + argNull); @@ -476,22 +376,12 @@ public Object invoke(Object o, Method m1, Object[] a) throws Throwable { @Test(expected = NullPointerException.class) public void zip2FirstNull() { - Single.zip(null, just1, new BiFunction() { - @Override - public Object apply(Object a, Integer b) { - return 1; - } - }); + Single.zip(null, just1, (a, b) -> 1); } @Test(expected = NullPointerException.class) public void zip2SecondNull() { - Single.zip(just1, null, new BiFunction() { - @Override - public Object apply(Integer a, Object b) { - return 1; - } - }); + Single.zip(just1, null, (a, b) -> 1); } @Test(expected = NullPointerException.class) @@ -501,33 +391,18 @@ public void zip2ZipperNull() { @Test(expected = NullPointerException.class) public void zip2ZipperReturnsdNull() { - Single.zip(just1, null, new BiFunction() { - @Override - public Object apply(Integer a, Object b) { - return null; - } - }).get(); + Single.zip(just1, null, (a, b) -> null).get(); } @Test(expected = NullPointerException.class) public void zipArrayNull() { - Single.zipArray(new Function() { - @Override - public Object apply(Object[] v) { - return 1; - } - }, (Single[])null); + Single.zipArray(v -> 1, (Single[])null); } @SuppressWarnings("unchecked") @Test(expected = NullPointerException.class) public void zipArrayOneIsNull() { - Single.zipArray(new Function() { - @Override - public Object apply(Object[] v) { - return 1; - } - }, just1, null); + Single.zipArray(v -> 1, just1, null); } @SuppressWarnings("unchecked") @@ -539,12 +414,7 @@ public void zipArrayFunctionNull() { @SuppressWarnings("unchecked") @Test(expected = NullPointerException.class) public void zipArrayFunctionReturnsNull() { - Single.zipArray(new Function() { - @Override - public Object apply(Object[] v) { - return null; - } - }, just1, just1).get(); + Single.zipArray(v -> null, just1, just1).get(); } //************************************************** @@ -608,12 +478,7 @@ public void flatMapNull() { @Test(expected = NullPointerException.class) public void flatMapFunctionReturnsNull() { - just1.flatMap(new Function>() { - @Override - public Single apply(Integer v) { - return null; - } - }).get(); + just1.flatMap(v -> null).get(); } @Test(expected = NullPointerException.class) @@ -623,12 +488,7 @@ public void flatMapPublisherNull() { @Test(expected = NullPointerException.class) public void flatMapPublisherFunctionReturnsNull() { - just1.flatMapPublisher(new Function>() { - @Override - public Publisher apply(Integer v) { - return null; - } - }).toBlocking().run(); + just1.flatMapPublisher(v -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) @@ -638,12 +498,7 @@ public void liftNull() { @Test(expected = NullPointerException.class) public void liftFunctionReturnsNull() { - just1.lift(new SingleOperator() { - @Override - public SingleSubscriber apply(SingleSubscriber s) { - return null; - } - }).get(); + just1.lift(s -> null).get(); } @Test(expected = NullPointerException.class) @@ -688,12 +543,7 @@ public void onErrorResumeNextNull() { @Test(expected = NullPointerException.class) public void onErrorResumeNextFunctionReturnsNull() { - error.onErrorResumeNext(new Function>() { - @Override - public Single apply(Throwable e) { - return null; - } - }).get(); + error.onErrorResumeNext(e -> null).get(); } @Test(expected = NullPointerException.class) @@ -703,12 +553,7 @@ public void repeatWhenNull() { @Test(expected = NullPointerException.class) public void repeatWhenFunctionReturnsNull() { - error.repeatWhen(new Function, Publisher>() { - @Override - public Publisher apply(Observable v) { - return null; - } - }).toBlocking().run(); + error.repeatWhen(v -> null).toBlocking().run(); } @Test(expected = NullPointerException.class) @@ -733,12 +578,7 @@ public void retryWhenNull() { @Test(expected = NullPointerException.class) public void retryWhenFunctionReturnsNull() { - error.retryWhen(new Function, Publisher>() { - @Override - public Publisher apply(Observable e) { - return null; - } - }).get(); + error.retryWhen(e -> null).get(); } @Test(expected = NullPointerException.class) @@ -763,18 +603,12 @@ public void subscribeSingeSubscriberNull() { @Test(expected = NullPointerException.class) public void subscribeOnSuccessNull() { - just1.subscribe(null, new Consumer() { - @Override - public void accept(Throwable e) { } - }); + just1.subscribe(null, e -> { }); } @Test(expected = NullPointerException.class) public void subscribeOnErrorNull() { - just1.subscribe(new Consumer() { - @Override - public void accept(Integer v) { } - }, null); + just1.subscribe(v -> { }, null); } @Test(expected = NullPointerException.class) public void subscribeSubscriberNull() { @@ -818,12 +652,7 @@ public void unsafeSubscribeNull() { @Test(expected = NullPointerException.class) public void zipWithNull() { - just1.zipWith(null, new BiFunction() { - @Override - public Object apply(Integer a, Object b) { - return 1; - } - }); + just1.zipWith(null, (a, b) -> 1); } @Test(expected = NullPointerException.class) @@ -833,11 +662,6 @@ public void zipWithFunctionNull() { @Test(expected = NullPointerException.class) public void zipWithFunctionReturnsNull() { - just1.zipWith(just1, new BiFunction() { - @Override - public Object apply(Integer a, Integer b) { - return null; - } - }).get(); + just1.zipWith(just1, (a, b) -> null).get(); } } \ No newline at end of file diff --git a/src/test/java/io/reactivex/SingleTest.java b/rxjava/src/test/java/io/reactivex/SingleTest.java similarity index 51% rename from src/test/java/io/reactivex/SingleTest.java rename to rxjava/src/test/java/io/reactivex/SingleTest.java index 68313c657a..6de8c1733d 100644 --- a/src/test/java/io/reactivex/SingleTest.java +++ b/rxjava/src/test/java/io/reactivex/SingleTest.java @@ -32,14 +32,14 @@ public class SingleTest { @Test public void testHelloWorld() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Single.just("Hello World!").subscribe(ts); ts.assertValueSequence(Arrays.asList("Hello World!")); } @Test public void testHelloWorld2() { - final AtomicReference v = new AtomicReference(); + final AtomicReference v = new AtomicReference<>(); Single.just("Hello World!").subscribe(new SingleSubscriber() { @Override @@ -63,51 +63,36 @@ public void onError(Throwable error) { @Test public void testMap() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Single.just("A") - .map(new Function() { - @Override - public String apply(String s) { - return s + "B"; - } - }) + .map(s -> s + "B") .subscribe(ts); ts.assertValueSequence(Arrays.asList("AB")); } @Test public void testZip() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Single a = Single.just("A"); Single b = Single.just("B"); - Single.zip(a, b, new BiFunction() { - @Override - public String apply(String a1, String b1) { - return a1 + b1; - } - }) + Single.zip(a, b, (a1, b1) -> a1 + b1) .subscribe(ts); ts.assertValueSequence(Arrays.asList("AB")); } @Test public void testZipWith() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); - Single.just("A").zipWith(Single.just("B"), new BiFunction() { - @Override - public String apply(String a1, String b1) { - return a1 + b1; - } - }) + Single.just("A").zipWith(Single.just("B"), (a1, b1) -> a1 + b1) .subscribe(ts); ts.assertValueSequence(Arrays.asList("AB")); } @Test public void testMerge() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Single a = Single.just("A"); Single b = Single.just("B"); @@ -117,7 +102,7 @@ public void testMerge() { @Test public void testMergeWith() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Single.just("A").mergeWith(Single.just("B")).subscribe(ts); ts.assertValueSequence(Arrays.asList("A", "B")); @@ -125,14 +110,11 @@ public void testMergeWith() { @Test public void testCreateSuccess() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); - Single.create(new SingleOnSubscribe() { - @Override - public void accept(SingleSubscriber s) { - s.onSubscribe(EmptyDisposable.INSTANCE); - s.onSuccess("Hello"); - } + Single.create(s -> { + s.onSubscribe(EmptyDisposable.INSTANCE); + s.onSuccess("Hello"); }).subscribe(ts); ts.assertValueSequence(Arrays.asList("Hello")); @@ -140,13 +122,10 @@ public void accept(SingleSubscriber s) { @Test public void testCreateError() { - TestSubscriber ts = new TestSubscriber(); - Single.create(new SingleOnSubscribe() { - @Override - public void accept(SingleSubscriber s) { - s.onSubscribe(EmptyDisposable.INSTANCE); - s.onError(new RuntimeException("fail")); - } + TestSubscriber ts = new TestSubscriber<>(); + Single.create(s -> { + s.onSubscribe(EmptyDisposable.INSTANCE); + s.onError(new RuntimeException("fail")); }).subscribe(ts); ts.assertError(RuntimeException.class); @@ -155,23 +134,17 @@ public void accept(SingleSubscriber s) { @Test public void testAsync() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Single.just("Hello") .subscribeOn(Schedulers.io()) - .map(new Function() { - @Override - public String apply(String v) { - System.out.println("SubscribeOn Thread: " + Thread.currentThread()); - return v; - } + .map(v -> { + System.out.println("SubscribeOn Thread: " + Thread.currentThread()); + return v; }) .observeOn(Schedulers.computation()) - .map(new Function() { - @Override - public String apply(String v) { - System.out.println("ObserveOn Thread: " + Thread.currentThread()); - return v; - } + .map(v -> { + System.out.println("ObserveOn Thread: " + Thread.currentThread()); + return v; }) .subscribe(ts); ts.awaitTerminalEvent(); @@ -180,32 +153,25 @@ public String apply(String v) { @Test public void testFlatMap() { - TestSubscriber ts = new TestSubscriber(); - Single.just("Hello").flatMap(new Function>() { - @Override - public Single apply(String s) { - return Single.just(s + " World!").subscribeOn(Schedulers.computation()); - } - } - ).subscribe(ts); + TestSubscriber ts = new TestSubscriber<>(); + Single.just("Hello") + .flatMap(s -> Single.just(s + " World!").subscribeOn(Schedulers.computation())) + .subscribe(ts); ts.awaitTerminalEvent(); ts.assertValueSequence(Arrays.asList("Hello World!")); } @Test public void testTimeout() { - TestSubscriber ts = new TestSubscriber(); - Single s1 = Single.create(new SingleOnSubscribe() { - @Override - public void accept(SingleSubscriber s) { - s.onSubscribe(EmptyDisposable.INSTANCE); - try { - Thread.sleep(5000); - } catch (InterruptedException e) { - // ignore as we expect this for the test - } - s.onSuccess("success"); + TestSubscriber ts = new TestSubscriber<>(); + Single s1 = Single.create(s -> { + s.onSubscribe(EmptyDisposable.INSTANCE); + try { + Thread.sleep(5000); + } catch (InterruptedException e) { + // ignore as we expect this for the test } + s.onSuccess("success"); }).subscribeOn(Schedulers.io()); s1.timeout(100, TimeUnit.MILLISECONDS).subscribe(ts); @@ -216,18 +182,15 @@ public void accept(SingleSubscriber s) { @Test public void testTimeoutWithFallback() { - TestSubscriber ts = new TestSubscriber(); - Single s1 = Single.create(new SingleOnSubscribe() { - @Override - public void accept(SingleSubscriber s) { - s.onSubscribe(EmptyDisposable.INSTANCE); - try { - Thread.sleep(5000); - } catch (InterruptedException e) { - // ignore as we expect this for the test - } - s.onSuccess("success"); - } + TestSubscriber ts = new TestSubscriber<>(); + Single s1 = Single.create(s -> { + s.onSubscribe(EmptyDisposable.INSTANCE); + try { + Thread.sleep(5000); + } catch (InterruptedException e) { + // ignore as we expect this for the test + } + s.onSuccess("success"); }).subscribeOn(Schedulers.io()); s1.timeout(100, TimeUnit.MILLISECONDS, Single.just("hello")).subscribe(ts); @@ -239,40 +202,29 @@ public void accept(SingleSubscriber s) { @Test public void testUnsubscribe() throws InterruptedException { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); final AtomicBoolean unsubscribed = new AtomicBoolean(); final AtomicBoolean interrupted = new AtomicBoolean(); final CountDownLatch latch = new CountDownLatch(2); - Single s1 = Single.create(new SingleOnSubscribe() { - @Override - public void accept(final SingleSubscriber s) { - MultipleAssignmentDisposable mad = new MultipleAssignmentDisposable(); - s.onSubscribe(mad); - final Thread t = new Thread(new Runnable() { - - @Override - public void run() { - try { - Thread.sleep(5000); - s.onSuccess("success"); - } catch (InterruptedException e) { - interrupted.set(true); - latch.countDown(); - } - } - - }); - mad.set(new Disposable() { - @Override - public void dispose() { - unsubscribed.set(true); - t.interrupt(); - latch.countDown(); - } - }); - t.start(); - } + Single s1 = Single.create(s -> { + MultipleAssignmentDisposable mad = new MultipleAssignmentDisposable(); + s.onSubscribe(mad); + final Thread t = new Thread(() -> { + try { + Thread.sleep(5000); + s.onSuccess("success"); + } catch (InterruptedException e) { + interrupted.set(true); + latch.countDown(); + } + }); + mad.set(() -> { + unsubscribed.set(true); + t.interrupt(); + latch.countDown(); + }); + t.start(); }); s1.subscribe(ts); @@ -318,36 +270,24 @@ public void onError(Throwable error) { final AtomicBoolean interrupted = new AtomicBoolean(); final CountDownLatch latch = new CountDownLatch(2); - Single s1 = Single.create(new SingleOnSubscribe() { - @Override - public void accept(final SingleSubscriber s) { - MultipleAssignmentDisposable mad = new MultipleAssignmentDisposable(); - s.onSubscribe(mad); - final Thread t = new Thread(new Runnable() { - - @Override - public void run() { - try { - Thread.sleep(5000); - s.onSuccess("success"); - } catch (InterruptedException e) { - interrupted.set(true); - latch.countDown(); - } - } - - }); - mad.set(new Disposable() { - @Override - public void dispose() { - unsubscribed.set(true); - t.interrupt(); - latch.countDown(); - } - }); - t.start(); - - } + Single s1 = Single.create(s -> { + MultipleAssignmentDisposable mad = new MultipleAssignmentDisposable(); + s.onSubscribe(mad); + final Thread t = new Thread(() -> { + try { + Thread.sleep(5000); + s.onSuccess("success"); + } catch (InterruptedException e) { + interrupted.set(true); + latch.countDown(); + } + }); + mad.set(() -> { + unsubscribed.set(true); + t.interrupt(); + latch.countDown(); + }); + t.start(); }); s1.subscribe(ts); @@ -374,36 +314,24 @@ public void testUnsubscribeViaReturnedSubscription() throws InterruptedException final AtomicBoolean interrupted = new AtomicBoolean(); final CountDownLatch latch = new CountDownLatch(2); - Single s1 = Single.create(new SingleOnSubscribe() { - @Override - public void accept(final SingleSubscriber s) { - MultipleAssignmentDisposable mad = new MultipleAssignmentDisposable(); - s.onSubscribe(mad); - final Thread t = new Thread(new Runnable() { - - @Override - public void run() { - try { - Thread.sleep(5000); - s.onSuccess("success"); - } catch (InterruptedException e) { - interrupted.set(true); - latch.countDown(); - } - } - - }); - mad.set(new Disposable() { - @Override - public void dispose() { - unsubscribed.set(true); - t.interrupt(); - latch.countDown(); - } - }); - t.start(); - - } + Single s1 = Single.create(s -> { + MultipleAssignmentDisposable mad = new MultipleAssignmentDisposable(); + s.onSubscribe(mad); + final Thread t = new Thread(() -> { + try { + Thread.sleep(5000); + s.onSuccess("success"); + } catch (InterruptedException e) { + interrupted.set(true); + latch.countDown(); + } + }); + mad.set(() -> { + unsubscribed.set(true); + t.interrupt(); + latch.countDown(); + }); + t.start(); }); Disposable subscription = s1.subscribe(); @@ -430,7 +358,7 @@ public void accept(SingleSubscriber t) { } }); - TestSubscriber ts = new TestSubscriber((Long)null); + TestSubscriber ts = new TestSubscriber<>((Long) null); s.subscribe(ts); @@ -444,7 +372,7 @@ public void accept(SingleSubscriber t) { @Test public void testToObservable() { Observable a = Single.just("a").toFlowable(); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); a.subscribe(ts); ts.assertValue("a"); ts.assertNoErrors(); diff --git a/src/test/java/io/reactivex/StartWithTests.java b/rxjava/src/test/java/io/reactivex/StartWithTests.java similarity index 94% rename from src/test/java/io/reactivex/StartWithTests.java rename to rxjava/src/test/java/io/reactivex/StartWithTests.java index 4ae91ae6fe..4387f4b1d8 100644 --- a/src/test/java/io/reactivex/StartWithTests.java +++ b/rxjava/src/test/java/io/reactivex/StartWithTests.java @@ -34,7 +34,7 @@ public void startWith1() { @Test public void startWithIterable() { - List li = new ArrayList(); + List li = new ArrayList<>(); li.add("alpha"); li.add("beta"); List values = Observable.just("one", "two").startWith(li).toList().toBlocking().single(); @@ -47,7 +47,7 @@ public void startWithIterable() { @Test public void startWithObservable() { - List li = new ArrayList(); + List li = new ArrayList<>(); li.add("alpha"); li.add("beta"); List values = Observable.just("one", "two") diff --git a/src/test/java/io/reactivex/SubscriberTest.java b/rxjava/src/test/java/io/reactivex/SubscriberTest.java similarity index 64% rename from src/test/java/io/reactivex/SubscriberTest.java rename to rxjava/src/test/java/io/reactivex/SubscriberTest.java index 46b0ae00b6..5b44d6d391 100644 --- a/src/test/java/io/reactivex/SubscriberTest.java +++ b/rxjava/src/test/java/io/reactivex/SubscriberTest.java @@ -33,7 +33,7 @@ public class SubscriberTest { */ @Test public void testRequestFromFinalSubscribeWithRequestValue() { - TestSubscriber s = new TestSubscriber((Long)null); + TestSubscriber s = new TestSubscriber<>((Long) null); s.request(10); final AtomicLong r = new AtomicLong(); s.onSubscribe(new Subscription() { @@ -57,7 +57,7 @@ public void cancel() { */ @Test public void testRequestFromFinalSubscribeWithoutRequestValue() { - TestSubscriber s = new TestSubscriber(); + TestSubscriber s = new TestSubscriber<>(); final AtomicLong r = new AtomicLong(); s.onSubscribe(new Subscription() { @@ -77,34 +77,29 @@ public void cancel() { @Test public void testRequestFromChainedOperator() { - TestSubscriber s = new TestSubscriber(); - Operator o = new Operator() { - @Override - public Subscriber apply(final Subscriber s1) { - return new Subscriber() { + TestSubscriber s = new TestSubscriber<>(); + Operator o = s1 -> new Subscriber() { - @Override - public void onSubscribe(Subscription a) { - s1.onSubscribe(a); - } - - @Override - public void onComplete() { + @Override + public void onSubscribe(Subscription a) { + s1.onSubscribe(a); + } - } + @Override + public void onComplete() { - @Override - public void onError(Throwable e) { + } - } + @Override + public void onError(Throwable e) { - @Override - public void onNext(String t) { + } - } + @Override + public void onNext(String t) { - }; } + }; s.request(10); Subscriber ns = o.apply(s); @@ -130,34 +125,29 @@ public void cancel() { @Test public void testRequestFromDecoupledOperator() { - TestSubscriber s = new TestSubscriber((Long)null); - Operator o = new Operator() { - @Override - public Subscriber apply(final Subscriber s1) { - return new Subscriber() { + TestSubscriber s = new TestSubscriber<>((Long) null); + Operator o = s1 -> new Subscriber() { - @Override - public void onSubscribe(Subscription a) { - s1.onSubscribe(a); - } - - @Override - public void onComplete() { + @Override + public void onSubscribe(Subscription a) { + s1.onSubscribe(a); + } - } + @Override + public void onComplete() { - @Override - public void onError(Throwable e) { + } - } + @Override + public void onError(Throwable e) { - @Override - public void onNext(String t) { + } - } + @Override + public void onNext(String t) { - }; } + }; s.request(10); Subscriber ns = o.apply(s); @@ -183,53 +173,50 @@ public void cancel() { @Test public void testRequestFromDecoupledOperatorThatRequestsN() { - TestSubscriber s = new TestSubscriber(); + TestSubscriber s = new TestSubscriber<>(); final AtomicLong innerR = new AtomicLong(); - Operator o = new Operator() { - @Override - public Subscriber apply(Subscriber child) { - // we want to decouple the chain so set our own Producer on the child instead of it coming from the parent - child.onSubscribe(new Subscription() { + Operator o = child -> { + // we want to decouple the chain so set our own Producer on the child instead of it coming from the parent + child.onSubscribe(new Subscription() { - @Override - public void request(long n) { - innerR.set(n); - } - - @Override - public void cancel() { - - } + @Override + public void request(long n) { + innerR.set(n); + } - }); + @Override + public void cancel() { - AsyncObserver as = new AsyncObserver() { - - @Override - protected void onStart() { - // we request 99 up to the parent - request(99); - } - - @Override - public void onComplete() { + } - } + }); - @Override - public void onError(Throwable e) { + AsyncObserver as = new AsyncObserver() { - } + @Override + protected void onStart() { + // we request 99 up to the parent + request(99); + } - @Override - public void onNext(String t) { + @Override + public void onComplete() { - } - - - }; - return as; - } + } + + @Override + public void onError(Throwable e) { + + } + + @Override + public void onNext(String t) { + + } + + + }; + return as; }; s.request(10); Subscriber ns = o.apply(s); @@ -256,77 +243,64 @@ public void cancel() { @Test public void testRequestToObservable() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); ts.request(3); final AtomicLong requested = new AtomicLong(); - Observable.create(new Publisher() { - @Override - public void subscribe(Subscriber s) { - s.onSubscribe(new Subscription() { - - @Override - public void request(long n) { - requested.set(n); - } - - @Override - public void cancel() { - - } - }); - } - }).subscribe(ts); + Observable.create(s -> + s.onSubscribe(new Subscription() { + @Override + public void request(long n) { + requested.set(n); + } + + @Override + public void cancel() { + + } + }) + ).subscribe(ts); assertEquals(3, requested.get()); } @Test public void testRequestThroughMap() { - TestSubscriber ts = new TestSubscriber((Long)null); + TestSubscriber ts = new TestSubscriber<>((Long) null); ts.request(3); final AtomicLong requested = new AtomicLong(); - Observable.create(new Publisher() { - @Override - public void subscribe(Subscriber s) { - s.onSubscribe(new Subscription() { - - @Override - public void request(long n) { - requested.set(n); - } - - @Override - public void cancel() { - - } - }); - } - }).map(Functions.identity()).subscribe(ts); + Observable.create(s -> + s.onSubscribe(new Subscription() { + @Override + public void request(long n) { + requested.set(n); + } + + @Override + public void cancel() { + + } + }) + ).map(Functions.identity()).subscribe(ts); assertEquals(3, requested.get()); } @Test public void testRequestThroughTakeThatReducesRequest() { - TestSubscriber ts = new TestSubscriber((Long)null); + TestSubscriber ts = new TestSubscriber<>((Long) null); ts.request(3); final AtomicLong requested = new AtomicLong(); - Observable.create(new Publisher() { + Observable.create(s -> s.onSubscribe(new Subscription() { + @Override - public void subscribe(Subscriber s) { - s.onSubscribe(new Subscription() { + public void request(long n) { + requested.set(n); + } - @Override - public void request(long n) { - requested.set(n); - } + @Override + public void cancel() { - @Override - public void cancel() { - - } - - }); } - }).take(2).subscribe(ts); + + })).take(2).subscribe(ts); // FIXME the take now requests Long.MAX_PATH if downstream requests at least the limit assertEquals(Long.MAX_VALUE, requested.get()); @@ -334,27 +308,22 @@ public void cancel() { @Test public void testRequestThroughTakeWhereRequestIsSmallerThanTake() { - TestSubscriber ts = new TestSubscriber((Long)null); + TestSubscriber ts = new TestSubscriber<>((Long) null); ts.request(3); final AtomicLong requested = new AtomicLong(); - Observable.create(new Publisher() { + Observable.create(s -> s.onSubscribe(new Subscription() { + @Override - public void subscribe(Subscriber s) { - s.onSubscribe(new Subscription() { + public void request(long n) { + requested.set(n); + } - @Override - public void request(long n) { - requested.set(n); - } - - @Override - public void cancel() { - - } + @Override + public void cancel() { - }); } - }).take(10).subscribe(ts); + + })).take(10).subscribe(ts); assertEquals(3, requested.get()); } @@ -463,7 +432,7 @@ public void onNext(Integer t) { @Test public void testNegativeRequestThrowsIllegalArgumentException() throws InterruptedException { final CountDownLatch latch = new CountDownLatch(1); - final AtomicReference exception = new AtomicReference(); + final AtomicReference exception = new AtomicReference<>(); Observable.just(1,2,3,4).subscribe(new Observer() { @Override @@ -494,7 +463,7 @@ public void onNext(Integer t) { @Test public void testOnStartRequestsAreAdditive() { - final List list = new ArrayList(); + final List list = new ArrayList<>(); Observable.just(1,2,3,4,5).subscribe(new Observer() { @Override public void onStart() { @@ -521,7 +490,7 @@ public void onNext(Integer t) { @Test public void testOnStartRequestsAreAdditiveAndOverflowBecomesMaxValue() { - final List list = new ArrayList(); + final List list = new ArrayList<>(); Observable.just(1,2,3,4,5).subscribe(new Observer() { @Override public void onStart() { diff --git a/src/test/java/io/reactivex/TestHelper.java b/rxjava/src/test/java/io/reactivex/TestHelper.java similarity index 80% rename from src/test/java/io/reactivex/TestHelper.java rename to rxjava/src/test/java/io/reactivex/TestHelper.java index 3c1bd2efa0..3cfb15a798 100644 --- a/src/test/java/io/reactivex/TestHelper.java +++ b/rxjava/src/test/java/io/reactivex/TestHelper.java @@ -37,14 +37,11 @@ public enum TestHelper { public static Subscriber mockSubscriber() { Subscriber w = mock(Subscriber.class); - Mockito.doAnswer(new Answer() { - @Override - public Object answer(InvocationOnMock a) throws Throwable { - Subscription s = a.getArgumentAt(0, Subscription.class); - s.request(Long.MAX_VALUE); - return null; - } - }).when(w).onSubscribe((Subscription)any()); + Mockito.doAnswer(a -> { + Subscription s = a.getArgumentAt(0, Subscription.class); + s.request(Long.MAX_VALUE); + return null; + }).when(w).onSubscribe(any()); return w; } diff --git a/src/test/java/io/reactivex/ThrottleLastTests.java b/rxjava/src/test/java/io/reactivex/ThrottleLastTests.java similarity index 100% rename from src/test/java/io/reactivex/ThrottleLastTests.java rename to rxjava/src/test/java/io/reactivex/ThrottleLastTests.java diff --git a/src/test/java/io/reactivex/ThrottleWithTimeoutTests.java b/rxjava/src/test/java/io/reactivex/ThrottleWithTimeoutTests.java similarity index 100% rename from src/test/java/io/reactivex/ThrottleWithTimeoutTests.java rename to rxjava/src/test/java/io/reactivex/ThrottleWithTimeoutTests.java diff --git a/src/test/java/io/reactivex/ZipTests.java b/rxjava/src/test/java/io/reactivex/ZipTests.java similarity index 55% rename from src/test/java/io/reactivex/ZipTests.java rename to rxjava/src/test/java/io/reactivex/ZipTests.java index 49b819db61..51942f06f1 100644 --- a/src/test/java/io/reactivex/ZipTests.java +++ b/rxjava/src/test/java/io/reactivex/ZipTests.java @@ -31,33 +31,14 @@ public class ZipTests { @Test public void testZipObservableOfObservables() { EventStream.getEventStream("HTTP-ClusterB", 20) - .groupBy(new Function() { - @Override - public String apply(Event e) { - return e.instanceId; - } - }) + .groupBy(e -> e.instanceId) // now we have streams of cluster+instanceId - .flatMap(new Function, Publisher>>() { - @Override - public Publisher> apply(final GroupedObservable ge) { - return ge.scan(new HashMap(), new BiFunction, Event, HashMap>() { - @Override - public HashMap apply(HashMap accum, - Event perInstanceEvent) { - accum.put("instance", ge.key()); - return accum; - } - }); - } - }) + .flatMap(ge -> ge.scan(new HashMap<>(), (accum, perInstanceEvent) -> { + accum.put("instance", ge.key()); + return accum; + })) .take(10) - .toBlocking().forEach(new Consumer>() { - @Override - public void accept(HashMap v) { - System.out.println(v); - } - }); + .toBlocking().forEach(System.out::println); System.out.println("**** finished"); } @@ -92,36 +73,18 @@ public void nonBlockingObservable() { Collection> observables = Collections.emptyList(); - Observable result = Observable.zip(observables, new Function() { - @Override - public Object apply(Object[] args) { - System.out.println("received: " + args); - assertEquals("No argument should have been passed", 0, args.length); - return invoked; - } + Observable result = Observable.zip(observables, args -> { + System.out.println("received: " + args); + assertEquals("No argument should have been passed", 0, args.length); + return invoked; }); assertSame(invoked, result.toBlocking().last()); } - BiFunction combine = new BiFunction() { - @Override - public ExtendedResult apply(Media m, Rating r) { - return new ExtendedResult(); - } - }; - - Consumer action = new Consumer() { - @Override - public void accept(Result t1) { - System.out.println("Result: " + t1); - } - }; - - Consumer extendedAction = new Consumer() { - @Override - public void accept(ExtendedResult t1) { - System.out.println("Result: " + t1); - } - }; + BiFunction combine = (m, r) -> new ExtendedResult(); + + Consumer action = t1 -> System.out.println("Result: " + t1); + + Consumer extendedAction = t1 -> System.out.println("Result: " + t1); } \ No newline at end of file diff --git a/src/test/java/io/reactivex/disposables/CompositeDisposableTest.java b/rxjava/src/test/java/io/reactivex/disposables/CompositeDisposableTest.java similarity index 77% rename from src/test/java/io/reactivex/disposables/CompositeDisposableTest.java rename to rxjava/src/test/java/io/reactivex/disposables/CompositeDisposableTest.java index 93d7c172fc..dbcc41d65b 100644 --- a/src/test/java/io/reactivex/disposables/CompositeDisposableTest.java +++ b/rxjava/src/test/java/io/reactivex/disposables/CompositeDisposableTest.java @@ -29,22 +29,9 @@ public class CompositeDisposableTest { public void testSuccess() { final AtomicInteger counter = new AtomicInteger(); CompositeDisposable s = new CompositeDisposable(); - s.add(new Disposable() { + s.add(counter::incrementAndGet); - @Override - public void dispose() { - counter.incrementAndGet(); - } - - }); - - s.add(new Disposable() { - - @Override - public void dispose() { - counter.incrementAndGet(); - } - }); + s.add(counter::incrementAndGet); s.dispose(); @@ -59,16 +46,10 @@ public void shouldUnsubscribeAll() throws InterruptedException { final int count = 10; final CountDownLatch start = new CountDownLatch(1); for (int i = 0; i < count; i++) { - s.add(new Disposable() { - - @Override - public void dispose() { - counter.incrementAndGet(); - } - }); + s.add(counter::incrementAndGet); } - final List threads = new ArrayList(); + final List threads = new ArrayList<>(); for (int i = 0; i < count; i++) { final Thread t = new Thread() { @Override @@ -97,23 +78,11 @@ public void run() { public void testException() { final AtomicInteger counter = new AtomicInteger(); CompositeDisposable s = new CompositeDisposable(); - s.add(new Disposable() { - - @Override - public void dispose() { - throw new RuntimeException("failed on first one"); - } - + s.add(() -> { + throw new RuntimeException("failed on first one"); }); - s.add(new Disposable() { - - @Override - public void dispose() { - counter.incrementAndGet(); - } - - }); + s.add(counter::incrementAndGet); try { s.dispose(); @@ -131,31 +100,15 @@ public void dispose() { public void testCompositeException() { final AtomicInteger counter = new AtomicInteger(); CompositeDisposable s = new CompositeDisposable(); - s.add(new Disposable() { - - @Override - public void dispose() { - throw new RuntimeException("failed on first one"); - } - + s.add(() -> { + throw new RuntimeException("failed on first one"); }); - s.add(new Disposable() { - - @Override - public void dispose() { - throw new RuntimeException("failed on second one too"); - } + s.add(() -> { + throw new RuntimeException("failed on second one too"); }); - s.add(new Disposable() { - - @Override - public void dispose() { - counter.incrementAndGet(); - } - - }); + s.add(() -> counter.incrementAndGet()); try { s.dispose(); @@ -215,14 +168,7 @@ public void testClear() { public void testUnsubscribeIdempotence() { final AtomicInteger counter = new AtomicInteger(); CompositeDisposable s = new CompositeDisposable(); - s.add(new Disposable() { - - @Override - public void dispose() { - counter.incrementAndGet(); - } - - }); + s.add(counter::incrementAndGet); s.dispose(); s.dispose(); @@ -240,16 +186,9 @@ public void testUnsubscribeIdempotenceConcurrently() final int count = 10; final CountDownLatch start = new CountDownLatch(1); - s.add(new Disposable() { - - @Override - public void dispose() { - counter.incrementAndGet(); - } - - }); + s.add(counter::incrementAndGet); - final List threads = new ArrayList(); + final List threads = new ArrayList<>(); for (int i = 0; i < count; i++) { final Thread t = new Thread() { @Override diff --git a/src/test/java/io/reactivex/disposables/DisposablesTest.java b/rxjava/src/test/java/io/reactivex/disposables/DisposablesTest.java similarity index 100% rename from src/test/java/io/reactivex/disposables/DisposablesTest.java rename to rxjava/src/test/java/io/reactivex/disposables/DisposablesTest.java diff --git a/src/test/java/io/reactivex/disposables/MultipleAssignmentDisposableTest.java b/rxjava/src/test/java/io/reactivex/disposables/MultipleAssignmentDisposableTest.java similarity index 100% rename from src/test/java/io/reactivex/disposables/MultipleAssignmentDisposableTest.java rename to rxjava/src/test/java/io/reactivex/disposables/MultipleAssignmentDisposableTest.java diff --git a/src/test/java/io/reactivex/disposables/RefCountDisposableTest.java b/rxjava/src/test/java/io/reactivex/disposables/RefCountDisposableTest.java similarity index 100% rename from src/test/java/io/reactivex/disposables/RefCountDisposableTest.java rename to rxjava/src/test/java/io/reactivex/disposables/RefCountDisposableTest.java diff --git a/src/test/java/io/reactivex/disposables/SerialDisposableTests.java b/rxjava/src/test/java/io/reactivex/disposables/SerialDisposableTests.java similarity index 96% rename from src/test/java/io/reactivex/disposables/SerialDisposableTests.java rename to rxjava/src/test/java/io/reactivex/disposables/SerialDisposableTests.java index b0c821d6f5..54308beb0a 100644 --- a/src/test/java/io/reactivex/disposables/SerialDisposableTests.java +++ b/rxjava/src/test/java/io/reactivex/disposables/SerialDisposableTests.java @@ -115,7 +115,7 @@ public void settingUnderlyingWhenUnsubscribedCausesImmediateUnsubscriptionConcur final int count = 10; final CountDownLatch end = new CountDownLatch(count); - final List threads = new ArrayList(); + final List threads = new ArrayList<>(); for (int i = 0; i < count; i++) { final Thread t = new Thread() { @Override @@ -150,12 +150,12 @@ public void run() { public void concurrentSetDisposableShouldNotInterleave() throws InterruptedException { final int count = 10; - final List subscriptions = new ArrayList(); + final List subscriptions = new ArrayList<>(); final CountDownLatch start = new CountDownLatch(1); final CountDownLatch end = new CountDownLatch(count); - final List threads = new ArrayList(); + final List threads = new ArrayList<>(); for (int i = 0; i < count; i++) { final Disposable subscription = mock(Disposable.class); subscriptions.add(subscription); diff --git a/src/test/java/io/reactivex/exceptions/TestException.java b/rxjava/src/test/java/io/reactivex/exceptions/TestException.java similarity index 100% rename from src/test/java/io/reactivex/exceptions/TestException.java rename to rxjava/src/test/java/io/reactivex/exceptions/TestException.java diff --git a/src/test/java/io/reactivex/internal/operators/BackpressureHelperTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/BackpressureHelperTest.java similarity index 100% rename from src/test/java/io/reactivex/internal/operators/BackpressureHelperTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/BackpressureHelperTest.java diff --git a/src/test/java/io/reactivex/internal/operators/BlockingOperatorLatestTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/BlockingOperatorLatestTest.java similarity index 100% rename from src/test/java/io/reactivex/internal/operators/BlockingOperatorLatestTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/BlockingOperatorLatestTest.java diff --git a/src/test/java/io/reactivex/internal/operators/BlockingOperatorMostRecentTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/BlockingOperatorMostRecentTest.java similarity index 100% rename from src/test/java/io/reactivex/internal/operators/BlockingOperatorMostRecentTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/BlockingOperatorMostRecentTest.java diff --git a/src/test/java/io/reactivex/internal/operators/BlockingOperatorNextTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/BlockingOperatorNextTest.java similarity index 94% rename from src/test/java/io/reactivex/internal/operators/BlockingOperatorNextTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/BlockingOperatorNextTest.java index 62e249abd9..41e0d57475 100644 --- a/src/test/java/io/reactivex/internal/operators/BlockingOperatorNextTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/BlockingOperatorNextTest.java @@ -239,21 +239,17 @@ public void testNoBufferingOrBlockingOfSequence() throws Throwable { @Override public void subscribe(final Subscriber o) { o.onSubscribe(EmptySubscription.INSTANCE); - new Thread(new Runnable() { - - @Override - public void run() { - try { - while (running.get()) { - o.onNext(count.incrementAndGet()); - timeHasPassed.countDown(); - } - o.onComplete(); - } catch (Throwable e) { - o.onError(e); - } finally { - finished.countDown(); + new Thread(() -> { + try { + while (running.get()) { + o.onNext(count.incrementAndGet()); + timeHasPassed.countDown(); } + o.onComplete(); + } catch (Throwable e) { + o.onError(e); + } finally { + finished.countDown(); } }).start(); } diff --git a/src/test/java/io/reactivex/internal/operators/BlockingOperatorToIteratorTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/BlockingOperatorToIteratorTest.java similarity index 90% rename from src/test/java/io/reactivex/internal/operators/BlockingOperatorToIteratorTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/BlockingOperatorToIteratorTest.java index d02df09f88..60682f0154 100644 --- a/src/test/java/io/reactivex/internal/operators/BlockingOperatorToIteratorTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/BlockingOperatorToIteratorTest.java @@ -69,11 +69,8 @@ public void subscribe(Subscriber observer) { @Ignore("subscribe() should not throw") @Test(expected = TestException.class) public void testExceptionThrownFromOnSubscribe() { - Iterable strings = Observable.create(new Publisher() { - @Override - public void subscribe(Subscriber subscriber) { - throw new TestException("intentional"); - } + Iterable strings = Observable.create((Publisher) subscriber -> { + throw new TestException("intentional"); }).toBlocking(); for (String string : strings) { // never reaches here diff --git a/src/test/java/io/reactivex/internal/operators/BufferUntilSubscriberTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/BufferUntilSubscriberTest.java similarity index 58% rename from src/test/java/io/reactivex/internal/operators/BufferUntilSubscriberTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/BufferUntilSubscriberTest.java index 7912fd5d95..7be72b6752 100644 --- a/src/test/java/io/reactivex/internal/operators/BufferUntilSubscriberTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/BufferUntilSubscriberTest.java @@ -42,32 +42,21 @@ public void testIssue1677() throws InterruptedException { Observable.fromArray(numbers) .takeUntil(s) .window(50) - .flatMap(new Function, Publisher>() { - @Override - public Publisher apply(Observable integerObservable) { - return integerObservable - .subscribeOn(Schedulers.computation()) - .map(new Function() { - @Override - public Object apply(Integer integer) { - if (integer >= 5 && completed.compareAndSet(false, true)) { - s.onComplete(); - } - // do some work - Math.pow(Math.random(), Math.random()); - return integer * 2; - } - }); - } - }) + .flatMap(integerObservable -> integerObservable + .subscribeOn(Schedulers.computation()) + .map((Function) integer -> { + if (integer >= 5 && completed.compareAndSet(false, true)) { + s.onComplete(); + } + // do some work + Math.pow(Math.random(), Math.random()); + return integer * 2; + })) .toList() - .doOnNext(new Consumer>() { - @Override - public void accept(List integers) { - counter.incrementAndGet(); - latch.countDown(); - innerLatch.countDown(); - } + .doOnNext(integers -> { + counter.incrementAndGet(); + latch.countDown(); + innerLatch.countDown(); }) .subscribe(); if (!innerLatch.await(30, TimeUnit.SECONDS)) diff --git a/src/test/java/io/reactivex/internal/operators/CachedObservableTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/CachedObservableTest.java similarity index 80% rename from src/test/java/io/reactivex/internal/operators/CachedObservableTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/CachedObservableTest.java index 46dad13f44..66551d7d21 100644 --- a/src/test/java/io/reactivex/internal/operators/CachedObservableTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/CachedObservableTest.java @@ -38,7 +38,7 @@ public void testColdReplayNoBackpressure() { assertFalse("Source is connected!", source.isConnected()); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); source.subscribe(ts); @@ -60,7 +60,7 @@ public void testColdReplayBackpressure() { assertFalse("Source is connected!", source.isConnected()); - TestSubscriber ts = new TestSubscriber((Long)null); + TestSubscriber ts = new TestSubscriber<>((Long) null); ts.request(10); source.subscribe(ts); @@ -89,15 +89,11 @@ public void testCache() throws InterruptedException { @Override public void subscribe(final Subscriber observer) { observer.onSubscribe(EmptySubscription.INSTANCE); - new Thread(new Runnable() { - - @Override - public void run() { - counter.incrementAndGet(); - System.out.println("published observable being executed"); - observer.onNext("one"); - observer.onComplete(); - } + new Thread(() -> { + counter.incrementAndGet(); + System.out.println("published observable being executed"); + observer.onNext("one"); + observer.onComplete(); }).start(); } }).cache(); @@ -106,23 +102,17 @@ public void run() { final CountDownLatch latch = new CountDownLatch(2); // subscribe once - o.subscribe(new Consumer() { - @Override - public void accept(String v) { - assertEquals("one", v); - System.out.println("v: " + v); - latch.countDown(); - } + o.subscribe(v -> { + assertEquals("one", v); + System.out.println("v: " + v); + latch.countDown(); }); // subscribe again - o.subscribe(new Consumer() { - @Override - public void accept(String v) { - assertEquals("one", v); - System.out.println("v: " + v); - latch.countDown(); - } + o.subscribe(v -> { + assertEquals("one", v); + System.out.println("v: " + v); + latch.countDown(); }); if (!latch.await(1000, TimeUnit.MILLISECONDS)) { @@ -143,7 +133,7 @@ public void testUnsubscribeSource() { @Test public void testTake() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); CachedObservable cached = CachedObservable.from(Observable.range(1, 100)); cached.take(10).subscribe(ts); @@ -159,7 +149,7 @@ public void testTake() { public void testAsync() { Observable source = Observable.range(1, 10000); for (int i = 0; i < 100; i++) { - TestSubscriber ts1 = new TestSubscriber(); + TestSubscriber ts1 = new TestSubscriber<>(); CachedObservable cached = CachedObservable.from(source); @@ -170,7 +160,7 @@ public void testAsync() { ts1.assertComplete(); assertEquals(10000, ts1.values().size()); - TestSubscriber ts2 = new TestSubscriber(); + TestSubscriber ts2 = new TestSubscriber<>(); cached.observeOn(Schedulers.computation()).subscribe(ts2); ts2.awaitTerminalEvent(2, TimeUnit.SECONDS); @@ -188,14 +178,14 @@ public void testAsyncComeAndGo() { Observable output = cached.observeOn(Schedulers.computation()); - List> list = new ArrayList>(100); + List> list = new ArrayList<>(100); for (int i = 0; i < 100; i++) { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); list.add(ts); output.skip(i * 10).take(10).subscribe(ts); } - List expected = new ArrayList(); + List expected = new ArrayList<>(); for (int i = 0; i < 10; i++) { expected.add((long)(i - 10)); } @@ -229,7 +219,7 @@ public void subscribe(Subscriber t) { } }); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); firehose.cache().observeOn(Schedulers.computation()).takeLast(100).subscribe(ts); ts.awaitTerminalEvent(3, TimeUnit.SECONDS); @@ -242,18 +232,18 @@ public void subscribe(Subscriber t) { @Test public void testValuesAndThenError() { Observable source = Observable.range(1, 10) - .concatWith(Observable.error(new TestException())) + .concatWith(Observable.error(new TestException())) .cache(); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); source.subscribe(ts); ts.assertValues(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); ts.assertNotComplete(); ts.assertError(TestException.class); - TestSubscriber ts2 = new TestSubscriber(); + TestSubscriber ts2 = new TestSubscriber<>(); source.subscribe(ts2); ts2.assertValues(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); @@ -266,12 +256,7 @@ public void unsafeChildThrows() { final AtomicInteger count = new AtomicInteger(); Observable source = Observable.range(1, 100) - .doOnNext(new Consumer() { - @Override - public void accept(Integer t) { - count.getAndIncrement(); - } - }) + .doOnNext(t -> count.getAndIncrement()) .cache(); TestSubscriber ts = new TestSubscriber() { diff --git a/src/test/java/io/reactivex/internal/operators/NotificationLiteTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/NotificationLiteTest.java similarity index 100% rename from src/test/java/io/reactivex/internal/operators/NotificationLiteTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/NotificationLiteTest.java diff --git a/src/test/java/io/reactivex/internal/operators/OnSubscribeAmbTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OnSubscribeAmbTest.java similarity index 87% rename from src/test/java/io/reactivex/internal/operators/OnSubscribeAmbTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OnSubscribeAmbTest.java index 71195544e7..6e63c487d1 100644 --- a/src/test/java/io/reactivex/internal/operators/OnSubscribeAmbTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OnSubscribeAmbTest.java @@ -64,24 +64,16 @@ public void cancel() { long delay = interval; for (final String value : values) { - parentSubscription.add(innerScheduler.schedule(new Runnable() { - @Override - public void run() { - subscriber.onNext(value); - } - } - , delay, TimeUnit.MILLISECONDS)); + parentSubscription.add(innerScheduler.schedule(() -> subscriber.onNext(value) + , delay, TimeUnit.MILLISECONDS)); delay += interval; } - parentSubscription.add(innerScheduler.schedule(new Runnable() { - @Override - public void run() { - if (e == null) { - subscriber.onComplete(); - } else { - subscriber.onError(e); - } - } + parentSubscription.add(innerScheduler.schedule(() -> { + if (e == null) { + subscriber.onComplete(); + } else { + subscriber.onError(e); + } }, delay, TimeUnit.MILLISECONDS)); } }); @@ -171,7 +163,7 @@ public void testAmb3() { @SuppressWarnings("unchecked") @Test public void testProducerRequestThroughAmb() { - TestSubscriber ts = new TestSubscriber((Long)null); + TestSubscriber ts = new TestSubscriber<>((Long) null); ts.request(3); final AtomicLong requested1 = new AtomicLong(); final AtomicLong requested2 = new AtomicLong(); @@ -222,7 +214,7 @@ public void cancel() { @Test public void testBackpressure() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.range(0, Observable.bufferSize() * 2) .ambWith(Observable.range(0, Observable.bufferSize() * 2)) .observeOn(Schedulers.computation()) // observeOn has a backpressured RxRingBuffer @@ -239,12 +231,7 @@ public void testBackpressure() { @Test public void testSubscriptionOnlyHappensOnce() throws InterruptedException { final AtomicLong count = new AtomicLong(); - Consumer incrementer = new Consumer() { - @Override - public void accept(Subscription s) { - count.incrementAndGet(); - } - }; + Consumer incrementer = s -> count.incrementAndGet(); //this aync stream should emit first Observable o1 = Observable.just(1).doOnSubscribe(incrementer) @@ -252,7 +239,7 @@ public void accept(Subscription s) { //this stream emits second Observable o2 = Observable.just(1).doOnSubscribe(incrementer) .delay(100, TimeUnit.MILLISECONDS).subscribeOn(Schedulers.computation()); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.amb(o1, o2).subscribe(ts); ts.request(1); ts.awaitTerminalEvent(5, TimeUnit.SECONDS); @@ -269,7 +256,7 @@ public void testSecondaryRequestsPropagatedToChildren() throws InterruptedExcept //this stream emits second Observable o2 = Observable.fromArray(4, 5, 6) .delay(200, TimeUnit.MILLISECONDS).subscribeOn(Schedulers.computation()); - TestSubscriber ts = new TestSubscriber(1L); + TestSubscriber ts = new TestSubscriber<>(1L); Observable.amb(o1, o2).subscribe(ts); // before first emission request 20 more @@ -287,15 +274,12 @@ public void testSynchronousSources() { // then second observable does not get subscribed to before first // subscription completes hence first observable emits result through // amb - int result = Observable.just(1).doOnNext(new Consumer() { - @Override - public void accept(Integer t) { - try { - Thread.sleep(100); - } catch (InterruptedException e) { - // - } - } + int result = Observable.just(1).doOnNext(t -> { + try { + Thread.sleep(100); + } catch (InterruptedException e) { + // + } }).ambWith(Observable.just(2)).toBlocking().single(); assertEquals(1, result); } @@ -307,7 +291,7 @@ public void testAmbCancelsOthers() { PublishSubject source2 = PublishSubject.create(); PublishSubject source3 = PublishSubject.create(); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.amb(source1, source2, source3).subscribe(ts); diff --git a/src/test/java/io/reactivex/internal/operators/OnSubscribeCombineLatestTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OnSubscribeCombineLatestTest.java similarity index 98% rename from src/test/java/io/reactivex/internal/operators/OnSubscribeCombineLatestTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OnSubscribeCombineLatestTest.java index c9ab0bd385..d2694f8840 100644 --- a/src/test/java/io/reactivex/internal/operators/OnSubscribeCombineLatestTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OnSubscribeCombineLatestTest.java @@ -437,8 +437,8 @@ public List apply(Object[] args) { }; for (int i = 1; i <= n; i++) { System.out.println("test1ToNSources: " + i + " sources"); - List> sources = new ArrayList>(); - List values = new ArrayList(); + List> sources = new ArrayList<>(); + List values = new ArrayList<>(); for (int j = 0; j < i; j++) { sources.add(Observable.just(j)); values.add(j); @@ -468,8 +468,8 @@ public List apply(Object[] args) { }; for (int i = 1; i <= n; i++) { System.out.println("test1ToNSourcesScheduled: " + i + " sources"); - List> sources = new ArrayList>(); - List values = new ArrayList(); + List> sources = new ArrayList<>(); + List values = new ArrayList<>(); for (int j = 0; j < i; j++) { sources.add(Observable.just(j).subscribeOn(Schedulers.io())); values.add(j); @@ -749,7 +749,7 @@ public void testBackpressure() { BiFunction combineLatestFunction = getConcatStringIntegerCombineLatestFunction(); int NUM = Observable.bufferSize() * 4; - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.combineLatest( Observable.just("one", "two"), Observable.range(2, NUM), @@ -784,7 +784,7 @@ public void accept(Try> n) { } }).take(SIZE); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.combineLatest(timer, Observable. never(), new BiFunction() { @Override diff --git a/src/test/java/io/reactivex/internal/operators/OnSubscribeDeferTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OnSubscribeDeferTest.java similarity index 100% rename from src/test/java/io/reactivex/internal/operators/OnSubscribeDeferTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OnSubscribeDeferTest.java diff --git a/src/test/java/io/reactivex/internal/operators/OnSubscribeFromIterableTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OnSubscribeFromIterableTest.java similarity index 73% rename from src/test/java/io/reactivex/internal/operators/OnSubscribeFromIterableTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OnSubscribeFromIterableTest.java index 443bab026e..539e9c322a 100644 --- a/src/test/java/io/reactivex/internal/operators/OnSubscribeFromIterableTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OnSubscribeFromIterableTest.java @@ -58,31 +58,22 @@ public void testListIterable() { */ @Test public void testRawIterable() { - Iterable it = new Iterable() { + Iterable it = () -> new Iterator() { + int i = 0; @Override - public Iterator iterator() { - return new Iterator() { - - int i = 0; - - @Override - public boolean hasNext() { - return i < 3; - } - - @Override - public String next() { - return String.valueOf(++i); - } - - @Override - public void remove() { - } + public boolean hasNext() { + return i < 3; + } - }; + @Override + public String next() { + return String.valueOf(++i); } + @Override + public void remove() { + } }; Observable observable = Observable.fromIterable(it); @@ -114,13 +105,13 @@ public void testObservableFromIterable() { @Test public void testBackpressureViaRequest() { - ArrayList list = new ArrayList(Observable.bufferSize()); + ArrayList list = new ArrayList<>(Observable.bufferSize()); for (int i = 1; i <= Observable.bufferSize() + 1; i++) { list.add(i); } Observable o = Observable.fromIterable(list); - TestSubscriber ts = new TestSubscriber((Long)null); + TestSubscriber ts = new TestSubscriber<>((Long) null); ts.assertNoValues(); ts.request(1); @@ -140,7 +131,7 @@ public void testBackpressureViaRequest() { public void testNoBackpressure() { Observable o = Observable.fromIterable(Arrays.asList(1, 2, 3, 4, 5)); - TestSubscriber ts = new TestSubscriber((Long)null); + TestSubscriber ts = new TestSubscriber<>((Long) null); ts.assertNoValues(); ts.request(Long.MAX_VALUE); // infinite @@ -156,7 +147,7 @@ public void testSubscribeMultipleTimes() { Observable o = Observable.fromIterable(Arrays.asList(1, 2, 3)); for (int i = 0; i < 10; i++) { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); o.subscribe(ts); @@ -231,34 +222,26 @@ public void onNext(Object t) { @Test public void testDoesNotCallIteratorHasNextMoreThanRequiredWithBackpressure() { final AtomicBoolean called = new AtomicBoolean(false); - Iterable iterable = new Iterable() { + Iterable iterable = () -> new Iterator() { + int count = 1; + + @Override + public void remove() { + // ignore + } @Override - public Iterator iterator() { - return new Iterator() { - - int count = 1; - - @Override - public void remove() { - // ignore - } - - @Override - public boolean hasNext() { - if (count > 1) { - called.set(true); - return false; - } else - return true; - } - - @Override - public Integer next() { - return count++; - } - - }; + public boolean hasNext() { + if (count > 1) { + called.set(true); + return false; + } else + return true; + } + + @Override + public Integer next() { + return count++; } }; Observable.fromIterable(iterable).take(1).subscribe(); @@ -268,34 +251,26 @@ public Integer next() { @Test public void testDoesNotCallIteratorHasNextMoreThanRequiredFastPath() { final AtomicBoolean called = new AtomicBoolean(false); - Iterable iterable = new Iterable() { + Iterable iterable = () -> new Iterator() { + int count = 1; + + @Override + public void remove() { + // ignore + } + + @Override + public boolean hasNext() { + if (count > 1) { + called.set(true); + return false; + } else + return true; + } @Override - public Iterator iterator() { - return new Iterator() { - - @Override - public void remove() { - // ignore - } - - int count = 1; - - @Override - public boolean hasNext() { - if (count > 1) { - called.set(true); - return false; - } else - return true; - } - - @Override - public Integer next() { - return count++; - } - - }; + public Integer next() { + return count++; } }; Observable.fromIterable(iterable).subscribe(new Observer() { diff --git a/src/test/java/io/reactivex/internal/operators/OnSubscribeRangeTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OnSubscribeRangeTest.java similarity index 87% rename from src/test/java/io/reactivex/internal/operators/OnSubscribeRangeTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OnSubscribeRangeTest.java index 817f1521b3..c2973e1bee 100644 --- a/src/test/java/io/reactivex/internal/operators/OnSubscribeRangeTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OnSubscribeRangeTest.java @@ -50,12 +50,7 @@ public void testRangeUnsubscribe() { final AtomicInteger count = new AtomicInteger(); - Observable.range(1, 1000).doOnNext(new Consumer() { - @Override - public void accept(Integer t1) { - count.incrementAndGet(); - } - }) + Observable.range(1, 1000).doOnNext(t1 -> count.incrementAndGet()) .take(3).subscribe(observer); verify(observer, times(1)).onNext(1); @@ -96,7 +91,7 @@ public void testRangeWithOverflow5() { public void testBackpressureViaRequest() { Observable o = Observable.range(1, Observable.bufferSize()); - TestSubscriber ts = new TestSubscriber((Long)null); + TestSubscriber ts = new TestSubscriber<>((Long) null); ts.assertNoValues(); ts.request(1); @@ -117,14 +112,14 @@ public void testBackpressureViaRequest() { @Test public void testNoBackpressure() { - ArrayList list = new ArrayList(Observable.bufferSize() * 2); + ArrayList list = new ArrayList<>(Observable.bufferSize() * 2); for (int i = 1; i <= Observable.bufferSize() * 2 + 1; i++) { list.add(i); } Observable o = Observable.range(1, list.size()); - TestSubscriber ts = new TestSubscriber((Long)null); + TestSubscriber ts = new TestSubscriber<>((Long) null); ts.assertNoValues(); ts.request(Long.MAX_VALUE); // infinite @@ -137,11 +132,11 @@ public void testNoBackpressure() { void testWithBackpressureOneByOne(int start) { Observable source = Observable.range(start, 100); - TestSubscriber ts = new TestSubscriber((Long)null); + TestSubscriber ts = new TestSubscriber<>((Long) null); ts.request(1); source.subscribe(ts); - List list = new ArrayList(100); + List list = new ArrayList<>(100); for (int i = 0; i < 100; i++) { list.add(i + start); ts.request(1); @@ -152,11 +147,11 @@ void testWithBackpressureOneByOne(int start) { void testWithBackpressureAllAtOnce(int start) { Observable source = Observable.range(start, 100); - TestSubscriber ts = new TestSubscriber((Long)null); + TestSubscriber ts = new TestSubscriber<>((Long) null); ts.request(100); source.subscribe(ts); - List list = new ArrayList(100); + List list = new ArrayList<>(100); for (int i = 0; i < 100; i++) { list.add(i + start); } @@ -179,11 +174,11 @@ public void testWithBackpressureAllAtOnce() { public void testWithBackpressureRequestWayMore() { Observable source = Observable.range(50, 100); - TestSubscriber ts = new TestSubscriber((Long)null); + TestSubscriber ts = new TestSubscriber<>((Long) null); ts.request(150); source.subscribe(ts); - List list = new ArrayList(100); + List list = new ArrayList<>(100); for (int i = 0; i < 100; i++) { list.add(i + 50); } @@ -252,7 +247,7 @@ public void onNext(Integer t) { @Test(timeout = 1000) public void testNearMaxValueWithoutBackpressure() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.range(Integer.MAX_VALUE - 1, 2).subscribe(ts); ts.assertComplete(); @@ -261,7 +256,7 @@ public void testNearMaxValueWithoutBackpressure() { } @Test(timeout = 1000) public void testNearMaxValueWithBackpressure() { - TestSubscriber ts = new TestSubscriber(3L); + TestSubscriber ts = new TestSubscriber<>(3L); Observable.range(Integer.MAX_VALUE - 1, 2).subscribe(ts); ts.assertComplete(); diff --git a/src/test/java/io/reactivex/internal/operators/OnSubscribeRefCountTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OnSubscribeRefCountTest.java similarity index 97% rename from src/test/java/io/reactivex/internal/operators/OnSubscribeRefCountTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OnSubscribeRefCountTest.java index 1c1c46abd5..5f7451c821 100644 --- a/src/test/java/io/reactivex/internal/operators/OnSubscribeRefCountTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OnSubscribeRefCountTest.java @@ -182,8 +182,8 @@ public void run() { .publish().refCount(); for (int i = 0; i < 10; i++) { - TestSubscriber ts1 = new TestSubscriber(); - TestSubscriber ts2 = new TestSubscriber(); + TestSubscriber ts1 = new TestSubscriber<>(); + TestSubscriber ts2 = new TestSubscriber<>(); r.subscribe(ts1); r.subscribe(ts2); try { @@ -225,7 +225,7 @@ public void run() { } }); - TestSubscriber s = new TestSubscriber(); + TestSubscriber s = new TestSubscriber<>(); o.publish().refCount().subscribeOn(Schedulers.newThread()).subscribe(s); System.out.println("send unsubscribe"); // wait until connected @@ -270,7 +270,7 @@ public void accept(Subscription s) { } }); - TestSubscriber s = new TestSubscriber(); + TestSubscriber s = new TestSubscriber<>(); o.publish().refCount().subscribeOn(Schedulers.computation()).subscribe(s); System.out.println("send unsubscribe"); @@ -363,7 +363,7 @@ public void testRefCount() { Observable interval = Observable.interval(100, TimeUnit.MILLISECONDS, s).publish().refCount(); // subscribe list1 - final List list1 = new ArrayList(); + final List list1 = new ArrayList<>(); Disposable s1 = interval.subscribe(new Consumer() { @Override public void accept(Long t1) { @@ -378,7 +378,7 @@ public void accept(Long t1) { assertEquals(1L, list1.get(1).longValue()); // subscribe list2 - final List list2 = new ArrayList(); + final List list2 = new ArrayList<>(); Disposable s2 = interval.subscribe(new Consumer() { @Override public void accept(Long t1) { @@ -423,7 +423,7 @@ public void accept(Long t1) { // subscribing a new one should start over because the source should have been unsubscribed // subscribe list3 - final List list3 = new ArrayList(); + final List list3 = new ArrayList<>(); interval.subscribe(new Consumer() { @Override public void accept(Long t1) { @@ -494,8 +494,8 @@ public Integer apply(Integer t1, Integer t2) { }) .publish().refCount(); - TestSubscriber ts1 = new TestSubscriber(); - TestSubscriber ts2 = new TestSubscriber(); + TestSubscriber ts1 = new TestSubscriber<>(); + TestSubscriber ts2 = new TestSubscriber<>(); combined.subscribe(ts1); combined.subscribe(ts2); diff --git a/src/test/java/io/reactivex/internal/operators/OnSubscribeTimerTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OnSubscribeTimerTest.java similarity index 93% rename from src/test/java/io/reactivex/internal/operators/OnSubscribeTimerTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OnSubscribeTimerTest.java index d069f7fa79..106c4cc378 100644 --- a/src/test/java/io/reactivex/internal/operators/OnSubscribeTimerTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OnSubscribeTimerTest.java @@ -57,7 +57,7 @@ public void testTimerOnce() { @Test public void testTimerPeriodically() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.interval(100, 100, TimeUnit.MILLISECONDS, scheduler).subscribe(ts); @@ -84,7 +84,7 @@ public void testTimerPeriodically() { @Test public void testInterval() { Observable w = Observable.interval(1, TimeUnit.SECONDS, scheduler); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); w.subscribe(ts); ts.assertNoValues(); @@ -109,8 +109,8 @@ public void testInterval() { public void testWithMultipleSubscribersStartingAtSameTime() { Observable w = Observable.interval(1, TimeUnit.SECONDS, scheduler); - TestSubscriber ts1 = new TestSubscriber(); - TestSubscriber ts2 = new TestSubscriber(); + TestSubscriber ts1 = new TestSubscriber<>(); + TestSubscriber ts2 = new TestSubscriber<>(); w.subscribe(ts1); w.subscribe(ts2); @@ -146,7 +146,7 @@ public void testWithMultipleSubscribersStartingAtSameTime() { public void testWithMultipleStaggeredSubscribers() { Observable w = Observable.interval(1, TimeUnit.SECONDS, scheduler); - TestSubscriber ts1 = new TestSubscriber(); + TestSubscriber ts1 = new TestSubscriber<>(); w.subscribe(ts1); @@ -154,7 +154,7 @@ public void testWithMultipleStaggeredSubscribers() { scheduler.advanceTimeTo(2, TimeUnit.SECONDS); - TestSubscriber ts2 = new TestSubscriber(); + TestSubscriber ts2 = new TestSubscriber<>(); w.subscribe(ts2); @@ -186,7 +186,7 @@ public void testWithMultipleStaggeredSubscribers() { public void testWithMultipleStaggeredSubscribersAndPublish() { ConnectableObservable w = Observable.interval(1, TimeUnit.SECONDS, scheduler).publish(); - TestSubscriber ts1 = new TestSubscriber(); + TestSubscriber ts1 = new TestSubscriber<>(); w.subscribe(ts1); w.connect(); @@ -195,7 +195,7 @@ public void testWithMultipleStaggeredSubscribersAndPublish() { scheduler.advanceTimeTo(2, TimeUnit.SECONDS); - TestSubscriber ts2 = new TestSubscriber(); + TestSubscriber ts2 = new TestSubscriber<>(); w.subscribe(ts2); ts1.assertValues(0L, 1L); diff --git a/src/test/java/io/reactivex/internal/operators/OnSubscribeToObservableFutureTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OnSubscribeToObservableFutureTest.java similarity index 94% rename from src/test/java/io/reactivex/internal/operators/OnSubscribeToObservableFutureTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OnSubscribeToObservableFutureTest.java index 35cc0062e4..f3ee711d98 100644 --- a/src/test/java/io/reactivex/internal/operators/OnSubscribeToObservableFutureTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OnSubscribeToObservableFutureTest.java @@ -37,7 +37,7 @@ public void testSuccess() throws Exception { Subscriber o = TestHelper.mockSubscriber(); - TestSubscriber ts = new TestSubscriber(o); + TestSubscriber ts = new TestSubscriber<>(o); Observable.fromFuture(future).subscribe(ts); @@ -58,7 +58,7 @@ public void testFailure() throws Exception { Subscriber o = TestHelper.mockSubscriber(); - TestSubscriber ts = new TestSubscriber(o); + TestSubscriber ts = new TestSubscriber<>(o); Observable.fromFuture(future).subscribe(ts); @@ -79,7 +79,7 @@ public void testCancelledBeforeSubscribe() throws Exception { Subscriber o = TestHelper.mockSubscriber(); - TestSubscriber ts = new TestSubscriber(o); + TestSubscriber ts = new TestSubscriber<>(o); ts.dispose(); Observable.fromFuture(future).subscribe(ts); @@ -125,7 +125,7 @@ public Object get(long timeout, TimeUnit unit) throws InterruptedException, Exec Subscriber o = TestHelper.mockSubscriber(); - TestSubscriber ts = new TestSubscriber(o); + TestSubscriber ts = new TestSubscriber<>(o); Observable futureObservable = Observable.fromFuture(future); futureObservable.subscribeOn(Schedulers.computation()).subscribe(ts); diff --git a/src/test/java/io/reactivex/internal/operators/OnSubscribeUsingTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OnSubscribeUsingTest.java similarity index 98% rename from src/test/java/io/reactivex/internal/operators/OnSubscribeUsingTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OnSubscribeUsingTest.java index abb3c21fab..1a127d6382 100644 --- a/src/test/java/io/reactivex/internal/operators/OnSubscribeUsingTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OnSubscribeUsingTest.java @@ -276,7 +276,7 @@ public void subscribe(Subscriber t1) { @Test public void testUsingDisposesEagerlyBeforeCompletion() { - final List events = new ArrayList(); + final List events = new ArrayList<>(); Supplier resourceFactory = createResourceFactory(events); final Runnable completion = createOnCompletedAction(events); final Runnable unsub =createUnsubAction(events); @@ -303,7 +303,7 @@ public Observable apply(Resource resource) { @Test public void testUsingDoesNotDisposesEagerlyBeforeCompletion() { - final List events = new ArrayList(); + final List events = new ArrayList<>(); Supplier resourceFactory = createResourceFactory(events); final Runnable completion = createOnCompletedAction(events); final Runnable unsub = createUnsubAction(events); @@ -332,7 +332,7 @@ public Observable apply(Resource resource) { @Test public void testUsingDisposesEagerlyBeforeError() { - final List events = new ArrayList(); + final List events = new ArrayList<>(); Supplier resourceFactory = createResourceFactory(events); final Consumer onError = createOnErrorAction(events); final Runnable unsub = createUnsubAction(events); @@ -360,7 +360,7 @@ public Observable apply(Resource resource) { @Test public void testUsingDoesNotDisposesEagerlyBeforeError() { - final List events = new ArrayList(); + final List events = new ArrayList<>(); final Supplier resourceFactory = createResourceFactory(events); final Consumer onError = createOnErrorAction(events); final Runnable unsub = createUnsubAction(events); diff --git a/src/test/java/io/reactivex/internal/operators/OperatorAllTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorAllTest.java similarity index 92% rename from src/test/java/io/reactivex/internal/operators/OperatorAllTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorAllTest.java index 50daa68cbd..de156b4459 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorAllTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorAllTest.java @@ -42,7 +42,7 @@ public boolean test(String s) { }) .subscribe(observer); - verify(observer).onSubscribe((Subscription)any()); + verify(observer).onSubscribe(any()); verify(observer).onNext(true); verify(observer).onComplete(); verifyNoMoreInteractions(observer); @@ -62,7 +62,7 @@ public boolean test(String s) { }) .subscribe(observer); - verify(observer).onSubscribe((Subscription)any()); + verify(observer).onSubscribe(any()); verify(observer).onNext(false); verify(observer).onComplete(); verifyNoMoreInteractions(observer); @@ -82,7 +82,7 @@ public boolean test(String s) { }) .subscribe(observer); - verify(observer).onSubscribe((Subscription)any()); + verify(observer).onSubscribe(any()); verify(observer).onNext(true); verify(observer).onComplete(); verifyNoMoreInteractions(observer); @@ -103,7 +103,7 @@ public boolean test(String s) { }) .subscribe(observer); - verify(observer).onSubscribe((Subscription)any()); + verify(observer).onSubscribe(any()); verify(observer).onError(error); verifyNoMoreInteractions(observer); } @@ -141,7 +141,7 @@ public Publisher apply(Boolean t1) { @Test public void testBackpressureIfNoneRequestedNoneShouldBeDelivered() { - TestSubscriber ts = new TestSubscriber((Long)null); + TestSubscriber ts = new TestSubscriber<>((Long) null); Observable.empty().all(new Predicate() { @Override public boolean test(Object t1) { @@ -156,7 +156,7 @@ public boolean test(Object t1) { @Test public void testBackpressureIfOneRequestedOneShouldBeDelivered() { - TestSubscriber ts = new TestSubscriber(1L); + TestSubscriber ts = new TestSubscriber<>(1L); Observable.empty().all(new Predicate() { @Override @@ -174,7 +174,7 @@ public boolean test(Object t) { @Test public void testPredicateThrowsExceptionAndValueInCauseMessage() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); final IllegalArgumentException ex = new IllegalArgumentException(); diff --git a/src/test/java/io/reactivex/internal/operators/OperatorAnyTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorAnyTest.java similarity index 97% rename from src/test/java/io/reactivex/internal/operators/OperatorAnyTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorAnyTest.java index 8172f579f2..193e1d5168 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorAnyTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorAnyTest.java @@ -240,7 +240,7 @@ public Publisher apply(Boolean t1) { @Test public void testBackpressureIfNoneRequestedNoneShouldBeDelivered() { - TestSubscriber ts = new TestSubscriber((Long)null); + TestSubscriber ts = new TestSubscriber<>((Long) null); Observable.just(1).any(new Predicate() { @Override @@ -257,7 +257,7 @@ public boolean test(Integer t) { @Test public void testBackpressureIfOneRequestedOneShouldBeDelivered() { - TestSubscriber ts = new TestSubscriber(1L); + TestSubscriber ts = new TestSubscriber<>(1L); Observable.just(1).any(new Predicate() { @Override public boolean test(Integer v) { @@ -273,7 +273,7 @@ public boolean test(Integer v) { @Test public void testPredicateThrowsExceptionAndValueInCauseMessage() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); final IllegalArgumentException ex = new IllegalArgumentException(); Observable.just("Boo!").any(new Predicate() { diff --git a/src/test/java/io/reactivex/internal/operators/OperatorAsObservableTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorAsObservableTest.java similarity index 100% rename from src/test/java/io/reactivex/internal/operators/OperatorAsObservableTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorAsObservableTest.java diff --git a/src/test/java/io/reactivex/internal/operators/OperatorBufferTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorBufferTest.java similarity index 98% rename from src/test/java/io/reactivex/internal/operators/OperatorBufferTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorBufferTest.java index 79cbd9ea14..db1c04202e 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorBufferTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorBufferTest.java @@ -312,7 +312,7 @@ public void accept(List t1) { } private List list(String... args) { - List list = new ArrayList(); + List list = new ArrayList<>(); for (String arg : args) { list.add(arg); } @@ -342,7 +342,7 @@ public void testBufferStopsWhenUnsubscribed1() { Observable source = Observable.never(); Subscriber> o = TestHelper.mockSubscriber(); - TestSubscriber> ts = new TestSubscriber>(o, (Long)null); + TestSubscriber> ts = new TestSubscriber<>(o, null); source.buffer(100, 200, TimeUnit.MILLISECONDS, scheduler) .doOnNext(new Consumer>() { @@ -762,7 +762,7 @@ public Observable apply(Integer t1) { @Test public void testProducerRequestThroughBufferWithSize1() { - TestSubscriber> ts = new TestSubscriber>(3L); + TestSubscriber> ts = new TestSubscriber<>(3L); final AtomicLong requested = new AtomicLong(); Observable.create(new Publisher() { @@ -793,7 +793,7 @@ public void cancel() { @Test public void testProducerRequestThroughBufferWithSize2() { - TestSubscriber> ts = new TestSubscriber>(); + TestSubscriber> ts = new TestSubscriber<>(); final AtomicLong requested = new AtomicLong(); Observable.create(new Publisher() { @@ -821,7 +821,7 @@ public void cancel() { @Test public void testProducerRequestThroughBufferWithSize3() { - TestSubscriber> ts = new TestSubscriber>(3L); + TestSubscriber> ts = new TestSubscriber<>(3L); final AtomicLong requested = new AtomicLong(); Observable.create(new Publisher() { @@ -850,7 +850,7 @@ public void cancel() { @Test public void testProducerRequestThroughBufferWithSize4() { - TestSubscriber> ts = new TestSubscriber>(); + TestSubscriber> ts = new TestSubscriber<>(); final AtomicLong requested = new AtomicLong(); Observable.create(new Publisher() { @@ -878,7 +878,7 @@ public void cancel() { @Test public void testProducerRequestOverflowThroughBufferWithSize1() { - TestSubscriber> ts = new TestSubscriber>(Long.MAX_VALUE >> 1); + TestSubscriber> ts = new TestSubscriber<>(Long.MAX_VALUE >> 1); final AtomicLong requested = new AtomicLong(); @@ -907,7 +907,7 @@ public void cancel() { @Test public void testProducerRequestOverflowThroughBufferWithSize2() { - TestSubscriber> ts = new TestSubscriber>(Long.MAX_VALUE >> 1); + TestSubscriber> ts = new TestSubscriber<>(Long.MAX_VALUE >> 1); final AtomicLong requested = new AtomicLong(); diff --git a/src/test/java/io/reactivex/internal/operators/OperatorCastTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorCastTest.java similarity index 100% rename from src/test/java/io/reactivex/internal/operators/OperatorCastTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorCastTest.java diff --git a/src/test/java/io/reactivex/internal/operators/OperatorConcatTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorConcatTest.java similarity index 81% rename from src/test/java/io/reactivex/internal/operators/OperatorConcatTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorConcatTest.java index 605b872241..3830b836fe 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorConcatTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorConcatTest.java @@ -62,7 +62,7 @@ public void testConcatWithList() { final Observable odds = Observable.fromArray(o); final Observable even = Observable.fromArray(e); - final List> list = new ArrayList>(); + final List> list = new ArrayList<>(); list.add(odds); list.add(even); Observable concat = Observable.concat(Observable.fromIterable(list)); @@ -107,8 +107,8 @@ public void subscribe(Subscriber> observer) { public void testSimpleAsyncConcat() { Subscriber observer = TestHelper.mockSubscriber(); - TestObservable o1 = new TestObservable("one", "two", "three"); - TestObservable o2 = new TestObservable("four", "five", "six"); + TestObservable o1 = new TestObservable<>("one", "two", "three"); + TestObservable o2 = new TestObservable<>("four", "five", "six"); Observable.concat(Observable.create(o1), Observable.create(o2)).subscribe(observer); @@ -147,12 +147,12 @@ public void testNestedAsyncConcatLoop() throws Throwable { public void testNestedAsyncConcat() throws InterruptedException { Subscriber observer = TestHelper.mockSubscriber(); - final TestObservable o1 = new TestObservable("one", "two", "three"); - final TestObservable o2 = new TestObservable("four", "five", "six"); - final TestObservable o3 = new TestObservable("seven", "eight", "nine"); + final TestObservable o1 = new TestObservable<>("one", "two", "three"); + final TestObservable o2 = new TestObservable<>("four", "five", "six"); + final TestObservable o3 = new TestObservable<>("seven", "eight", "nine"); final CountDownLatch allowThird = new CountDownLatch(1); - final AtomicReference parent = new AtomicReference(); + final AtomicReference parent = new AtomicReference<>(); final CountDownLatch parentHasStarted = new CountDownLatch(1); final CountDownLatch parentHasFinished = new CountDownLatch(1); @@ -172,40 +172,36 @@ public void cancel() { s.dispose(); } }); - parent.set(new Thread(new Runnable() { + parent.set(new Thread(() -> { + try { + // emit first + if (!s.isDisposed()) { + System.out.println("Emit o1"); + observer.onNext(Observable.create(o1)); + } + // emit second + if (!s.isDisposed()) { + System.out.println("Emit o2"); + observer.onNext(Observable.create(o2)); + } - @Override - public void run() { + // wait until sometime later and emit third try { - // emit first - if (!s.isDisposed()) { - System.out.println("Emit o1"); - observer.onNext(Observable.create(o1)); - } - // emit second - if (!s.isDisposed()) { - System.out.println("Emit o2"); - observer.onNext(Observable.create(o2)); - } - - // wait until sometime later and emit third - try { - allowThird.await(); - } catch (InterruptedException e) { - observer.onError(e); - } - if (!s.isDisposed()) { - System.out.println("Emit o3"); - observer.onNext(Observable.create(o3)); - } - - } catch (Throwable e) { + allowThird.await(); + } catch (InterruptedException e) { observer.onError(e); - } finally { - System.out.println("Done parent Observable"); - observer.onComplete(); - parentHasFinished.countDown(); } + if (!s.isDisposed()) { + System.out.println("Emit o3"); + observer.onNext(Observable.create(o3)); + } + + } catch (Throwable e) { + observer.onError(e); + } finally { + System.out.println("Done parent Observable"); + observer.onComplete(); + parentHasFinished.countDown(); } })); parent.get().start(); @@ -281,7 +277,7 @@ public void testBlockedObservableOfObservables() { final CountDownLatch callOnce = new CountDownLatch(1); final CountDownLatch okToContinue = new CountDownLatch(1); @SuppressWarnings("unchecked") - TestObservable> observableOfObservables = new TestObservable>(callOnce, okToContinue, odds, even); + TestObservable> observableOfObservables = new TestObservable<>(callOnce, okToContinue, odds, even); Observable concatF = Observable.concat(Observable.create(observableOfObservables)); concatF.subscribe(observer); try { @@ -313,14 +309,14 @@ public void testBlockedObservableOfObservables() { @Test public void testConcatConcurrentWithInfinity() { - final TestObservable w1 = new TestObservable("one", "two", "three"); + final TestObservable w1 = new TestObservable<>("one", "two", "three"); //This observable will send "hello" MAX_VALUE time. - final TestObservable w2 = new TestObservable("hello", Integer.MAX_VALUE); + final TestObservable w2 = new TestObservable<>("hello", Integer.MAX_VALUE); Subscriber observer = TestHelper.mockSubscriber(); @SuppressWarnings("unchecked") - TestObservable> observableOfObservables = new TestObservable>(Observable.create(w1), Observable.create(w2)); + TestObservable> observableOfObservables = new TestObservable<>(Observable.create(w1), Observable.create(w2)); Observable concatF = Observable.concat(Observable.create(observableOfObservables)); concatF.take(50).subscribe(observer); @@ -348,8 +344,8 @@ public void testConcatNonBlockingObservables() { final CountDownLatch okToContinueW1 = new CountDownLatch(1); final CountDownLatch okToContinueW2 = new CountDownLatch(1); - final TestObservable w1 = new TestObservable(null, okToContinueW1, "one", "two", "three"); - final TestObservable w2 = new TestObservable(null, okToContinueW2, "four", "five", "six"); + final TestObservable w1 = new TestObservable<>(null, okToContinueW1, "one", "two", "three"); + final TestObservable w2 = new TestObservable<>(null, okToContinueW2, "four", "five", "six"); Subscriber observer = TestHelper.mockSubscriber(); @@ -399,11 +395,11 @@ public void subscribe(Subscriber> observer) { public void testConcatUnsubscribe() { final CountDownLatch callOnce = new CountDownLatch(1); final CountDownLatch okToContinue = new CountDownLatch(1); - final TestObservable w1 = new TestObservable("one", "two", "three"); - final TestObservable w2 = new TestObservable(callOnce, okToContinue, "four", "five", "six"); + final TestObservable w1 = new TestObservable<>("one", "two", "three"); + final TestObservable w2 = new TestObservable<>(callOnce, okToContinue, "four", "five", "six"); Subscriber observer = TestHelper.mockSubscriber(); - TestSubscriber ts = new TestSubscriber(observer, null); + TestSubscriber ts = new TestSubscriber<>(observer, null); final Observable concat = Observable.concat(Observable.create(w1), Observable.create(w2)); @@ -441,14 +437,14 @@ public void testConcatUnsubscribe() { public void testConcatUnsubscribeConcurrent() { final CountDownLatch callOnce = new CountDownLatch(1); final CountDownLatch okToContinue = new CountDownLatch(1); - final TestObservable w1 = new TestObservable("one", "two", "three"); - final TestObservable w2 = new TestObservable(callOnce, okToContinue, "four", "five", "six"); + final TestObservable w1 = new TestObservable<>("one", "two", "three"); + final TestObservable w2 = new TestObservable<>(callOnce, okToContinue, "four", "five", "six"); Subscriber observer = TestHelper.mockSubscriber(); - TestSubscriber ts = new TestSubscriber(observer, null); + TestSubscriber ts = new TestSubscriber<>(observer, null); @SuppressWarnings("unchecked") - TestObservable> observableOfObservables = new TestObservable>(Observable.create(w1), Observable.create(w2)); + TestObservable> observableOfObservables = new TestObservable<>(Observable.create(w1), Observable.create(w2)); Observable concatF = Observable.concat(Observable.create(observableOfObservables)); concatF.subscribe(ts); @@ -526,32 +522,27 @@ public TestObservable(T seed, int size) { @Override public void subscribe(final Subscriber observer) { observer.onSubscribe(s); - t = new Thread(new Runnable() { - - @Override - public void run() { - try { - while (count < size && subscribed) { - if (null != values) - observer.onNext(values.get(count)); - else - observer.onNext(seed); - count++; - //Unblock the main thread to call unsubscribe. - if (null != once) - once.countDown(); - //Block until the main thread has called unsubscribe. - if (null != okToContinue) - okToContinue.await(5, TimeUnit.SECONDS); - } - if (subscribed) - observer.onComplete(); - } catch (InterruptedException e) { - e.printStackTrace(); - fail(e.getMessage()); + t = new Thread(() -> { + try { + while (count < size && subscribed) { + if (null != values) + observer.onNext(values.get(count)); + else + observer.onNext(seed); + count++; + //Unblock the main thread to call unsubscribe. + if (null != once) + once.countDown(); + //Block until the main thread has called unsubscribe. + if (null != okToContinue) + okToContinue.await(5, TimeUnit.SECONDS); } + if (subscribed) + observer.onComplete(); + } catch (InterruptedException e) { + e.printStackTrace(); + fail(e.getMessage()); } - }); t.start(); threadHasStarted.countDown(); @@ -609,12 +600,7 @@ public void testMultipleObservers() { @Test public void concatVeryLongObservableOfObservables() { final int n = 10000; - Observable> source = Observable.range(0, n).map(new Function>() { - @Override - public Observable apply(Integer v) { - return Observable.just(v); - } - }); + Observable> source = Observable.range(0, n).map(Observable::just); Observable> result = Observable.concat(source).toList(); @@ -623,7 +609,7 @@ public Observable apply(Integer v) { result.subscribe(o); - List list = new ArrayList(n); + List list = new ArrayList<>(n); for (int i = 0; i < n; i++) { list.add(i); } @@ -634,12 +620,7 @@ public Observable apply(Integer v) { @Test public void concatVeryLongObservableOfObservablesTakeHalf() { final int n = 10000; - Observable> source = Observable.range(0, n).map(new Function>() { - @Override - public Observable apply(Integer v) { - return Observable.just(v); - } - }); + Observable> source = Observable.range(0, n).map(Observable::just); Observable> result = Observable.concat(source).take(n / 2).toList(); @@ -648,7 +629,7 @@ public Observable apply(Integer v) { result.subscribe(o); - List list = new ArrayList(n); + List list = new ArrayList<>(n); for (int i = 0; i < n / 2; i++) { list.add(i); } @@ -668,7 +649,7 @@ public void testConcatOuterBackpressure() { @Test public void testInnerBackpressureWithAlignedBoundaries() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.range(0, Observable.bufferSize() * 2) .concatWith(Observable.range(0, Observable.bufferSize() * 2)) .observeOn(Schedulers.computation()) // observeOn has a backpressured RxRingBuffer @@ -687,7 +668,7 @@ public void testInnerBackpressureWithAlignedBoundaries() { */ @Test public void testInnerBackpressureWithoutAlignedBoundaries() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.range(0, (Observable.bufferSize() * 2) + 10) .concatWith(Observable.range(0, (Observable.bufferSize() * 2) + 10)) .observeOn(Schedulers.computation()) // observeOn has a backpressured RxRingBuffer @@ -713,7 +694,7 @@ public void subscribe(Subscriber s) { }); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.concat(o, o).subscribe(ts); ts.awaitTerminalEvent(500, TimeUnit.MILLISECONDS); ts.assertTerminated(); @@ -726,16 +707,12 @@ public void testIssue2890NoStackoverflow() throws InterruptedException { final ExecutorService executor = Executors.newFixedThreadPool(2); final Scheduler sch = Schedulers.from(executor); - Function> func = new Function>() { - @Override - public Observable apply(Integer t) { - Observable observable = Observable.just(t) - .subscribeOn(sch) - ; - Subject subject = UnicastSubject.create(); - observable.subscribe(subject); - return subject; - } + Function> func = t -> { + Observable observable = Observable.just(t) + .subscribeOn(sch); + Subject subject = UnicastSubject.create(); + observable.subscribe(subject); + return subject; }; int n = 5000; @@ -808,14 +785,9 @@ public void concatMapRangeAsyncLoopIssue2876() { if (i % 1000 == 0) { System.out.println("concatMapRangeAsyncLoop > " + i); } - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.range(0, 1000) - .concatMap(new Function>() { - @Override - public Observable apply(Integer t) { - return Observable.fromIterable(Arrays.asList(t)); - } - }) + .concatMap(t -> Observable.fromIterable(Arrays.asList(t))) .observeOn(Schedulers.computation()).subscribe(ts); ts.awaitTerminalEvent(2500, TimeUnit.MILLISECONDS); diff --git a/src/test/java/io/reactivex/internal/operators/OperatorDebounceTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorDebounceTest.java similarity index 85% rename from src/test/java/io/reactivex/internal/operators/OperatorDebounceTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorDebounceTest.java index 4491ab8aac..4ba7c4144b 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorDebounceTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorDebounceTest.java @@ -126,43 +126,22 @@ public void subscribe(Subscriber observer) { } private void publishCompleted(final Subscriber observer, long delay) { - innerScheduler.schedule(new Runnable() { - @Override - public void run() { - observer.onComplete(); - } - }, delay, TimeUnit.MILLISECONDS); + innerScheduler.schedule(observer::onComplete, delay, TimeUnit.MILLISECONDS); } private void publishError(final Subscriber observer, long delay, final Exception error) { - innerScheduler.schedule(new Runnable() { - @Override - public void run() { - observer.onError(error); - } - }, delay, TimeUnit.MILLISECONDS); + innerScheduler.schedule(() -> observer.onError(error), delay, TimeUnit.MILLISECONDS); } private void publishNext(final Subscriber observer, final long delay, final T value) { - innerScheduler.schedule(new Runnable() { - @Override - public void run() { - observer.onNext(value); - } - }, delay, TimeUnit.MILLISECONDS); + innerScheduler.schedule(() -> observer.onNext(value), delay, TimeUnit.MILLISECONDS); } @Test public void debounceSelectorNormal1() { PublishSubject source = PublishSubject.create(); final PublishSubject debouncer = PublishSubject.create(); - Function> debounceSel = new Function>() { - - @Override - public Observable apply(Integer t1) { - return debouncer; - } - }; + Function> debounceSel = t1 -> debouncer; Subscriber o = TestHelper.mockSubscriber(); InOrder inOrder = inOrder(o); @@ -192,12 +171,8 @@ public Observable apply(Integer t1) { @Test public void debounceSelectorFuncThrows() { PublishSubject source = PublishSubject.create(); - Function> debounceSel = new Function>() { - - @Override - public Observable apply(Integer t1) { - throw new TestException(); - } + Function> debounceSel = t1 -> { + throw new TestException(); }; Subscriber o = TestHelper.mockSubscriber(); @@ -214,13 +189,7 @@ public Observable apply(Integer t1) { @Test public void debounceSelectorObservableThrows() { PublishSubject source = PublishSubject.create(); - Function> debounceSel = new Function>() { - - @Override - public Observable apply(Integer t1) { - return Observable.error(new TestException()); - } - }; + Function> debounceSel = t1 -> Observable.error(new TestException()); Subscriber o = TestHelper.mockSubscriber(); @@ -254,13 +223,7 @@ public void debounceSelectorLastIsNotLost() { PublishSubject source = PublishSubject.create(); final PublishSubject debouncer = PublishSubject.create(); - Function> debounceSel = new Function>() { - - @Override - public Observable apply(Integer t1) { - return debouncer; - } - }; + Function> debounceSel = t1 -> debouncer; Subscriber o = TestHelper.mockSubscriber(); @@ -279,7 +242,7 @@ public Observable apply(Integer t1) { @Test public void debounceWithTimeBackpressure() throws InterruptedException { TestScheduler scheduler = new TestScheduler(); - TestSubscriber subscriber = new TestSubscriber(); + TestSubscriber subscriber = new TestSubscriber<>(); Observable.merge( Observable.just(1), Observable.just(2).delay(10, TimeUnit.MILLISECONDS, scheduler) diff --git a/src/test/java/io/reactivex/internal/operators/OperatorDefaultIfEmptyTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorDefaultIfEmptyTest.java similarity index 95% rename from src/test/java/io/reactivex/internal/operators/OperatorDefaultIfEmptyTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorDefaultIfEmptyTest.java index ad2ccea977..6e842bdefc 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorDefaultIfEmptyTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorDefaultIfEmptyTest.java @@ -85,7 +85,7 @@ public void onComplete() { @Test public void testBackpressureEmpty() { - TestSubscriber ts = new TestSubscriber((Long)null); + TestSubscriber ts = new TestSubscriber<>((Long) null); Observable.empty().defaultIfEmpty(1).subscribe(ts); ts.assertNoValues(); ts.assertNotTerminated(); @@ -97,7 +97,7 @@ public void testBackpressureEmpty() { @Test public void testBackpressureNonEmpty() { - TestSubscriber ts = new TestSubscriber((Long)null); + TestSubscriber ts = new TestSubscriber<>((Long) null); Observable.just(1,2,3).defaultIfEmpty(1).subscribe(ts); ts.assertNoValues(); ts.assertNotTerminated(); diff --git a/src/test/java/io/reactivex/internal/operators/OperatorDelayTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorDelayTest.java similarity index 97% rename from src/test/java/io/reactivex/internal/operators/OperatorDelayTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorDelayTest.java index 30d9668e51..ca80d766ab 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorDelayTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorDelayTest.java @@ -217,7 +217,7 @@ public void testDelaySubscriptionCancelBeforeTime() { Observable result = Observable.just(1, 2, 3).delaySubscription(100, TimeUnit.MILLISECONDS, scheduler); Subscriber o = TestHelper.mockSubscriber(); - TestSubscriber ts = new TestSubscriber(o); + TestSubscriber ts = new TestSubscriber<>(o); result.subscribe(ts); ts.dispose(); @@ -231,7 +231,7 @@ public void testDelaySubscriptionCancelBeforeTime() { @Test public void testDelayWithObservableNormal1() { PublishSubject source = PublishSubject.create(); - final List> delays = new ArrayList>(); + final List> delays = new ArrayList<>(); final int n = 10; for (int i = 0; i < n; i++) { PublishSubject delay = PublishSubject.create(); @@ -582,7 +582,7 @@ public void testDelayWithObservableReorder() { int n = 3; PublishSubject source = PublishSubject.create(); - final List> subjects = new ArrayList>(); + final List> subjects = new ArrayList<>(); for (int i = 0; i < n; i++) { subjects.add(PublishSubject. create()); } @@ -630,7 +630,7 @@ public void accept(Try> t1) { } }); - TestSubscriber observer = new TestSubscriber(); + TestSubscriber observer = new TestSubscriber<>(); delayed.subscribe(observer); // all will be delivered after 500ms since range does not delay between them scheduler.advanceTimeBy(500L, TimeUnit.MILLISECONDS); @@ -639,7 +639,7 @@ public void accept(Try> t1) { @Test public void testBackpressureWithTimedDelay() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.range(1, Observable.bufferSize() * 2) .delay(100, TimeUnit.MILLISECONDS) .observeOn(Schedulers.computation()) @@ -667,7 +667,7 @@ public Integer apply(Integer t) { @Test public void testBackpressureWithSubscriptionTimedDelay() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.range(1, Observable.bufferSize() * 2) .delaySubscription(100, TimeUnit.MILLISECONDS) .delay(100, TimeUnit.MILLISECONDS) @@ -696,7 +696,7 @@ public Integer apply(Integer t) { @Test public void testBackpressureWithSelectorDelay() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.range(1, Observable.bufferSize() * 2) .delay(new Function>() { @@ -731,7 +731,7 @@ public Integer apply(Integer t) { @Test public void testBackpressureWithSelectorDelayAndSubscriptionDelay() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.range(1, Observable.bufferSize() * 2) .delay(new Supplier>() { @@ -776,7 +776,7 @@ public void testErrorRunsBeforeOnNext() { PublishSubject ps = PublishSubject.create(); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); ps.delay(1, TimeUnit.SECONDS, test).subscribe(ts); @@ -797,7 +797,7 @@ public void testDelaySupplierSimple() { Observable source = Observable.range(1, 5); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); source.delaySubscription(new Supplier>() { @Override @@ -823,7 +823,7 @@ public void testDelaySupplierCompletes() { Observable source = Observable.range(1, 5); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); source.delaySubscription(new Supplier>() { @Override @@ -850,7 +850,7 @@ public void testDelaySupplierErrors() { Observable source = Observable.range(1, 5); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); source.delaySubscription(new Supplier>() { @Override diff --git a/src/test/java/io/reactivex/internal/operators/OperatorDematerializeTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorDematerializeTest.java similarity index 98% rename from src/test/java/io/reactivex/internal/operators/OperatorDematerializeTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorDematerializeTest.java index 20318e14c8..22b8231e45 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorDematerializeTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorDematerializeTest.java @@ -92,7 +92,7 @@ public void testCompletePassThru() { Subscriber observer = TestHelper.mockSubscriber(); - TestSubscriber ts = new TestSubscriber(observer); + TestSubscriber ts = new TestSubscriber<>(observer); dematerialize.subscribe(ts); System.out.println(ts.errors()); diff --git a/src/test/java/io/reactivex/internal/operators/OperatorDistinctTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorDistinctTest.java similarity index 93% rename from src/test/java/io/reactivex/internal/operators/OperatorDistinctTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorDistinctTest.java index ac0008a261..d3f2eb9cbe 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorDistinctTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorDistinctTest.java @@ -28,14 +28,11 @@ public class OperatorDistinctTest { Subscriber w; // nulls lead to exceptions - final Function TO_UPPER_WITH_EXCEPTION = new Function() { - @Override - public String apply(String s) { - if (s.equals("x")) { - return "XX"; - } - return s.toUpperCase(); + final Function TO_UPPER_WITH_EXCEPTION = s -> { + if (s.equals("x")) { + return "XX"; } + return s.toUpperCase(); }; @Before diff --git a/src/test/java/io/reactivex/internal/operators/OperatorDistinctUntilChangedTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorDistinctUntilChangedTest.java similarity index 94% rename from src/test/java/io/reactivex/internal/operators/OperatorDistinctUntilChangedTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorDistinctUntilChangedTest.java index 8e593f7021..afa1fe7b67 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorDistinctUntilChangedTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorDistinctUntilChangedTest.java @@ -29,14 +29,11 @@ public class OperatorDistinctUntilChangedTest { Subscriber w2; // nulls lead to exceptions - final Function TO_UPPER_WITH_EXCEPTION = new Function() { - @Override - public String apply(String s) { - if (s.equals("x")) { - return "xx"; - } - return s.toUpperCase(); + final Function TO_UPPER_WITH_EXCEPTION = s -> { + if (s.equals("x")) { + return "xx"; } + return s.toUpperCase(); }; @Before diff --git a/src/test/java/io/reactivex/internal/operators/OperatorDoOnEachTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorDoOnEachTest.java similarity index 100% rename from src/test/java/io/reactivex/internal/operators/OperatorDoOnEachTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorDoOnEachTest.java diff --git a/src/test/java/io/reactivex/internal/operators/OperatorDoOnRequestTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorDoOnRequestTest.java similarity index 74% rename from src/test/java/io/reactivex/internal/operators/OperatorDoOnRequestTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorDoOnRequestTest.java index f1e15aaa8c..6b6f7e0bbd 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorDoOnRequestTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorDoOnRequestTest.java @@ -31,18 +31,10 @@ public void testUnsubscribeHappensAgainstParent() { final AtomicBoolean unsubscribed = new AtomicBoolean(false); Observable.just(1) // - .doOnCancel(new Runnable() { - @Override - public void run() { - unsubscribed.set(true); - } - }) + .doOnCancel(() -> unsubscribed.set(true)) // - .doOnRequest(new LongConsumer() { - @Override - public void accept(long n) { - // do nothing - } + .doOnRequest(n -> { + // do nothing }) // .subscribe(); @@ -51,15 +43,10 @@ public void accept(long n) { @Test public void testDoRequest() { - final List requests = new ArrayList(); + final List requests = new ArrayList<>(); Observable.range(1, 5) // - .doOnRequest(new LongConsumer() { - @Override - public void accept(long n) { - requests.add(n); - } - }) + .doOnRequest(requests::add) // .subscribe(new Observer() { diff --git a/src/test/java/io/reactivex/internal/operators/OperatorDoOnSubscribeTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorDoOnSubscribeTest.java similarity index 98% rename from src/test/java/io/reactivex/internal/operators/OperatorDoOnSubscribeTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorDoOnSubscribeTest.java index 1b839990ca..7f1475d3b2 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorDoOnSubscribeTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorDoOnSubscribeTest.java @@ -66,7 +66,7 @@ public void testDoOnUnSubscribeWorksWithRefCount() throws Exception { final AtomicInteger onSubscribed = new AtomicInteger(); final AtomicInteger countBefore = new AtomicInteger(); final AtomicInteger countAfter = new AtomicInteger(); - final AtomicReference> sref = new AtomicReference>(); + final AtomicReference> sref = new AtomicReference<>(); Observable o = Observable.create(new Publisher() { @Override diff --git a/src/test/java/io/reactivex/internal/operators/OperatorDoOnUnsubscribeTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorDoOnUnsubscribeTest.java similarity index 94% rename from src/test/java/io/reactivex/internal/operators/OperatorDoOnUnsubscribeTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorDoOnUnsubscribeTest.java index 5437287a72..ff483804cd 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorDoOnUnsubscribeTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorDoOnUnsubscribeTest.java @@ -66,11 +66,11 @@ public void run() { } }); - List subscriptions = new ArrayList(); - List> subscribers = new ArrayList>(); + List subscriptions = new ArrayList<>(); + List> subscribers = new ArrayList<>(); for (int i = 0; i < subCount; ++i) { - TestSubscriber subscriber = new TestSubscriber(); + TestSubscriber subscriber = new TestSubscriber<>(); subscriptions.add(subscriber); longs.subscribe(subscriber); subscribers.add(subscriber); @@ -129,11 +129,11 @@ public void run() { .publish() .refCount(); - List subscriptions = new ArrayList(); - List> subscribers = new ArrayList>(); + List subscriptions = new ArrayList<>(); + List> subscribers = new ArrayList<>(); for (int i = 0; i < subCount; ++i) { - TestSubscriber subscriber = new TestSubscriber(); + TestSubscriber subscriber = new TestSubscriber<>(); longs.subscribe(subscriber); subscriptions.add(subscriber); subscribers.add(subscriber); diff --git a/src/test/java/io/reactivex/internal/operators/OperatorElementAtTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorElementAtTest.java similarity index 100% rename from src/test/java/io/reactivex/internal/operators/OperatorElementAtTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorElementAtTest.java diff --git a/src/test/java/io/reactivex/internal/operators/OperatorFilterTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorFilterTest.java similarity index 89% rename from src/test/java/io/reactivex/internal/operators/OperatorFilterTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorFilterTest.java index 397b5f2909..b1e7cba487 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorFilterTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorFilterTest.java @@ -31,13 +31,7 @@ public class OperatorFilterTest { @Test public void testFilter() { Observable w = Observable.just("one", "two", "three"); - Observable observable = w.filter(new Predicate() { - - @Override - public boolean test(String t1) { - return t1.equals("two"); - } - }); + Observable observable = w.filter(t1 -> t1.equals("two")); Subscriber observer = TestHelper.mockSubscriber(); @@ -58,13 +52,7 @@ public boolean test(String t1) { @Test(timeout = 500) public void testWithBackpressure() throws InterruptedException { Observable w = Observable.just("one", "two", "three"); - Observable o = w.filter(new Predicate() { - - @Override - public boolean test(String t1) { - return t1.equals("three"); - } - }); + Observable o = w.filter(t1 -> t1.equals("three")); final CountDownLatch latch = new CountDownLatch(1); TestSubscriber ts = new TestSubscriber() { @@ -105,13 +93,7 @@ public void onNext(String t) { @Test(timeout = 500000) public void testWithBackpressure2() throws InterruptedException { Observable w = Observable.range(1, Observable.bufferSize() * 2); - Observable o = w.filter(new Predicate() { - - @Override - public boolean test(Integer t1) { - return t1 > 100; - } - }); + Observable o = w.filter(t1 -> t1 > 100); final CountDownLatch latch = new CountDownLatch(1); final TestSubscriber ts = new TestSubscriber() { diff --git a/src/test/java/io/reactivex/internal/operators/OperatorFinallyTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorFinallyTest.java similarity index 100% rename from src/test/java/io/reactivex/internal/operators/OperatorFinallyTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorFinallyTest.java diff --git a/src/test/java/io/reactivex/internal/operators/OperatorFirstTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorFirstTest.java similarity index 100% rename from src/test/java/io/reactivex/internal/operators/OperatorFirstTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorFirstTest.java diff --git a/src/test/java/io/reactivex/internal/operators/OperatorFlatMapTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorFlatMapTest.java similarity index 95% rename from src/test/java/io/reactivex/internal/operators/OperatorFlatMapTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorFlatMapTest.java index 08044c702c..c6557693ef 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorFlatMapTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorFlatMapTest.java @@ -334,14 +334,14 @@ public Observable apply(Integer t1) { } }, m); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); source.subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); - Set expected = new HashSet(Arrays.asList( - 10, 11, 20, 21, 30, 31, 40, 41, 50, 51, 60, 61, 70, 71, 80, 81, 90, 91, 100, 101 + Set expected = new HashSet<>(Arrays.asList( + 10, 11, 20, 21, 30, 31, 40, 41, 50, 51, 60, 61, 70, 71, 80, 81, 90, 91, 100, 101 )); Assert.assertEquals(expected.size(), ts.valueCount()); Assert.assertTrue(expected.containsAll(ts.values())); @@ -364,15 +364,15 @@ public Integer apply(Integer t1, Integer t2) { } }, m); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); source.subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); - Set expected = new HashSet(Arrays.asList( - 1010, 1011, 2020, 2021, 3030, 3031, 4040, 4041, 5050, 5051, - 6060, 6061, 7070, 7071, 8080, 8081, 9090, 9091, 10100, 10101 + Set expected = new HashSet<>(Arrays.asList( + 1010, 1011, 2020, 2021, 3030, 3031, 4040, 4041, 5050, 5051, + 6060, 6061, 7070, 7071, 8080, 8081, 9090, 9091, 10100, 10101 )); Assert.assertEquals(expected.size(), ts.valueCount()); System.out.println("--> testFlatMapSelectorMaxConcurrent: " + ts.values()); @@ -410,7 +410,7 @@ public void testFlatMapTransformsMaxConcurrentNormal() { Observable source = Observable.fromIterable(Arrays.asList(10, 20, 30)); Subscriber o = TestHelper.mockSubscriber(); - TestSubscriber ts = new TestSubscriber(o); + TestSubscriber ts = new TestSubscriber<>(o); Function> just = just(onNext); Function> just2 = just(onError); @@ -438,7 +438,7 @@ public void flatMapRangeAsyncLoop() { if (i % 10 == 0) { System.out.println("flatMapRangeAsyncLoop > " + i); } - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.range(0, 1000) .flatMap(new Function>() { @Override @@ -475,7 +475,7 @@ public void flatMapRangeMixedAsyncLoop() { if (i % 10 == 0) { System.out.println("flatMapRangeAsyncLoop > " + i); } - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.range(0, 1000) .flatMap(new Function>() { final Random rnd = new Random(); @@ -499,7 +499,7 @@ public Observable apply(Integer t) { ts.assertNoErrors(); List list = ts.values(); if (list.size() < 1000) { - Set set = new HashSet(list); + Set set = new HashSet<>(list); for (int j = 0; j < 1000; j++) { if (!set.contains(j)) { System.out.println(j + " missing"); @@ -513,7 +513,7 @@ public Observable apply(Integer t) { @Test public void flatMapIntPassthruAsync() { for (int i = 0;i < 1000; i++) { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.range(1, 1000).flatMap(new Function>() { @Override @@ -531,7 +531,7 @@ public Observable apply(Integer t) { @Test public void flatMapTwoNestedSync() { for (final int n : new int[] { 1, 1000, 1000000 }) { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.just(1, 2).flatMap(new Function>() { @Override diff --git a/src/test/java/io/reactivex/internal/operators/OperatorGroupByTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorGroupByTest.java similarity index 97% rename from src/test/java/io/reactivex/internal/operators/OperatorGroupByTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorGroupByTest.java index 63d2b6dd15..10c8c3e672 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorGroupByTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorGroupByTest.java @@ -104,7 +104,7 @@ public void testError() { final AtomicInteger groupCounter = new AtomicInteger(); final AtomicInteger eventCounter = new AtomicInteger(); - final AtomicReference error = new AtomicReference(); + final AtomicReference error = new AtomicReference<>(); grouped.flatMap(new Function, Observable>() { @@ -147,13 +147,13 @@ public void onNext(String v) { private static Map> toMap(Observable> observable) { - final ConcurrentHashMap> result = new ConcurrentHashMap>(); + final ConcurrentHashMap> result = new ConcurrentHashMap<>(); observable.toBlocking().forEach(new Consumer>() { @Override public void accept(final GroupedObservable o) { - result.put(o.getKey(), new ConcurrentLinkedQueue()); + result.put(o.getKey(), new ConcurrentLinkedQueue<>()); o.subscribe(new Consumer() { @Override @@ -594,7 +594,7 @@ public void accept(String s) { @Test public void testFirstGroupsCompleteAndParentSlowToThenEmitFinalGroupsAndThenComplete() throws InterruptedException { final CountDownLatch first = new CountDownLatch(2); // there are two groups to first complete - final ArrayList results = new ArrayList(); + final ArrayList results = new ArrayList<>(); Observable.create(new Publisher() { @Override @@ -673,7 +673,7 @@ public void accept(String s) { public void testFirstGroupsCompleteAndParentSlowToThenEmitFinalGroupsWhichThenSubscribesOnAndDelaysAndThenCompletes() throws InterruptedException { System.err.println("----------------------------------------------------------------------------------------------"); final CountDownLatch first = new CountDownLatch(2); // there are two groups to first complete - final ArrayList results = new ArrayList(); + final ArrayList results = new ArrayList<>(); Observable.create(new Publisher() { @Override @@ -765,7 +765,7 @@ public void accept(String s) { @Test public void testFirstGroupsCompleteAndParentSlowToThenEmitFinalGroupsWhichThenObservesOnAndDelaysAndThenCompletes() throws InterruptedException { final CountDownLatch first = new CountDownLatch(2); // there are two groups to first complete - final ArrayList results = new ArrayList(); + final ArrayList results = new ArrayList<>(); Observable.create(new Publisher() { @Override @@ -842,7 +842,7 @@ public void accept(String s) { @Test public void testGroupsWithNestedSubscribeOn() throws InterruptedException { - final ArrayList results = new ArrayList(); + final ArrayList results = new ArrayList<>(); Observable.create(new Publisher() { @Override @@ -899,7 +899,7 @@ public void accept(String s) { @Test public void testGroupsWithNestedObserveOn() throws InterruptedException { - final ArrayList results = new ArrayList(); + final ArrayList results = new ArrayList<>(); Observable.create(new Publisher() { @Override @@ -1026,7 +1026,7 @@ public Boolean apply(Integer n) { @Test public void testGroupByBackpressure() throws InterruptedException { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.range(1, 4000) .groupBy(IS_EVEN2) @@ -1153,7 +1153,7 @@ public String apply(String v) { } }); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); m.subscribe(ts); ts.awaitTerminalEvent(); System.out.println("ts .get " + ts.values()); @@ -1169,7 +1169,7 @@ public void keySelectorThrows() { Observable m = source.groupBy(fail(0), dbl).flatMap(FLATTEN_INTEGER); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); m.subscribe(ts); ts.awaitTerminalEvent(); assertEquals(1, ts.errorCount()); @@ -1181,7 +1181,7 @@ public void valueSelectorThrows() { Observable source = Observable.just(0, 1, 2, 3, 4, 5, 6); Observable m = source.groupBy(identity, fail(0)).flatMap(FLATTEN_INTEGER); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); m.subscribe(ts); ts.awaitTerminalEvent(); assertEquals(1, ts.errorCount()); @@ -1195,7 +1195,7 @@ public void innerEscapeCompleted() { Observable m = source.groupBy(identity, dbl).flatMap(FLATTEN_INTEGER); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); m.subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); @@ -1209,7 +1209,7 @@ public void innerEscapeCompleted() { public void testExceptionIfSubscribeToChildMoreThanOnce() { Observable source = Observable.just(0); - final AtomicReference> inner = new AtomicReference>(); + final AtomicReference> inner = new AtomicReference<>(); Observable> m = source.groupBy(identity, dbl); @@ -1239,7 +1239,7 @@ public void testError2() { Observable m = source.groupBy(identity, dbl).flatMap(FLATTEN_INTEGER); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); m.subscribe(ts); ts.awaitTerminalEvent(); assertEquals(1, ts.errorCount()); @@ -1248,7 +1248,7 @@ public void testError2() { @Test public void testgroupByBackpressure() throws InterruptedException { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.range(1, 4000).groupBy(IS_EVEN2).flatMap(new Function, Observable>() { @@ -1305,7 +1305,7 @@ public void accept(Try> t1) { @Test public void testgroupByBackpressure2() throws InterruptedException { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.range(1, 4000) .doOnNext(new Consumer() { @@ -1353,7 +1353,7 @@ public Observable apply(GroupedObservable t) { @Test public void testGroupByWithNullKey() { final String[] key = new String[]{"uninitialized"}; - final List values = new ArrayList(); + final List values = new ArrayList<>(); Observable.just("a", "b", "c").groupBy(new Function() { @Override @@ -1389,7 +1389,7 @@ public void subscribe(Subscriber subscriber) { } } ); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); o.groupBy(new Function() { @@ -1407,11 +1407,11 @@ public Integer apply(Integer integer) { @Test public void testGroupByShouldPropagateError() { final Throwable e = new RuntimeException("Oops"); - final TestSubscriber inner1 = new TestSubscriber(); - final TestSubscriber inner2 = new TestSubscriber(); + final TestSubscriber inner1 = new TestSubscriber<>(); + final TestSubscriber inner2 = new TestSubscriber<>(); final TestSubscriber> outer - = new TestSubscriber>(new Observer>() { + = new TestSubscriber<>(new Observer>() { @Override public void onComplete() { @@ -1527,7 +1527,7 @@ public Object apply(Integer i) { */ @Test public void testBackpressureInnerDoesntOverflowOuter() { - TestSubscriber> ts = new TestSubscriber>((Long)null); + TestSubscriber> ts = new TestSubscriber<>((Long) null); Observable.fromArray(1, 2) .groupBy(new Function() { @@ -1553,8 +1553,8 @@ public void accept(GroupedObservable g) { @Test public void testOneGroupInnerRequestsTwiceBuffer() { - TestSubscriber ts1 = new TestSubscriber((Long)null); - final TestSubscriber ts2 = new TestSubscriber((Long)null); + TestSubscriber ts1 = new TestSubscriber<>((Long) null); + final TestSubscriber ts2 = new TestSubscriber<>((Long) null); Observable.range(1, Observable.bufferSize() * 2) .groupBy(new Function() { diff --git a/src/test/java/io/reactivex/internal/operators/OperatorIgnoreElementsTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorIgnoreElementsTest.java similarity index 77% rename from src/test/java/io/reactivex/internal/operators/OperatorIgnoreElementsTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorIgnoreElementsTest.java index ccf35ec5e5..8825cba403 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorIgnoreElementsTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorIgnoreElementsTest.java @@ -41,12 +41,7 @@ public void testUpstreamIsProcessedButIgnored() { final int num = 10; final AtomicInteger upstreamCount = new AtomicInteger(); long count = Observable.range(1, num) - .doOnNext(new Consumer() { - @Override - public void accept(Integer t) { - upstreamCount.incrementAndGet(); - } - }) + .doOnNext(t -> upstreamCount.incrementAndGet()) .ignoreElements() .count().toBlocking().single(); assertEquals(num, upstreamCount.get()); @@ -55,7 +50,7 @@ public void accept(Integer t) { @Test public void testCompletedOk() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.range(1, 10).ignoreElements().subscribe(ts); ts.assertNoErrors(); ts.assertNoValues(); @@ -66,7 +61,7 @@ public void testCompletedOk() { @Test public void testErrorReceived() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); TestException ex = new TestException("boo"); Observable.error(ex).ignoreElements().subscribe(ts); ts.assertNoValues(); @@ -80,11 +75,7 @@ public void testErrorReceived() { @Test public void testUnsubscribesFromUpstream() { final AtomicBoolean unsub = new AtomicBoolean(); - Observable.range(1, 10).doOnCancel(new Runnable() { - @Override - public void run() { - unsub.set(true); - }}) + Observable.range(1, 10).doOnCancel(() -> unsub.set(true)) .subscribe(); assertTrue(unsub.get()); } @@ -96,22 +87,11 @@ public void testDoesNotHangAndProcessesAllUsingBackpressure() { int num = 10; Observable.range(1, num) // - .doOnNext(new Consumer() { - @Override - public void accept(Integer t) { - upstreamCount.incrementAndGet(); - } - }) + .doOnNext(t -> upstreamCount.incrementAndGet()) // .ignoreElements() // - .doOnNext(new Consumer() { - - @Override - public void accept(Integer t) { - upstreamCount.incrementAndGet(); - } - }) + .doOnNext(t -> upstreamCount.incrementAndGet()) // .subscribe(new Observer() { diff --git a/src/test/java/io/reactivex/internal/operators/OperatorLastTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorLastTest.java similarity index 83% rename from src/test/java/io/reactivex/internal/operators/OperatorLastTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorLastTest.java index 1ad7796bb1..0010b709f5 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorLastTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorLastTest.java @@ -94,13 +94,7 @@ public void testLastWithEmpty() { @Test public void testLastWithPredicate() { Observable observable = Observable.just(1, 2, 3, 4, 5, 6) - .filter(new Predicate() { - - @Override - public boolean test(Integer t1) { - return t1 % 2 == 0; - } - }) + .filter(t1 -> t1 % 2 == 0) .last(); Subscriber observer = TestHelper.mockSubscriber(); @@ -115,14 +109,7 @@ public boolean test(Integer t1) { @Test public void testLastWithPredicateAndOneElement() { Observable observable = Observable.just(1, 2) - .filter( - new Predicate() { - - @Override - public boolean test(Integer t1) { - return t1 % 2 == 0; - } - }) + .filter(t1 -> t1 % 2 == 0) .last(); Subscriber observer = TestHelper.mockSubscriber(); @@ -137,14 +124,7 @@ public boolean test(Integer t1) { @Test public void testLastWithPredicateAndEmpty() { Observable observable = Observable.just(1) - .filter( - new Predicate() { - - @Override - public boolean test(Integer t1) { - return t1 % 2 == 0; - } - }).last(); + .filter(t1 -> t1 % 2 == 0).last(); Subscriber observer = TestHelper.mockSubscriber(); observable.subscribe(observer); @@ -199,13 +179,7 @@ public void testLastOrDefaultWithEmpty() { @Test public void testLastOrDefaultWithPredicate() { Observable observable = Observable.just(1, 2, 3, 4, 5, 6) - .filter(new Predicate() { - - @Override - public boolean test(Integer t1) { - return t1 % 2 == 0; - } - }) + .filter(t1 -> t1 % 2 == 0) .last(8); Subscriber observer = TestHelper.mockSubscriber(); @@ -220,13 +194,7 @@ public boolean test(Integer t1) { @Test public void testLastOrDefaultWithPredicateAndOneElement() { Observable observable = Observable.just(1, 2) - .filter(new Predicate() { - - @Override - public boolean test(Integer t1) { - return t1 % 2 == 0; - } - }) + .filter(t1 -> t1 % 2 == 0) .last(4); Subscriber observer = TestHelper.mockSubscriber(); @@ -241,14 +209,7 @@ public boolean test(Integer t1) { @Test public void testLastOrDefaultWithPredicateAndEmpty() { Observable observable = Observable.just(1) - .filter( - new Predicate() { - - @Override - public boolean test(Integer t1) { - return t1 % 2 == 0; - } - }) + .filter(t1 -> t1 % 2 == 0) .last(2); Subscriber observer = TestHelper.mockSubscriber(); diff --git a/src/test/java/io/reactivex/internal/operators/OperatorMapNotificationTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorMapNotificationTest.java similarity index 53% rename from src/test/java/io/reactivex/internal/operators/OperatorMapNotificationTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorMapNotificationTest.java index e2c8f73b5b..a78fe542f0 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorMapNotificationTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorMapNotificationTest.java @@ -22,28 +22,10 @@ public class OperatorMapNotificationTest { @Test public void testJust() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.just(1) - .flatMap( - new Function>() { - @Override - public Observable apply(Integer item) { - return Observable.just((Object)(item + 1)); - } - }, - new Function>() { - @Override - public Observable apply(Throwable e) { - return Observable.error(e); - } - }, - new Supplier>() { - @Override - public Observable get() { - return Observable.never(); - } - } - ).subscribe(ts); + .flatMap(item -> Observable.just(item + 1), Observable::error, Observable::never) + .subscribe(ts); ts.assertNoErrors(); ts.assertNotComplete(); diff --git a/src/test/java/io/reactivex/internal/operators/OperatorMapTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorMapTest.java similarity index 99% rename from src/test/java/io/reactivex/internal/operators/OperatorMapTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorMapTest.java index 14cd32fcc5..4204c37888 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorMapTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorMapTest.java @@ -301,7 +301,7 @@ public Integer apply(Integer i) { // } private static Map getMap(String prefix) { - Map m = new HashMap(); + Map m = new HashMap<>(); m.put("firstName", prefix + "First"); m.put("lastName", prefix + "Last"); return m; diff --git a/src/test/java/io/reactivex/internal/operators/OperatorMaterializeTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorMaterializeTest.java similarity index 86% rename from src/test/java/io/reactivex/internal/operators/OperatorMaterializeTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorMaterializeTest.java index df5857872f..d0a503efbb 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorMaterializeTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorMaterializeTest.java @@ -98,7 +98,7 @@ public void testMultipleSubscribes() throws InterruptedException, ExecutionExcep @Test public void testBackpressureOnEmptyStream() { - TestSubscriber>> ts = new TestSubscriber>>((Long)null); + TestSubscriber>> ts = new TestSubscriber<>((Long) null); Observable. empty().materialize().subscribe(ts); ts.assertNoValues(); ts.request(1); @@ -109,7 +109,7 @@ public void testBackpressureOnEmptyStream() { @Test public void testBackpressureNoError() { - TestSubscriber>> ts = new TestSubscriber>>((Long)null); + TestSubscriber>> ts = new TestSubscriber<>((Long) null); Observable.just(1, 2, 3).materialize().subscribe(ts); ts.assertNoValues(); ts.request(1); @@ -123,7 +123,7 @@ public void testBackpressureNoError() { @Test public void testBackpressureNoErrorAsync() throws InterruptedException { - TestSubscriber>> ts = new TestSubscriber>>((Long)null); + TestSubscriber>> ts = new TestSubscriber<>((Long) null); Observable.just(1, 2, 3) .materialize() .subscribeOn(Schedulers.computation()) @@ -144,7 +144,7 @@ public void testBackpressureNoErrorAsync() throws InterruptedException { @Test public void testBackpressureWithError() { - TestSubscriber>> ts = new TestSubscriber>>((Long)null); + TestSubscriber>> ts = new TestSubscriber<>((Long) null); Observable. error(new IllegalArgumentException()).materialize().subscribe(ts); ts.assertNoValues(); ts.request(1); @@ -154,7 +154,7 @@ public void testBackpressureWithError() { @Test public void testBackpressureWithEmissionThenError() { - TestSubscriber>> ts = new TestSubscriber>>((Long)null); + TestSubscriber>> ts = new TestSubscriber<>((Long) null); IllegalArgumentException ex = new IllegalArgumentException(); Observable.fromIterable(Arrays.asList(1)).concatWith(Observable. error(ex)).materialize() .subscribe(ts); @@ -171,13 +171,10 @@ public void testBackpressureWithEmissionThenError() { @Test public void testWithCompletionCausingError() { - TestSubscriber>> ts = new TestSubscriber>>(); + TestSubscriber>> ts = new TestSubscriber<>(); final RuntimeException ex = new RuntimeException("boo"); - Observable.empty().materialize().doOnNext(new Consumer() { - @Override - public void accept(Object t) { - throw ex; - } + Observable.empty().materialize().doOnNext(t -> { + throw ex; }).subscribe(ts); ts.assertError(ex); ts.assertNoValues(); @@ -186,7 +183,7 @@ public void accept(Object t) { @Test public void testUnsubscribeJustBeforeCompletionNotificationShouldPreventThatNotificationArriving() { - TestSubscriber>> ts = new TestSubscriber>>((Long)null); + TestSubscriber>> ts = new TestSubscriber<>((Long) null); Observable.empty().materialize() .subscribe(ts); @@ -202,7 +199,7 @@ private static class TestObserver extends Observer>> { boolean onCompleted = false; boolean onError = false; - List>> notifications = new Vector>>(); + List>> notifications = new Vector<>(); @Override public void onComplete() { @@ -234,28 +231,23 @@ private static class TestAsyncErrorObservable implements Publisher { @Override public void subscribe(final Subscriber observer) { observer.onSubscribe(EmptySubscription.INSTANCE); - t = new Thread(new Runnable() { - - @Override - public void run() { - for (String s : valuesToReturn) { - if (s == null) { - System.out.println("throwing exception"); - try { - Thread.sleep(100); - } catch (Throwable e) { - - } - observer.onError(new NullPointerException()); - return; - } else { - observer.onNext(s); + t = new Thread(() -> { + for (String s : valuesToReturn) { + if (s == null) { + System.out.println("throwing exception"); + try { + Thread.sleep(100); + } catch (Throwable e) { + } + observer.onError(new NullPointerException()); + return; + } else { + observer.onNext(s); } - System.out.println("subscription complete"); - observer.onComplete(); } - + System.out.println("subscription complete"); + observer.onComplete(); }); t.start(); } diff --git a/src/test/java/io/reactivex/internal/operators/OperatorMergeDelayErrorTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorMergeDelayErrorTest.java similarity index 91% rename from src/test/java/io/reactivex/internal/operators/OperatorMergeDelayErrorTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorMergeDelayErrorTest.java index 86880e096b..bedc71e5f4 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorMergeDelayErrorTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorMergeDelayErrorTest.java @@ -258,7 +258,7 @@ public void testMergeArray() { public void testMergeList() { final Observable o1 = Observable.create(new TestSynchronousObservable()); final Observable o2 = Observable.create(new TestSynchronousObservable()); - List> listOfObservables = new ArrayList>(); + List> listOfObservables = new ArrayList<>(); listOfObservables.add(o1); listOfObservables.add(o2); @@ -335,14 +335,9 @@ private static class TestASynchronousObservable implements Publisher { @Override public void subscribe(final Subscriber observer) { observer.onSubscribe(EmptySubscription.INSTANCE); - t = new Thread(new Runnable() { - - @Override - public void run() { - observer.onNext("hello"); - observer.onComplete(); - } - + t = new Thread(() -> { + observer.onNext("hello"); + observer.onComplete(); }); t.start(); } @@ -390,28 +385,23 @@ private static class TestAsyncErrorObservable implements Publisher { @Override public void subscribe(final Subscriber observer) { observer.onSubscribe(EmptySubscription.INSTANCE); - t = new Thread(new Runnable() { + t = new Thread(() -> { + for (String s : valuesToReturn) { + if (s == null) { + System.out.println("throwing exception"); + try { + Thread.sleep(100); + } catch (Throwable e) { - @Override - public void run() { - for (String s : valuesToReturn) { - if (s == null) { - System.out.println("throwing exception"); - try { - Thread.sleep(100); - } catch (Throwable e) { - - } - observer.onError(new NullPointerException()); - return; - } else { - observer.onNext(s); } + observer.onError(new NullPointerException()); + return; + } else { + observer.onNext(s); } - System.out.println("subscription complete"); - observer.onComplete(); } - + System.out.println("subscription complete"); + observer.onComplete(); }); t.start(); } @@ -494,7 +484,7 @@ public void onComplete() { @Test public void testErrorInParentObservable() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.mergeDelayError( Observable.just(Observable.just(1), Observable.just(2)) .startWith(Observable. error(new RuntimeException())) @@ -523,7 +513,7 @@ public void subscribe(Subscriber> op) { Subscriber stringObserver = TestHelper.mockSubscriber(); - TestSubscriber ts = new TestSubscriber(stringObserver); + TestSubscriber ts = new TestSubscriber<>(stringObserver); Observable m = Observable.mergeDelayError(parentObservable); m.subscribe(ts); System.out.println("testErrorInParentObservableDelayed | " + i); @@ -542,37 +532,27 @@ private static class TestASynchronous1sDelayedObservable implements Publisher observer) { observer.onSubscribe(EmptySubscription.INSTANCE); - t = new Thread(new Runnable() { - - @Override - public void run() { - try { - Thread.sleep(100); - } catch (InterruptedException e) { - observer.onError(e); - } - observer.onNext("hello"); - observer.onComplete(); + t = new Thread(() -> { + try { + Thread.sleep(100); + } catch (InterruptedException e) { + observer.onError(e); } - + observer.onNext("hello"); + observer.onComplete(); }); t.start(); } } @Test public void testDelayErrorMaxConcurrent() { - final List requests = new ArrayList(); + final List requests = new ArrayList<>(); Observable source = Observable.mergeDelayError(Observable.just( Observable.just(1).asObservable(), Observable.error(new TestException())) - .doOnRequest(new LongConsumer() { - @Override - public void accept(long t1) { - requests.add(t1); - } - }), 1); + .doOnRequest(t1 -> requests.add(t1)), 1); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); source.subscribe(ts); diff --git a/src/test/java/io/reactivex/internal/operators/OperatorMergeMaxConcurrentTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorMergeMaxConcurrentTest.java similarity index 80% rename from src/test/java/io/reactivex/internal/operators/OperatorMergeMaxConcurrentTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorMergeMaxConcurrentTest.java index f83024c98d..c24669915b 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorMergeMaxConcurrentTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorMergeMaxConcurrentTest.java @@ -41,14 +41,14 @@ public void before() { @Test public void testWhenMaxConcurrentIsOne() { for (int i = 0; i < 100; i++) { - List> os = new ArrayList>(); + List> os = new ArrayList<>(); os.add(Observable.just("one", "two", "three", "four", "five").subscribeOn(Schedulers.newThread())); os.add(Observable.just("one", "two", "three", "four", "five").subscribeOn(Schedulers.newThread())); os.add(Observable.just("one", "two", "three", "four", "five").subscribeOn(Schedulers.newThread())); List expected = Arrays.asList("one", "two", "three", "four", "five", "one", "two", "three", "four", "five", "one", "two", "three", "four", "five"); Iterator iter = Observable.merge(os, 1).toBlocking().iterator(); - List actual = new ArrayList(); + List actual = new ArrayList<>(); while (iter.hasNext()) { actual.add(iter.next()); } @@ -64,8 +64,8 @@ public void testMaxConcurrent() { int maxConcurrent = 2 + (times % 10); AtomicInteger subscriptionCount = new AtomicInteger(0); - List> os = new ArrayList>(); - List scos = new ArrayList(); + List> os = new ArrayList<>(); + List scos = new ArrayList<>(); for (int i = 0; i < observableCount; i++) { SubscriptionCheckObservable sco = new SubscriptionCheckObservable(subscriptionCount, maxConcurrent); scos.add(sco); @@ -73,7 +73,7 @@ public void testMaxConcurrent() { } Iterator iter = Observable.merge(os, maxConcurrent).toBlocking().iterator(); - List actual = new ArrayList(); + List actual = new ArrayList<>(); while (iter.hasNext()) { actual.add(iter.next()); } @@ -99,24 +99,19 @@ private static class SubscriptionCheckObservable implements Publisher { @Override public void subscribe(final Subscriber t1) { t1.onSubscribe(EmptySubscription.INSTANCE); - new Thread(new Runnable() { - - @Override - public void run() { - if (subscriptionCount.incrementAndGet() > maxConcurrent) { - failed = true; - } - t1.onNext("one"); - t1.onNext("two"); - t1.onNext("three"); - t1.onNext("four"); - t1.onNext("five"); - // We could not decrement subscriptionCount in the unsubscribe method - // as "unsubscribe" is not guaranteed to be called before the next "subscribe". - subscriptionCount.decrementAndGet(); - t1.onComplete(); + new Thread(() -> { + if (subscriptionCount.incrementAndGet() > maxConcurrent) { + failed = true; } - + t1.onNext("one"); + t1.onNext("two"); + t1.onNext("three"); + t1.onNext("four"); + t1.onNext("five"); + // We could not decrement subscriptionCount in the unsubscribe method + // as "unsubscribe" is not guaranteed to be called before the next "subscribe". + subscriptionCount.decrementAndGet(); + t1.onComplete(); }).start(); } @@ -125,7 +120,7 @@ public void run() { @Test public void testMergeALotOfSourcesOneByOneSynchronously() { int n = 10000; - List> sourceList = new ArrayList>(n); + List> sourceList = new ArrayList<>(n); for (int i = 0; i < n; i++) { sourceList.add(Observable.just(i)); } @@ -140,7 +135,7 @@ public void testMergeALotOfSourcesOneByOneSynchronously() { @Test public void testMergeALotOfSourcesOneByOneSynchronouslyTakeHalf() { int n = 10000; - List> sourceList = new ArrayList>(n); + List> sourceList = new ArrayList<>(n); for (int i = 0; i < n; i++) { sourceList.add(Observable.just(i)); } @@ -156,9 +151,9 @@ public void testMergeALotOfSourcesOneByOneSynchronouslyTakeHalf() { @Test public void testSimple() { for (int i = 1; i < 100; i++) { - TestSubscriber ts = new TestSubscriber(); - List> sourceList = new ArrayList>(i); - List result = new ArrayList(i); + TestSubscriber ts = new TestSubscriber<>(); + List> sourceList = new ArrayList<>(i); + List result = new ArrayList<>(i); for (int j = 1; j <= i; j++) { sourceList.add(Observable.just(j)); result.add(j); @@ -174,9 +169,9 @@ public void testSimple() { @Test public void testSimpleOneLess() { for (int i = 2; i < 100; i++) { - TestSubscriber ts = new TestSubscriber(); - List> sourceList = new ArrayList>(i); - List result = new ArrayList(i); + TestSubscriber ts = new TestSubscriber<>(); + List> sourceList = new ArrayList<>(i); + List result = new ArrayList<>(i); for (int j = 1; j <= i; j++) { sourceList.add(Observable.just(j)); result.add(j); @@ -204,9 +199,9 @@ public void testSimpleAsyncLoop() { @Test(timeout = 10000) public void testSimpleAsync() { for (int i = 1; i < 50; i++) { - TestSubscriber ts = new TestSubscriber(); - List> sourceList = new ArrayList>(i); - Set expected = new HashSet(i); + TestSubscriber ts = new TestSubscriber<>(); + List> sourceList = new ArrayList<>(i); + Set expected = new HashSet<>(i); for (int j = 1; j <= i; j++) { sourceList.add(Observable.just(j).subscribeOn(Schedulers.io())); expected.add(j); @@ -216,7 +211,7 @@ public void testSimpleAsync() { ts.awaitTerminalEvent(1, TimeUnit.SECONDS); ts.assertNoErrors(); - Set actual = new HashSet(ts.values()); + Set actual = new HashSet<>(ts.values()); assertEquals(expected, actual); } @@ -234,9 +229,9 @@ public void testSimpleOneLessAsync() { if (System.currentTimeMillis() - t > TimeUnit.SECONDS.toMillis(9)) { break; } - TestSubscriber ts = new TestSubscriber(); - List> sourceList = new ArrayList>(i); - Set expected = new HashSet(i); + TestSubscriber ts = new TestSubscriber<>(); + List> sourceList = new ArrayList<>(i); + Set expected = new HashSet<>(i); for (int j = 1; j <= i; j++) { sourceList.add(Observable.just(j).subscribeOn(Schedulers.io())); expected.add(j); @@ -246,14 +241,14 @@ public void testSimpleOneLessAsync() { ts.awaitTerminalEvent(1, TimeUnit.SECONDS); ts.assertNoErrors(); - Set actual = new HashSet(ts.values()); + Set actual = new HashSet<>(ts.values()); assertEquals(expected, actual); } } @Test(timeout = 5000) public void testBackpressureHonored() throws Exception { - List> sourceList = new ArrayList>(3); + List> sourceList = new ArrayList<>(3); sourceList.add(Observable.range(0, 100000).subscribeOn(Schedulers.io())); sourceList.add(Observable.range(0, 100000).subscribeOn(Schedulers.io())); @@ -283,13 +278,13 @@ public void onNext(Integer t) { } @Test(timeout = 5000) public void testTake() throws Exception { - List> sourceList = new ArrayList>(3); + List> sourceList = new ArrayList<>(3); sourceList.add(Observable.range(0, 100000).subscribeOn(Schedulers.io())); sourceList.add(Observable.range(0, 100000).subscribeOn(Schedulers.io())); sourceList.add(Observable.range(0, 100000).subscribeOn(Schedulers.io())); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.merge(sourceList, 2).take(5).subscribe(ts); diff --git a/src/test/java/io/reactivex/internal/operators/OperatorMergeTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorMergeTest.java similarity index 77% rename from src/test/java/io/reactivex/internal/operators/OperatorMergeTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorMergeTest.java index 236b8e10e7..71d837a210 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorMergeTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorMergeTest.java @@ -74,18 +74,14 @@ public void testMergeObservableOfObservables() { final Observable o1 = Observable.create(new TestSynchronousObservable()); final Observable o2 = Observable.create(new TestSynchronousObservable()); - Observable> observableOfObservables = Observable.create(new Publisher>() { - - @Override - public void subscribe(Subscriber> observer) { + Observable> observableOfObservables = Observable.create(observer -> { observer.onSubscribe(EmptySubscription.INSTANCE); // simulate what would happen in an observable observer.onNext(o1); observer.onNext(o2); observer.onComplete(); } - - }); + ); Observable m = Observable.merge(observableOfObservables); m.subscribe(stringObserver); @@ -111,7 +107,7 @@ public void testMergeArray() { public void testMergeList() { final Observable o1 = Observable.create(new TestSynchronousObservable()); final Observable o2 = Observable.create(new TestSynchronousObservable()); - List> listOfObservables = new ArrayList>(); + List> listOfObservables = new ArrayList<>(); listOfObservables.add(o1); listOfObservables.add(o2); @@ -129,10 +125,7 @@ public void testUnSubscribeObservableOfObservables() throws InterruptedException final AtomicBoolean unsubscribed = new AtomicBoolean(); final CountDownLatch latch = new CountDownLatch(1); - Observable> source = Observable.create(new Publisher>() { - - @Override - public void subscribe(final Subscriber> observer) { + Observable> source = Observable.create(observer -> { // verbose on purpose so I can track the inside of it final Subscription s = new Subscription() { @@ -150,37 +143,29 @@ public void cancel() { }; observer.onSubscribe(s); - new Thread(new Runnable() { - - @Override - public void run() { - - while (!unsubscribed.get()) { - observer.onNext(Observable.just(1L, 2L)); - } - System.out.println("Done looping after unsubscribe: " + unsubscribed.get()); - observer.onComplete(); + new Thread(() -> { - // mark that the thread is finished - latch.countDown(); + while (!unsubscribed.get()) { + observer.onNext(Observable.just(1L, 2L)); } + System.out.println("Done looping after unsubscribe: " + unsubscribed.get()); + observer.onComplete(); + + // mark that the thread is finished + latch.countDown(); }).start(); } - }); + ); final AtomicInteger count = new AtomicInteger(); - Observable.merge(source).take(6).toBlocking().forEach(new Consumer() { - - @Override - public void accept(Long v) { - System.out.println("Value: " + v); - int c = count.incrementAndGet(); - if (c > 6) { - fail("Should be only 6"); - } - + Observable.merge(source).take(6).toBlocking().forEach((Consumer) v -> { + System.out.println("Value: " + v); + int c = count.incrementAndGet(); + if (c > 6) { + fail("Should be only 6"); } + }); latch.await(1000, TimeUnit.MILLISECONDS); @@ -197,7 +182,7 @@ public void testMergeArrayWithThreading() { final TestASynchronousObservable o2 = new TestASynchronousObservable(); Observable m = Observable.merge(Observable.create(o1), Observable.create(o2)); - TestSubscriber ts = new TestSubscriber(stringObserver); + TestSubscriber ts = new TestSubscriber<>(stringObserver); m.subscribe(ts); ts.awaitTerminalEvent(); @@ -343,14 +328,9 @@ public void testError2() { @Test @Ignore("Subscribe should not throw") public void testThrownErrorHandling() { - TestSubscriber ts = new TestSubscriber(); - Observable o1 = Observable.create(new Publisher() { - - @Override - public void subscribe(Subscriber s) { - throw new RuntimeException("fail"); - } - + TestSubscriber ts = new TestSubscriber<>(); + Observable o1 = Observable.create(s -> { + throw new RuntimeException("fail"); }); Observable.merge(o1, o1).subscribe(ts); @@ -376,21 +356,16 @@ private static class TestASynchronousObservable implements Publisher { @Override public void subscribe(final Subscriber observer) { observer.onSubscribe(EmptySubscription.INSTANCE); - t = new Thread(new Runnable() { - - @Override - public void run() { - onNextBeingSent.countDown(); - try { - observer.onNext("hello"); - // I can't use a countDownLatch to prove we are actually sending 'onNext' - // since it will block if synchronized and I'll deadlock - observer.onComplete(); - } catch (Exception e) { - observer.onError(e); - } + t = new Thread(() -> { + onNextBeingSent.countDown(); + try { + observer.onNext("hello"); + // I can't use a countDownLatch to prove we are actually sending 'onNext' + // since it will block if synchronized and I'll deadlock + observer.onComplete(); + } catch (Exception e) { + observer.onError(e); } - }, "TestASynchronousObservable"); t.start(); } @@ -429,7 +404,7 @@ public void testUnsubscribeAsObservablesComplete() { AtomicBoolean os2 = new AtomicBoolean(false); Observable o2 = createObservableOf5IntervalsOf1SecondIncrementsWithSubscriptionHook(scheduler2, os2); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.merge(o1, o2).subscribe(ts); // we haven't incremented time so nothing should be received yet @@ -471,7 +446,7 @@ public void testEarlyUnsubscribe() { AtomicBoolean os2 = new AtomicBoolean(false); Observable o2 = createObservableOf5IntervalsOf1SecondIncrementsWithSubscriptionHook(scheduler2, os2); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.merge(o1, o2).subscribe(ts); // we haven't incremented time so nothing should be received yet @@ -498,49 +473,44 @@ public void testEarlyUnsubscribe() { } private Observable createObservableOf5IntervalsOf1SecondIncrementsWithSubscriptionHook(final Scheduler scheduler, final AtomicBoolean unsubscribed) { - return Observable.create(new Publisher() { + return Observable.create(child -> Observable.interval(1, TimeUnit.SECONDS, scheduler) + .take(5) + .subscribe(new Subscriber() { + @Override + public void onSubscribe(final Subscription s) { + child.onSubscribe(new Subscription() { + @Override + public void request(long n) { + s.request(n); + } - @Override - public void subscribe(final Subscriber child) { - Observable.interval(1, TimeUnit.SECONDS, scheduler) - .take(5) - .subscribe(new Subscriber() { - @Override - public void onSubscribe(final Subscription s) { - child.onSubscribe(new Subscription() { - @Override - public void request(long n) { - s.request(n); - } - - @Override - public void cancel() { - unsubscribed.set(true); - s.cancel(); - } - }); - } - - @Override - public void onNext(Long t) { - child.onNext(t); - } - - @Override - public void onError(Throwable t) { - unsubscribed.set(true); - child.onError(t); - } - - @Override - public void onComplete() { - unsubscribed.set(true); - child.onComplete(); - } - - }); - } - }); + @Override + public void cancel() { + unsubscribed.set(true); + s.cancel(); + } + }); + } + + @Override + public void onNext(Long t) { + child.onNext(t); + } + + @Override + public void onError(Throwable t) { + unsubscribed.set(true); + child.onError(t); + } + + @Override + public void onComplete() { + unsubscribed.set(true); + child.onComplete(); + } + + }) + ); } @Test//(timeout = 10000) @@ -549,7 +519,7 @@ public void testConcurrency() { for (int i = 0; i < 10; i++) { Observable merge = Observable.merge(o.onBackpressureBuffer(), o.onBackpressureBuffer(), o.onBackpressureBuffer()); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); merge.subscribe(ts); ts.awaitTerminalEvent(3, TimeUnit.SECONDS); @@ -565,10 +535,7 @@ public void testConcurrency() { @Test public void testConcurrencyWithSleeping() { - Observable o = Observable.create(new Publisher() { - - @Override - public void subscribe(final Subscriber s) { + Observable o = Observable.create(s -> { Worker inner = Schedulers.newThread().createWorker(); final AsyncSubscription as = new AsyncSubscription(); as.setSubscription(EmptySubscription.INSTANCE); @@ -576,33 +543,28 @@ public void subscribe(final Subscriber s) { s.onSubscribe(as); - inner.schedule(new Runnable() { - - @Override - public void run() { - try { - for (int i = 0; i < 100; i++) { - s.onNext(1); - try { - Thread.sleep(1); - } catch (InterruptedException e) { - e.printStackTrace(); - } + inner.schedule(() -> { + try { + for (int i = 0; i < 100; i++) { + s.onNext(1); + try { + Thread.sleep(1); + } catch (InterruptedException e) { + e.printStackTrace(); } - } catch (Exception e) { - s.onError(e); } - as.dispose(); - s.onComplete(); + } catch (Exception e) { + s.onError(e); } - + as.dispose(); + s.onComplete(); }); } - }); + ); for (int i = 0; i < 10; i++) { Observable merge = Observable.merge(o, o, o); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); merge.subscribe(ts); ts.awaitTerminalEvent(); @@ -615,10 +577,7 @@ public void run() { @Test public void testConcurrencyWithBrokenOnCompleteContract() { - Observable o = Observable.create(new Publisher() { - - @Override - public void subscribe(final Subscriber s) { + Observable o = Observable.create(s -> { Worker inner = Schedulers.newThread().createWorker(); final AsyncSubscription as = new AsyncSubscription(); as.setSubscription(EmptySubscription.INSTANCE); @@ -626,30 +585,25 @@ public void subscribe(final Subscriber s) { s.onSubscribe(as); - inner.schedule(new Runnable() { - - @Override - public void run() { - try { - for (int i = 0; i < 10000; i++) { - s.onNext(i); - } - } catch (Exception e) { - s.onError(e); + inner.schedule(() -> { + try { + for (int i = 0; i < 10000; i++) { + s.onNext(i); } - as.dispose(); - s.onComplete(); - s.onComplete(); - s.onComplete(); + } catch (Exception e) { + s.onError(e); } - + as.dispose(); + s.onComplete(); + s.onComplete(); + s.onComplete(); }); } - }); + ); for (int i = 0; i < 10; i++) { Observable merge = Observable.merge(o.onBackpressureBuffer(), o.onBackpressureBuffer(), o.onBackpressureBuffer()); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); merge.subscribe(ts); ts.awaitTerminalEvent(); @@ -774,15 +728,7 @@ public void onNext(Integer t) { @Test public void testBackpressureBothUpstreamAndDownstreamWithSynchronousScalarObservables() throws InterruptedException { final AtomicInteger generated1 = new AtomicInteger(); - Observable> o1 = createInfiniteObservable(generated1) - .map(new Function>() { - - @Override - public Observable apply(Integer t1) { - return Observable.just(t1); - } - - }); + final Observable> o1 = createInfiniteObservable(generated1).map(Observable::just); TestSubscriber testSubscriber = new TestSubscriber() { @Override @@ -827,14 +773,7 @@ public void onNext(Integer t) { @Test(timeout = 5000) public void testBackpressureBothUpstreamAndDownstreamWithRegularObservables() throws InterruptedException { final AtomicInteger generated1 = new AtomicInteger(); - Observable> o1 = createInfiniteObservable(generated1).map(new Function>() { - - @Override - public Observable apply(Integer t1) { - return Observable.just(1, 2, 3); - } - - }); + final Observable> o1 = createInfiniteObservable(generated1).map(t1 -> Observable.just(1, 2, 3)); TestSubscriber testSubscriber = new TestSubscriber() { int i = 0; @@ -872,7 +811,7 @@ public void onNext(Integer t) { @Ignore("Null values not permitted") public void mergeWithNullValues() { System.out.println("mergeWithNullValues"); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.merge(Observable.just(null, "one"), Observable.just("two", null)).subscribe(ts); ts.assertTerminated(); ts.assertNoErrors(); @@ -883,18 +822,14 @@ public void mergeWithNullValues() { @Ignore("Null values are no longer permitted") public void mergeWithTerminalEventAfterUnsubscribe() { System.out.println("mergeWithTerminalEventAfterUnsubscribe"); - TestSubscriber ts = new TestSubscriber(); - Observable bad = Observable.create(new Publisher() { - - @Override - public void subscribe(Subscriber s) { + TestSubscriber ts = new TestSubscriber<>(); + Observable bad = Observable.create(s -> { s.onNext("two"); // FIXME can't cancel downstream // s.unsubscribe(); // s.onComplete(); } - - }); + ); Observable.merge(Observable.just(null, "one"), bad).subscribe(ts); ts.assertNoErrors(); ts.assertValues(null, "one", "two"); @@ -903,7 +838,7 @@ public void subscribe(Subscriber s) { @Test @Ignore("Null values are not permitted") public void mergingNullObservable() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.merge(Observable.just("one"), null).subscribe(ts); ts.assertNoErrors(); ts.assertValue("one"); @@ -911,7 +846,7 @@ public void mergingNullObservable() { @Test public void merge1AsyncStreamOf1() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); mergeNAsyncStreamsOfN(1, 1).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); @@ -920,7 +855,7 @@ public void merge1AsyncStreamOf1() { @Test public void merge1AsyncStreamOf1000() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); mergeNAsyncStreamsOfN(1, 1000).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); @@ -929,7 +864,7 @@ public void merge1AsyncStreamOf1000() { @Test public void merge10AsyncStreamOf1000() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); mergeNAsyncStreamsOfN(10, 1000).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); @@ -938,7 +873,7 @@ public void merge10AsyncStreamOf1000() { @Test public void merge1000AsyncStreamOf1000() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); mergeNAsyncStreamsOfN(1000, 1000).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); @@ -947,7 +882,7 @@ public void merge1000AsyncStreamOf1000() { @Test public void merge2000AsyncStreamOf100() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); mergeNAsyncStreamsOfN(2000, 100).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); @@ -956,7 +891,7 @@ public void merge2000AsyncStreamOf100() { @Test public void merge100AsyncStreamOf1() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); mergeNAsyncStreamsOfN(100, 1).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); @@ -964,21 +899,14 @@ public void merge100AsyncStreamOf1() { } private Observable mergeNAsyncStreamsOfN(final int outerSize, final int innerSize) { - Observable> os = Observable.range(1, outerSize) - .map(new Function>() { - - @Override - public Observable apply(Integer i) { - return Observable.range(1, innerSize).subscribeOn(Schedulers.computation()); - } - - }); + final Observable> os = Observable.range(1, outerSize) + .map(i -> Observable.range(1, innerSize).subscribeOn(Schedulers.computation())); return Observable.merge(os); } @Test public void merge1SyncStreamOf1() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); mergeNSyncStreamsOfN(1, 1).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); @@ -987,7 +915,7 @@ public void merge1SyncStreamOf1() { @Test public void merge1SyncStreamOf1000000() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); mergeNSyncStreamsOfN(1, 1000000).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); @@ -996,7 +924,7 @@ public void merge1SyncStreamOf1000000() { @Test public void merge1000SyncStreamOf1000() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); mergeNSyncStreamsOfN(1000, 1000).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); @@ -1005,7 +933,7 @@ public void merge1000SyncStreamOf1000() { @Test public void merge10000SyncStreamOf10() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); mergeNSyncStreamsOfN(10000, 10).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); @@ -1014,7 +942,7 @@ public void merge10000SyncStreamOf10() { @Test public void merge1000000SyncStreamOf1() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); mergeNSyncStreamsOfN(1000000, 1).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); @@ -1022,71 +950,46 @@ public void merge1000000SyncStreamOf1() { } private Observable mergeNSyncStreamsOfN(final int outerSize, final int innerSize) { - Observable> os = Observable.range(1, outerSize) - .map(new Function>() { - - @Override - public Observable apply(Integer i) { - return Observable.range(1, innerSize); - } - - }); + final Observable> os = Observable.range(1, outerSize) + .map(i -> Observable.range(1, innerSize)); return Observable.merge(os); } private Observable createInfiniteObservable(final AtomicInteger generated) { - Observable observable = Observable.fromIterable(new Iterable() { + return Observable.fromIterable(() -> new Iterator() { @Override - public Iterator iterator() { - return new Iterator() { - - @Override - public void remove() { - } + public void remove() { + } - @Override - public Integer next() { - return generated.getAndIncrement(); - } + @Override + public Integer next() { + return generated.getAndIncrement(); + } - @Override - public boolean hasNext() { - return true; - } - }; + @Override + public boolean hasNext() { + return true; } }); - return observable; } @Test public void mergeManyAsyncSingle() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable> os = Observable.range(1, 10000) - .map(new Function>() { - - @Override - public Observable apply(final Integer i) { - return Observable.create(new Publisher() { - - @Override - public void subscribe(Subscriber s) { - s.onSubscribe(EmptySubscription.INSTANCE); - if (i < 500) { - try { - Thread.sleep(1); - } catch (InterruptedException e) { - e.printStackTrace(); - } - } - s.onNext(i); - s.onComplete(); + .map(i -> Observable.create(s -> { + s.onSubscribe(EmptySubscription.INSTANCE); + if (i < 500) { + try { + Thread.sleep(1); + } catch (InterruptedException e) { + e.printStackTrace(); } - - }).subscribeOn(Schedulers.computation()).cache(); + } + s.onNext(i); + s.onComplete(); } - - }); + ).subscribeOn(Schedulers.computation()).cache()); Observable.merge(os).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); @@ -1096,7 +999,7 @@ public void subscribe(Subscriber s) { @Test public void shouldCompleteAfterApplyingBackpressure_NormalPath() { Observable source = Observable.mergeDelayError(Observable.just(Observable.range(1, 2))); - TestSubscriber subscriber = new TestSubscriber((Long)null); + TestSubscriber subscriber = new TestSubscriber<>((Long) null); source.subscribe(subscriber); subscriber.request(3); // 1, 2, - with request(2) we get the 1 and 2 but not the subscriber.assertValues(1, 2); @@ -1106,7 +1009,7 @@ public void shouldCompleteAfterApplyingBackpressure_NormalPath() { @Test public void shouldCompleteAfterApplyingBackpressure_FastPath() { Observable source = Observable.mergeDelayError(Observable.just(Observable.just(1))); - TestSubscriber subscriber = new TestSubscriber((Long)null); + TestSubscriber subscriber = new TestSubscriber<>((Long) null); source.subscribe(subscriber); subscriber.request(2); // 1, - should work as per .._NormalPath above subscriber.assertValue(1); @@ -1117,7 +1020,7 @@ public void shouldCompleteAfterApplyingBackpressure_FastPath() { public void shouldNotCompleteIfThereArePendingScalarSynchronousEmissionsWhenTheLastInnerSubscriberCompletes() { TestScheduler scheduler = Schedulers.test(); Observable source = Observable.mergeDelayError(Observable.just(1L), Observable.timer(1, TimeUnit.SECONDS, scheduler).skip(1)); - TestSubscriber subscriber = new TestSubscriber((Long)null); + TestSubscriber subscriber = new TestSubscriber<>((Long) null); source.subscribe(subscriber); scheduler.advanceTimeBy(1, TimeUnit.SECONDS); subscriber.assertNoValues(); @@ -1134,7 +1037,7 @@ public void shouldNotCompleteIfThereArePendingScalarSynchronousEmissionsWhenTheL public void delayedErrorsShouldBeEmittedWhenCompleteAfterApplyingBackpressure_NormalPath() { Throwable exception = new Throwable(); Observable source = Observable.mergeDelayError(Observable.range(1, 2), Observable.error(exception)); - TestSubscriber subscriber = new TestSubscriber((Long)null); + TestSubscriber subscriber = new TestSubscriber<>((Long) null); source.subscribe(subscriber); subscriber.request(3); // 1, 2, subscriber.assertValues(1, 2); @@ -1146,7 +1049,7 @@ public void delayedErrorsShouldBeEmittedWhenCompleteAfterApplyingBackpressure_No public void delayedErrorsShouldBeEmittedWhenCompleteAfterApplyingBackpressure_FastPath() { Throwable exception = new Throwable(); Observable source = Observable.mergeDelayError(Observable.just(1), Observable.error(exception)); - TestSubscriber subscriber = new TestSubscriber((Long)null); + TestSubscriber subscriber = new TestSubscriber<>((Long) null); source.subscribe(subscriber); subscriber.request(2); // 1, subscriber.assertValue(1); @@ -1157,7 +1060,7 @@ public void delayedErrorsShouldBeEmittedWhenCompleteAfterApplyingBackpressure_Fa @Test public void shouldNotCompleteWhileThereAreStillScalarSynchronousEmissionsInTheQueue() { Observable source = Observable.merge(Observable.just(1), Observable.just(2)); - TestSubscriber subscriber = new TestSubscriber(1L); + TestSubscriber subscriber = new TestSubscriber<>(1L); source.subscribe(subscriber); subscriber.assertValue(1); subscriber.request(1); @@ -1168,7 +1071,7 @@ public void shouldNotCompleteWhileThereAreStillScalarSynchronousEmissionsInTheQu public void shouldNotReceivedDelayedErrorWhileThereAreStillScalarSynchronousEmissionsInTheQueue() { Throwable exception = new Throwable(); Observable source = Observable.mergeDelayError(Observable.just(1), Observable.just(2), Observable.error(exception)); - TestSubscriber subscriber = new TestSubscriber((Long)null); + TestSubscriber subscriber = new TestSubscriber<>((Long) null); subscriber.request(1); source.subscribe(subscriber); subscriber.assertValue(1); @@ -1182,7 +1085,7 @@ public void shouldNotReceivedDelayedErrorWhileThereAreStillScalarSynchronousEmis public void shouldNotReceivedDelayedErrorWhileThereAreStillNormalEmissionsInTheQueue() { Throwable exception = new Throwable(); Observable source = Observable.mergeDelayError(Observable.range(1, 2), Observable.range(3, 2), Observable.error(exception)); - TestSubscriber subscriber = new TestSubscriber((Long)null); + TestSubscriber subscriber = new TestSubscriber<>((Long) null); subscriber.request(3); source.subscribe(subscriber); subscriber.assertValues(1, 2, 3); @@ -1197,50 +1100,26 @@ public void testMergeKeepsRequesting() throws InterruptedException { //for (int i = 0; i < 5000; i++) { //System.out.println(i + "......................................................................."); final CountDownLatch latch = new CountDownLatch(1); - final ConcurrentLinkedQueue messages = new ConcurrentLinkedQueue(); + final ConcurrentLinkedQueue messages = new ConcurrentLinkedQueue<>(); Observable.range(1, 2) - // produce many integers per second - .flatMap(new Function>() { - @Override - public Observable apply(final Integer number) { - return Observable.range(1, Integer.MAX_VALUE) - .doOnRequest(new LongConsumer() { - - @Override - public void accept(long n) { - messages.add(">>>>>>>> A requested[" + number + "]: " + n); - } - - }) - // pause a bit - .doOnNext(pauseForMs(3)) - // buffer on backpressure - .onBackpressureBuffer() - // do in parallel - .subscribeOn(Schedulers.computation()) - .doOnRequest(new LongConsumer() { - - @Override - public void accept(long n) { - messages.add(">>>>>>>> B requested[" + number + "]: " + n); - } - - }); - } - - }) - // take a number bigger than 2* Observable.bufferSize() (used by OperatorMerge) - .take(Observable.bufferSize() * 2 + 1) - // log count - .doOnNext(printCount()) - // release latch - .doOnComplete(new Runnable() { - @Override - public void run() { - latch.countDown(); - } - }).subscribe(); + // produce many integers per second + .flatMap(number -> Observable.range(1, Integer.MAX_VALUE) + .doOnRequest(n -> messages.add(">>>>>>>> A requested[" + number + "]: " + n)) + // pause a bit + .doOnNext(pauseForMs(3)) + // buffer on backpressure + .onBackpressureBuffer() + // do in parallel + .subscribeOn(Schedulers.computation()) + .doOnRequest(n -> messages.add(">>>>>>>> B requested[" + number + "]: " + n))) + // take a number bigger than 2* Observable.bufferSize() (used by OperatorMerge) + .take(Observable.bufferSize() * 2 + 1) + // log count + .doOnNext(printCount()) + // release latch + .doOnComplete(latch::countDown) + .subscribe(); boolean a = latch.await(2, TimeUnit.SECONDS); if (!a) { for (String s : messages) { @@ -1297,35 +1176,21 @@ public void accept(Integer t1) { } private static Consumer pauseForMs(final long time) { - return new Consumer() { - @Override - public void accept(Integer s) { - try { - Thread.sleep(time); - } catch (InterruptedException e) { - throw new RuntimeException(e); - } + return s -> { + try { + Thread.sleep(time); + } catch (InterruptedException e) { + throw new RuntimeException(e); } }; } - Function> toScalar = new Function>() { - @Override - public Observable apply(Integer v) { - return Observable.just(v); - } - }; + Function> toScalar = Observable::just; - Function> toHiddenScalar = new Function>() { - @Override - public Observable apply(Integer t) { - return Observable.just(t).asObservable(); - } - }; - ; + Function> toHiddenScalar = t -> Observable.just(t).asObservable(); void runMerge(Function> func, TestSubscriber ts) { - List list = new ArrayList(); + List list = new ArrayList<>(); for (int i = 0; i < 1000; i++) { list.add(i); } @@ -1343,11 +1208,11 @@ void runMerge(Function> func, TestSubscriber()); + runMerge(toScalar, new TestSubscriber<>()); } @Test public void testFastMergeHiddenScalar() { - runMerge(toHiddenScalar, new TestSubscriber()); + runMerge(toHiddenScalar, new TestSubscriber<>()); } @Test public void testSlowMergeFullScalar() { diff --git a/src/test/java/io/reactivex/internal/operators/OperatorMulticastTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorMulticastTest.java similarity index 100% rename from src/test/java/io/reactivex/internal/operators/OperatorMulticastTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorMulticastTest.java diff --git a/src/test/java/io/reactivex/internal/operators/OperatorObserveOnTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorObserveOnTest.java similarity index 98% rename from src/test/java/io/reactivex/internal/operators/OperatorObserveOnTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorObserveOnTest.java index 8e5d91271e..90c7889179 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorObserveOnTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorObserveOnTest.java @@ -63,7 +63,7 @@ public void testOrdering() throws InterruptedException { Subscriber observer = TestHelper.mockSubscriber(); InOrder inOrder = inOrder(observer); - TestSubscriber ts = new TestSubscriber(observer); + TestSubscriber ts = new TestSubscriber<>(observer); obs.observeOn(Schedulers.computation()).subscribe(ts); @@ -389,7 +389,7 @@ public void testAfterUnsubscribeCalledThenObserverOnNextNeverCalled() { final TestScheduler testScheduler = new TestScheduler(); final Subscriber observer = TestHelper.mockSubscriber(); - TestSubscriber ts = new TestSubscriber(observer); + TestSubscriber ts = new TestSubscriber<>(observer); Observable.just(1, 2, 3) .observeOn(testScheduler) @@ -524,7 +524,7 @@ public boolean hasNext() { } }); - TestSubscriber testSubscriber = new TestSubscriber(); + TestSubscriber testSubscriber = new TestSubscriber<>(); observable .take(7) .observeOn(Schedulers.newThread()) @@ -552,7 +552,7 @@ public void subscribe(Subscriber o) { }); - TestSubscriber testSubscriber = new TestSubscriber(new Observer() { + TestSubscriber testSubscriber = new TestSubscriber<>(new Observer() { @Override public void onComplete() { @@ -595,7 +595,7 @@ public void onNext(Integer t) { @Test public void testAsyncChild() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.range(0, 100000).observeOn(Schedulers.newThread()).observeOn(Schedulers.newThread()).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); @@ -607,18 +607,18 @@ public void testOnErrorCutsAheadOfOnNext() { final PublishSubject subject = PublishSubject.create(); final AtomicLong counter = new AtomicLong(); - TestSubscriber ts = new TestSubscriber(new Observer() { - + TestSubscriber ts = new TestSubscriber<>(new Observer() { + @Override public void onComplete() { - + } - + @Override public void onError(Throwable e) { - + } - + @Override public void onNext(Long t) { // simulate slow consumer to force backpressure failure @@ -627,7 +627,7 @@ public void onNext(Long t) { } catch (InterruptedException e) { } } - + }); subject.observeOn(Schedulers.computation()).subscribe(ts); @@ -654,7 +654,7 @@ public void onNext(Long t) { */ @Test public void testHotOperatorBackpressure() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.interval(0, 1, TimeUnit.MICROSECONDS) .observeOn(Schedulers.computation()) .map(new Function() { @@ -702,7 +702,7 @@ public void accept(Try> n) { }); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.combineLatest(timer, Observable. never(), new BiFunction() { @@ -762,7 +762,7 @@ public void onNext(Integer t) { @Test public void testNoMoreRequestsAfterUnsubscribe() throws InterruptedException { final CountDownLatch latch = new CountDownLatch(1); - final List requests = Collections.synchronizedList(new ArrayList()); + final List requests = Collections.synchronizedList(new ArrayList<>()); Observable.range(1, 1000000) .doOnRequest(new LongConsumer() { diff --git a/src/test/java/io/reactivex/internal/operators/OperatorOnBackpressureBufferTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorOnBackpressureBufferTest.java similarity index 89% rename from src/test/java/io/reactivex/internal/operators/OperatorOnBackpressureBufferTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorOnBackpressureBufferTest.java index 548c70da4e..21c05247c6 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorOnBackpressureBufferTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorOnBackpressureBufferTest.java @@ -30,7 +30,7 @@ public class OperatorOnBackpressureBufferTest { @Test public void testNoBackpressureSupport() { - TestSubscriber ts = new TestSubscriber((Long)null); + TestSubscriber ts = new TestSubscriber<>((Long) null); // this will be ignored ts.request(100); // we take 500 so it unsubscribes @@ -44,12 +44,12 @@ public void testNoBackpressureSupport() { public void testFixBackpressureWithBuffer() throws InterruptedException { final CountDownLatch l1 = new CountDownLatch(100); final CountDownLatch l2 = new CountDownLatch(150); - TestSubscriber ts = new TestSubscriber(new Observer() { + TestSubscriber ts = new TestSubscriber<>(new Observer() { @Override protected void onStart() { } - + @Override public void onComplete() { } @@ -101,17 +101,19 @@ public void testFixBackpressureBufferZeroCapacity() throws InterruptedException public void testFixBackpressureBoundedBuffer() throws InterruptedException { final CountDownLatch l1 = new CountDownLatch(100); final CountDownLatch backpressureCallback = new CountDownLatch(1); - TestSubscriber ts = new TestSubscriber(new Observer() { + TestSubscriber ts = new TestSubscriber<>(new Observer() { @Override protected void onStart() { } - + @Override - public void onComplete() { } + public void onComplete() { + } @Override - public void onError(Throwable e) { } + public void onError(Throwable e) { + } @Override public void onNext(Long t) { @@ -122,12 +124,7 @@ public void onNext(Long t) { ts.request(100); infinite.subscribeOn(Schedulers.computation()) - .onBackpressureBuffer(500, new Runnable() { - @Override - public void run() { - backpressureCallback.countDown(); - } - }) + .onBackpressureBuffer(500, backpressureCallback::countDown) /*.take(1000)*/ .subscribe(ts); l1.await(); diff --git a/src/test/java/io/reactivex/internal/operators/OperatorOnBackpressureDropTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorOnBackpressureDropTest.java similarity index 95% rename from src/test/java/io/reactivex/internal/operators/OperatorOnBackpressureDropTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorOnBackpressureDropTest.java index 8c0dab953f..afe2b9bcee 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorOnBackpressureDropTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorOnBackpressureDropTest.java @@ -30,7 +30,7 @@ public class OperatorOnBackpressureDropTest { @Test public void testNoBackpressureSupport() { - TestSubscriber ts = new TestSubscriber((Long)null); + TestSubscriber ts = new TestSubscriber<>((Long) null); // this will be ignored ts.request(100); // we take 500 so it unsubscribes @@ -42,7 +42,7 @@ public void testNoBackpressureSupport() { @Test(timeout = 500) public void testWithObserveOn() throws InterruptedException { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.range(0, Observable.bufferSize() * 10).onBackpressureDrop().observeOn(Schedulers.io()).subscribe(ts); ts.awaitTerminalEvent(); } @@ -51,12 +51,12 @@ public void testWithObserveOn() throws InterruptedException { public void testFixBackpressureWithBuffer() throws InterruptedException { final CountDownLatch l1 = new CountDownLatch(100); final CountDownLatch l2 = new CountDownLatch(150); - TestSubscriber ts = new TestSubscriber(new Observer() { + TestSubscriber ts = new TestSubscriber<>(new Observer() { @Override protected void onStart() { } - + @Override public void onComplete() { } diff --git a/src/test/java/io/reactivex/internal/operators/OperatorOnBackpressureLatestTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorOnBackpressureLatestTest.java similarity index 92% rename from src/test/java/io/reactivex/internal/operators/OperatorOnBackpressureLatestTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorOnBackpressureLatestTest.java index 49ff71098b..07a461ff5d 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorOnBackpressureLatestTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorOnBackpressureLatestTest.java @@ -27,7 +27,7 @@ public class OperatorOnBackpressureLatestTest { @Test public void testSimple() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.range(1, 5).onBackpressureLatest().subscribe(ts); @@ -37,7 +37,7 @@ public void testSimple() { } @Test public void testSimpleError() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.range(1, 5).concatWith(Observable.error(new TestException())) .onBackpressureLatest().subscribe(ts); @@ -48,7 +48,7 @@ public void testSimpleError() { } @Test public void testSimpleBackpressure() { - TestSubscriber ts = new TestSubscriber(2L); + TestSubscriber ts = new TestSubscriber<>(2L); Observable.range(1, 5).onBackpressureLatest().subscribe(ts); @@ -60,7 +60,7 @@ public void testSimpleBackpressure() { @Test public void testSynchronousDrop() { PublishSubject source = PublishSubject.create(); - TestSubscriber ts = new TestSubscriber((Long)null); + TestSubscriber ts = new TestSubscriber<>((Long) null); source.onBackpressureLatest().subscribe(ts); diff --git a/src/test/java/io/reactivex/internal/operators/OperatorOnErrorResumeNextViaFunctionTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorOnErrorResumeNextViaFunctionTest.java similarity index 97% rename from src/test/java/io/reactivex/internal/operators/OperatorOnErrorResumeNextViaFunctionTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorOnErrorResumeNextViaFunctionTest.java index aae1550b65..11ed297919 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorOnErrorResumeNextViaFunctionTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorOnErrorResumeNextViaFunctionTest.java @@ -34,7 +34,7 @@ public class OperatorOnErrorResumeNextViaFunctionTest { @Test public void testResumeNextWithSynchronousExecution() { - final AtomicReference receivedException = new AtomicReference(); + final AtomicReference receivedException = new AtomicReference<>(); Observable w = Observable.create(new Publisher() { @Override @@ -74,7 +74,7 @@ public Observable apply(Throwable t1) { @Test public void testResumeNextWithAsyncExecution() { - final AtomicReference receivedException = new AtomicReference(); + final AtomicReference receivedException = new AtomicReference<>(); Subscription s = mock(Subscription.class); TestObservable w = new TestObservable(s, "one"); Function> resume = new Function>() { @@ -150,7 +150,7 @@ public Observable apply(Throwable t1) { @Test @Ignore("Failed operator may leave the child subscriber in an inconsistent state which prevents further error delivery.") public void testOnErrorResumeReceivesErrorFromPreviousNonProtectedOperator() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.just(1).lift(new Operator() { @Override @@ -183,7 +183,7 @@ public Observable apply(Throwable t1) { @Test @Ignore("A crashing operator may leave the downstream in an inconsistent state and not suitable for event delivery") public void testOnErrorResumeReceivesErrorFromPreviousNonProtectedOperatorOnNext() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.just(1).lift(new Operator() { @Override @@ -260,7 +260,7 @@ public Observable apply(Throwable t1) { @SuppressWarnings("unchecked") Observer observer = mock(Observer.class); - TestSubscriber ts = new TestSubscriber(observer, Long.MAX_VALUE); + TestSubscriber ts = new TestSubscriber<>(observer, Long.MAX_VALUE); observable.subscribe(ts); ts.awaitTerminalEvent(); @@ -312,7 +312,7 @@ public void run() { @Test public void testBackpressure() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.range(0, 100000) .onErrorResumeNext(new Function>() { diff --git a/src/test/java/io/reactivex/internal/operators/OperatorOnErrorResumeNextViaObservableTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorOnErrorResumeNextViaObservableTest.java similarity index 98% rename from src/test/java/io/reactivex/internal/operators/OperatorOnErrorResumeNextViaObservableTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorOnErrorResumeNextViaObservableTest.java index e77335b9d3..de7ee76895 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorOnErrorResumeNextViaObservableTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorOnErrorResumeNextViaObservableTest.java @@ -135,7 +135,7 @@ public void subscribe(Subscriber t1) { @SuppressWarnings("unchecked") Observer observer = mock(Observer.class); - TestSubscriber ts = new TestSubscriber(observer, Long.MAX_VALUE); + TestSubscriber ts = new TestSubscriber<>(observer, Long.MAX_VALUE); observable.subscribe(ts); ts.awaitTerminalEvent(); @@ -189,7 +189,7 @@ public void run() { @Test public void testBackpressure() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.range(0, 100000) .onErrorResumeNext(Observable.just(1)) .observeOn(Schedulers.computation()) diff --git a/src/test/java/io/reactivex/internal/operators/OperatorOnErrorReturnTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorOnErrorReturnTest.java similarity index 97% rename from src/test/java/io/reactivex/internal/operators/OperatorOnErrorReturnTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorOnErrorReturnTest.java index a830da3716..f2e66638f0 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorOnErrorReturnTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorOnErrorReturnTest.java @@ -35,7 +35,7 @@ public class OperatorOnErrorReturnTest { public void testResumeNext() { TestObservable f = new TestObservable("one"); Observable w = Observable.create(f); - final AtomicReference capturedException = new AtomicReference(); + final AtomicReference capturedException = new AtomicReference<>(); Observable observable = w.onErrorReturn(new Function() { @@ -71,7 +71,7 @@ public String apply(Throwable e) { public void testFunctionThrowsError() { TestObservable f = new TestObservable("one"); Observable w = Observable.create(f); - final AtomicReference capturedException = new AtomicReference(); + final AtomicReference capturedException = new AtomicReference<>(); Observable observable = w.onErrorReturn(new Function() { @@ -130,7 +130,7 @@ public String apply(Throwable t1) { @SuppressWarnings("unchecked") Observer observer = mock(Observer.class); - TestSubscriber ts = new TestSubscriber(observer, Long.MAX_VALUE); + TestSubscriber ts = new TestSubscriber<>(observer, Long.MAX_VALUE); observable.subscribe(ts); ts.awaitTerminalEvent(); @@ -144,7 +144,7 @@ public String apply(Throwable t1) { @Test public void testBackpressure() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.range(0, 100000) .onErrorReturn(new Function() { diff --git a/src/test/java/io/reactivex/internal/operators/OperatorOnExceptionResumeNextViaObservableTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorOnExceptionResumeNextViaObservableTest.java similarity index 81% rename from src/test/java/io/reactivex/internal/operators/OperatorOnExceptionResumeNextViaObservableTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorOnExceptionResumeNextViaObservableTest.java index 9faed28124..8eec036695 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorOnExceptionResumeNextViaObservableTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorOnExceptionResumeNextViaObservableTest.java @@ -46,7 +46,7 @@ public void testResumeNextWithException() { fail(e.getMessage()); } - verify(observer).onSubscribe((Subscription)any()); + verify(observer).onSubscribe(any()); verify(observer, times(1)).onNext("one"); verify(observer, Mockito.never()).onNext("two"); verify(observer, Mockito.never()).onNext("three"); @@ -74,7 +74,7 @@ public void testResumeNextWithRuntimeException() { fail(e.getMessage()); } - verify(observer).onSubscribe((Subscription)any()); + verify(observer).onSubscribe(any()); verify(observer, times(1)).onNext("one"); verify(observer, Mockito.never()).onNext("two"); verify(observer, Mockito.never()).onNext("three"); @@ -102,7 +102,7 @@ public void testThrowablePassesThru() { fail(e.getMessage()); } - verify(observer).onSubscribe((Subscription)any()); + verify(observer).onSubscribe(any()); verify(observer, times(1)).onNext("one"); verify(observer, never()).onNext("two"); verify(observer, never()).onNext("three"); @@ -130,7 +130,7 @@ public void testErrorPassesThru() { fail(e.getMessage()); } - verify(observer).onSubscribe((Subscription)any()); + verify(observer).onSubscribe(any()); verify(observer, times(1)).onNext("one"); verify(observer, never()).onNext("two"); verify(observer, never()).onNext("three"); @@ -151,14 +151,11 @@ public void testMapResumeAsyncNext() { // Introduce map function that fails intermittently (Map does not prevent this when the observer is a // rx.operator incl onErrorResumeNextViaObservable) - w = w.map(new Function() { - @Override - public String apply(String s) { - if ("fail".equals(s)) - throw new RuntimeException("Forced Failure"); - System.out.println("BadMapper:" + s); - return s; - } + w = w.map(s -> { + if ("fail".equals(s)) + throw new RuntimeException("Forced Failure"); + System.out.println("BadMapper:" + s); + return s; }); Observable observable = w.onExceptionResumeNext(resume); @@ -187,7 +184,7 @@ public String apply(String s) { @Test public void testBackpressure() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.range(0, 100000) .onExceptionResumeNext(Observable.just(1)) .observeOn(Schedulers.computation()) @@ -227,32 +224,27 @@ public TestObservable(String... values) { public void subscribe(final Subscriber observer) { observer.onSubscribe(EmptySubscription.INSTANCE); System.out.println("TestObservable subscribed to ..."); - t = new Thread(new Runnable() { - - @Override - public void run() { - try { - System.out.println("running TestObservable thread"); - for (String s : values) { - if ("EXCEPTION".equals(s)) - throw new Exception("Forced Exception"); - else if ("RUNTIMEEXCEPTION".equals(s)) - throw new RuntimeException("Forced RuntimeException"); - else if ("ERROR".equals(s)) - throw new Error("Forced Error"); - else if ("THROWABLE".equals(s)) - throw new Throwable("Forced Throwable"); - System.out.println("TestObservable onNext: " + s); - observer.onNext(s); - } - System.out.println("TestObservable onCompleted"); - observer.onComplete(); - } catch (Throwable e) { - System.out.println("TestObservable onError: " + e); - observer.onError(e); + t = new Thread(() -> { + try { + System.out.println("running TestObservable thread"); + for (String s : values) { + if ("EXCEPTION".equals(s)) + throw new Exception("Forced Exception"); + else if ("RUNTIMEEXCEPTION".equals(s)) + throw new RuntimeException("Forced RuntimeException"); + else if ("ERROR".equals(s)) + throw new Error("Forced Error"); + else if ("THROWABLE".equals(s)) + throw new Throwable("Forced Throwable"); + System.out.println("TestObservable onNext: " + s); + observer.onNext(s); } + System.out.println("TestObservable onCompleted"); + observer.onComplete(); + } catch (Throwable e) { + System.out.println("TestObservable onError: " + e); + observer.onError(e); } - }); System.out.println("starting TestObservable thread"); t.start(); diff --git a/src/test/java/io/reactivex/internal/operators/OperatorPublishTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorPublishTest.java similarity index 94% rename from src/test/java/io/reactivex/internal/operators/OperatorPublishTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorPublishTest.java index e75375d392..2d3803cc17 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorPublishTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorPublishTest.java @@ -121,7 +121,7 @@ public void run() { }); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.merge(fast, slow).subscribe(ts); is.connect(); ts.awaitTerminalEvent(); @@ -141,7 +141,7 @@ public void accept(Integer t1) { } }); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); xs.publish(new Function, Observable>() { @Override @@ -168,7 +168,7 @@ public boolean test(Integer i) { @Test public void testTakeUntilWithPublishedStream() { Observable xs = Observable.range(0, Observable.bufferSize() * 2); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); ConnectableObservable xsp = xs.publish(); xsp.takeUntil(xsp.skipWhile(new Predicate() { @@ -204,7 +204,7 @@ public void run() { final AtomicBoolean child1Unsubscribed = new AtomicBoolean(); final AtomicBoolean child2Unsubscribed = new AtomicBoolean(); - final TestSubscriber ts2 = new TestSubscriber(); + final TestSubscriber ts2 = new TestSubscriber<>(); final TestSubscriber ts1 = new TestSubscriber() { @Override @@ -252,7 +252,7 @@ public void testConnectWithNoSubscriber() { co.connect(); // Emit 0 scheduler.advanceTimeBy(15, TimeUnit.MILLISECONDS); - TestSubscriber subscriber = new TestSubscriber(); + TestSubscriber subscriber = new TestSubscriber<>(); co.subscribe(subscriber); // Emit 1 and 2 scheduler.advanceTimeBy(50, TimeUnit.MILLISECONDS); @@ -265,7 +265,7 @@ public void testConnectWithNoSubscriber() { public void testSubscribeAfterDisconnectThenConnect() { ConnectableObservable source = Observable.just(1).publish(); - TestSubscriber ts1 = new TestSubscriber(); + TestSubscriber ts1 = new TestSubscriber<>(); source.subscribe(ts1); @@ -275,7 +275,7 @@ public void testSubscribeAfterDisconnectThenConnect() { ts1.assertNoErrors(); ts1.assertTerminated(); - TestSubscriber ts2 = new TestSubscriber(); + TestSubscriber ts2 = new TestSubscriber<>(); source.subscribe(ts2); @@ -293,7 +293,7 @@ public void testSubscribeAfterDisconnectThenConnect() { public void testNoSubscriberRetentionOnCompleted() { OperatorPublish source = (OperatorPublish)Observable.just(1).publish(); - TestSubscriber ts1 = new TestSubscriber(); + TestSubscriber ts1 = new TestSubscriber<>(); source.unsafeSubscribe(ts1); @@ -345,7 +345,7 @@ static boolean checkPublishDisposed(Disposable d) { public void testZeroRequested() { ConnectableObservable source = Observable.just(1).publish(); - TestSubscriber ts = new TestSubscriber((Long)null); + TestSubscriber ts = new TestSubscriber<>((Long) null); source.subscribe(ts); @@ -398,9 +398,9 @@ public void testObserveOn() { Observable obs = co.observeOn(Schedulers.computation()); for (int i = 0; i < 1000; i++) { for (int j = 1; j < 6; j++) { - List> tss = new ArrayList>(); + List> tss = new ArrayList<>(); for (int k = 1; k < j; k++) { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); tss.add(ts); obs.subscribe(ts); } diff --git a/src/test/java/io/reactivex/internal/operators/OperatorReduceTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorReduceTest.java similarity index 100% rename from src/test/java/io/reactivex/internal/operators/OperatorReduceTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorReduceTest.java diff --git a/src/test/java/io/reactivex/internal/operators/OperatorRepeatTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorRepeatTest.java similarity index 86% rename from src/test/java/io/reactivex/internal/operators/OperatorRepeatTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorRepeatTest.java index 64f306e148..2d023b6229 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorRepeatTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorRepeatTest.java @@ -79,18 +79,13 @@ public void subscribe(Subscriber sub) { } }).subscribeOn(Schedulers.newThread()); - Object[] ys = oi.repeat().subscribeOn(Schedulers.newThread()).map(new Function() { - - @Override - public Integer apply(Integer t1) { - try { - Thread.sleep(50); - } catch (InterruptedException e) { - e.printStackTrace(); - } - return t1; + Object[] ys = oi.repeat().subscribeOn(Schedulers.newThread()).map(t1 -> { + try { + Thread.sleep(50); + } catch (InterruptedException e) { + e.printStackTrace(); } - + return t1; }).take(4).toList().toBlocking().last().toArray(); assertEquals(2, counter.get()); @@ -161,7 +156,7 @@ public void testRepeatAndDistinctUnbounded() { .repeat(3) .distinct(); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); src.subscribe(ts); @@ -173,18 +168,15 @@ public void testRepeatAndDistinctUnbounded() { /** Issue #2844: wrong target of request. */ @Test(timeout = 3000) public void testRepeatRetarget() { - final List concatBase = new ArrayList(); - TestSubscriber ts = new TestSubscriber(); + final List concatBase = new ArrayList<>(); + TestSubscriber ts = new TestSubscriber<>(); Observable.just(1, 2) .repeat(5) - .concatMap(new Function>() { - @Override - public Observable apply(Integer x) { - System.out.println("testRepeatRetarget -> " + x); - concatBase.add(x); - return Observable.empty() - .delay(200, TimeUnit.MILLISECONDS); - } + .concatMap(x -> { + System.out.println("testRepeatRetarget -> " + x); + concatBase.add(x); + return Observable.empty() + .delay(200, TimeUnit.MILLISECONDS); }) .subscribe(ts); diff --git a/src/test/java/io/reactivex/internal/operators/OperatorReplayTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorReplayTest.java similarity index 94% rename from src/test/java/io/reactivex/internal/operators/OperatorReplayTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorReplayTest.java index af3796b781..6c0c1e9e4f 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorReplayTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorReplayTest.java @@ -532,8 +532,8 @@ public void testIssue2191_UnsubscribeSource() { replay.subscribe(spiedSubscriberAfterConnect); replay.subscribe(spiedSubscriberAfterConnect); - verify(spiedSubscriberBeforeConnect, times(2)).onSubscribe((Subscription)any()); - verify(spiedSubscriberAfterConnect, times(2)).onSubscribe((Subscription)any()); + verify(spiedSubscriberBeforeConnect, times(2)).onSubscribe(any()); + verify(spiedSubscriberAfterConnect, times(2)).onSubscribe(any()); // verify interactions verify(sourceNext, times(1)).accept(1); @@ -585,8 +585,8 @@ public void testIssue2191_SchedulerUnsubscribe() throws Exception { replay.subscribe(mockObserverAfterConnect); replay.subscribe(mockObserverAfterConnect); - verify(mockObserverBeforeConnect, times(2)).onSubscribe((Subscription)any()); - verify(mockObserverAfterConnect, times(2)).onSubscribe((Subscription)any()); + verify(mockObserverBeforeConnect, times(2)).onSubscribe(any()); + verify(mockObserverAfterConnect, times(2)).onSubscribe(any()); // verify interactions verify(sourceNext, times(1)).accept(1); @@ -653,8 +653,8 @@ public void testIssue2191_SchedulerUnsubscribeOnError() throws Exception { replay.subscribe(mockObserverAfterConnect); replay.subscribe(mockObserverAfterConnect); - verify(mockObserverBeforeConnect, times(2)).onSubscribe((Subscription)any()); - verify(mockObserverAfterConnect, times(2)).onSubscribe((Subscription)any()); + verify(mockObserverBeforeConnect, times(2)).onSubscribe(any()); + verify(mockObserverAfterConnect, times(2)).onSubscribe(any()); // verify interactions verify(mockScheduler, times(1)).createWorker(); @@ -732,14 +732,14 @@ public void dispose() { @Test public void testBoundedReplayBuffer() { - BoundedReplayBuffer buf = new BoundedReplayBuffer(); + BoundedReplayBuffer buf = new BoundedReplayBuffer<>(); buf.addLast(new Node(1, 0)); buf.addLast(new Node(2, 1)); buf.addLast(new Node(3, 2)); buf.addLast(new Node(4, 3)); buf.addLast(new Node(5, 4)); - List values = new ArrayList(); + List values = new ArrayList<>(); buf.collect(values); Assert.assertEquals(Arrays.asList(1, 2, 3, 4, 5), values); @@ -763,8 +763,8 @@ public void testBoundedReplayBuffer() { @Test public void testTimedAndSizedTruncation() { TestScheduler test = Schedulers.test(); - SizeAndTimeBoundReplayBuffer buf = new SizeAndTimeBoundReplayBuffer(2, 2000, TimeUnit.MILLISECONDS, test); - List values = new ArrayList(); + SizeAndTimeBoundReplayBuffer buf = new SizeAndTimeBoundReplayBuffer<>(2, 2000, TimeUnit.MILLISECONDS, test); + List values = new ArrayList<>(); buf.next(1); test.advanceTimeBy(1, TimeUnit.SECONDS); @@ -809,8 +809,8 @@ public void accept(long t) { }); ConnectableObservable co = source.replay(); - TestSubscriber ts1 = new TestSubscriber(10L); - TestSubscriber ts2 = new TestSubscriber(90L); + TestSubscriber ts1 = new TestSubscriber<>(10L); + TestSubscriber ts2 = new TestSubscriber<>(90L); co.subscribe(ts1); co.subscribe(ts2); @@ -840,8 +840,8 @@ public void accept(long t) { }); ConnectableObservable co = source.replay(50); - TestSubscriber ts1 = new TestSubscriber(10L); - TestSubscriber ts2 = new TestSubscriber(90L); + TestSubscriber ts1 = new TestSubscriber<>(10L); + TestSubscriber ts2 = new TestSubscriber<>(90L); co.subscribe(ts1); co.subscribe(ts2); @@ -863,7 +863,7 @@ public void accept(long t) { public void testColdReplayNoBackpressure() { Observable source = Observable.range(0, 1000).replay().autoConnect(); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); source.subscribe(ts); @@ -880,7 +880,7 @@ public void testColdReplayNoBackpressure() { public void testColdReplayBackpressure() { Observable source = Observable.range(0, 1000).replay().autoConnect(); - TestSubscriber ts = new TestSubscriber((Long)null); + TestSubscriber ts = new TestSubscriber<>((Long) null); ts.request(10); source.subscribe(ts); @@ -961,7 +961,7 @@ public void testUnsubscribeSource() { @Test public void testTake() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable cached = Observable.range(1, 100).replay().autoConnect(); cached.take(10).subscribe(ts); @@ -977,7 +977,7 @@ public void testTake() { public void testAsync() { Observable source = Observable.range(1, 10000); for (int i = 0; i < 100; i++) { - TestSubscriber ts1 = new TestSubscriber(); + TestSubscriber ts1 = new TestSubscriber<>(); Observable cached = source.replay().autoConnect(); @@ -988,7 +988,7 @@ public void testAsync() { ts1.assertTerminated(); assertEquals(10000, ts1.values().size()); - TestSubscriber ts2 = new TestSubscriber(); + TestSubscriber ts2 = new TestSubscriber<>(); cached.observeOn(Schedulers.computation()).subscribe(ts2); ts2.awaitTerminalEvent(2, TimeUnit.SECONDS); @@ -1006,14 +1006,14 @@ public void testAsyncComeAndGo() { Observable output = cached.observeOn(Schedulers.computation()); - List> list = new ArrayList>(100); + List> list = new ArrayList<>(100); for (int i = 0; i < 100; i++) { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); list.add(ts); output.skip(i * 10).take(10).subscribe(ts); } - List expected = new ArrayList(); + List expected = new ArrayList<>(); for (int i = 0; i < 10; i++) { expected.add((long)(i - 10)); } @@ -1047,7 +1047,7 @@ public void subscribe(Subscriber t) { } }); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); firehose.replay().autoConnect().observeOn(Schedulers.computation()).takeLast(100).subscribe(ts); ts.awaitTerminalEvent(3, TimeUnit.SECONDS); @@ -1064,14 +1064,14 @@ public void testValuesAndThenError() { .replay().autoConnect(); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); source.subscribe(ts); ts.assertValues(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); ts.assertNotComplete(); Assert.assertEquals(1, ts.errors().size()); - TestSubscriber ts2 = new TestSubscriber(); + TestSubscriber ts2 = new TestSubscriber<>(); source.subscribe(ts2); ts2.assertValues(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); @@ -1112,7 +1112,7 @@ public void onNext(Integer t) { public void unboundedLeavesEarly() { PublishSubject source = PublishSubject.create(); - final List requests = new ArrayList(); + final List requests = new ArrayList<>(); Observable out = source .doOnRequest(new LongConsumer() { @@ -1122,8 +1122,8 @@ public void accept(long t) { } }).replay().autoConnect(); - TestSubscriber ts1 = new TestSubscriber(5L); - TestSubscriber ts2 = new TestSubscriber(10L); + TestSubscriber ts1 = new TestSubscriber<>(5L); + TestSubscriber ts2 = new TestSubscriber<>(10L); out.subscribe(ts1); out.subscribe(ts2); @@ -1137,7 +1137,7 @@ public void testSubscribersComeAndGoAtRequestBoundaries() { ConnectableObservable source = Observable.range(1, 10).replay(1); source.connect(); - TestSubscriber ts1 = new TestSubscriber(2L); + TestSubscriber ts1 = new TestSubscriber<>(2L); source.subscribe(ts1); @@ -1145,7 +1145,7 @@ public void testSubscribersComeAndGoAtRequestBoundaries() { ts1.assertNoErrors(); ts1.dispose(); - TestSubscriber ts2 = new TestSubscriber(2L); + TestSubscriber ts2 = new TestSubscriber<>(2L); source.subscribe(ts2); @@ -1153,7 +1153,7 @@ public void testSubscribersComeAndGoAtRequestBoundaries() { ts2.assertNoErrors(); ts2.dispose(); - TestSubscriber ts21 = new TestSubscriber(1L); + TestSubscriber ts21 = new TestSubscriber<>(1L); source.subscribe(ts21); @@ -1161,7 +1161,7 @@ public void testSubscribersComeAndGoAtRequestBoundaries() { ts21.assertNoErrors(); ts21.dispose(); - TestSubscriber ts22 = new TestSubscriber(1L); + TestSubscriber ts22 = new TestSubscriber<>(1L); source.subscribe(ts22); @@ -1170,7 +1170,7 @@ public void testSubscribersComeAndGoAtRequestBoundaries() { ts22.dispose(); - TestSubscriber ts3 = new TestSubscriber(); + TestSubscriber ts3 = new TestSubscriber<>(); source.subscribe(ts3); @@ -1185,7 +1185,7 @@ public void testSubscribersComeAndGoAtRequestBoundaries2() { ConnectableObservable source = Observable.range(1, 10).replay(2); source.connect(); - TestSubscriber ts1 = new TestSubscriber(2L); + TestSubscriber ts1 = new TestSubscriber<>(2L); source.subscribe(ts1); @@ -1193,7 +1193,7 @@ public void testSubscribersComeAndGoAtRequestBoundaries2() { ts1.assertNoErrors(); ts1.dispose(); - TestSubscriber ts11 = new TestSubscriber(2L); + TestSubscriber ts11 = new TestSubscriber<>(2L); source.subscribe(ts11); @@ -1201,7 +1201,7 @@ public void testSubscribersComeAndGoAtRequestBoundaries2() { ts11.assertNoErrors(); ts11.dispose(); - TestSubscriber ts2 = new TestSubscriber(3L); + TestSubscriber ts2 = new TestSubscriber<>(3L); source.subscribe(ts2); @@ -1209,7 +1209,7 @@ public void testSubscribersComeAndGoAtRequestBoundaries2() { ts2.assertNoErrors(); ts2.dispose(); - TestSubscriber ts21 = new TestSubscriber(1L); + TestSubscriber ts21 = new TestSubscriber<>(1L); source.subscribe(ts21); @@ -1217,7 +1217,7 @@ public void testSubscribersComeAndGoAtRequestBoundaries2() { ts21.assertNoErrors(); ts21.dispose(); - TestSubscriber ts22 = new TestSubscriber(1L); + TestSubscriber ts22 = new TestSubscriber<>(1L); source.subscribe(ts22); @@ -1226,7 +1226,7 @@ public void testSubscribersComeAndGoAtRequestBoundaries2() { ts22.dispose(); - TestSubscriber ts3 = new TestSubscriber(); + TestSubscriber ts3 = new TestSubscriber<>(); source.subscribe(ts3); diff --git a/src/test/java/io/reactivex/internal/operators/OperatorRetryTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorRetryTest.java similarity index 97% rename from src/test/java/io/reactivex/internal/operators/OperatorRetryTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorRetryTest.java index d84833be7d..b77917ce0c 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorRetryTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorRetryTest.java @@ -61,7 +61,7 @@ public void subscribe(Subscriber t1) { } }); - TestSubscriber ts = new TestSubscriber(consumer); + TestSubscriber ts = new TestSubscriber<>(consumer); producer.retryWhen(new Function, Observable>() { @Override @@ -115,7 +115,7 @@ public void testRetryIndefinitely() { Subscriber observer = TestHelper.mockSubscriber(); int NUM_RETRIES = 20; Observable origin = Observable.create(new FuncWithErrors(NUM_RETRIES)); - origin.retry().unsafeSubscribe(new TestSubscriber(observer)); + origin.retry().unsafeSubscribe(new TestSubscriber<>(observer)); InOrder inOrder = inOrder(observer); // should show 3 attempts @@ -134,7 +134,7 @@ public void testSchedulingNotificationHandler() { Subscriber observer = TestHelper.mockSubscriber(); int NUM_RETRIES = 2; Observable origin = Observable.create(new FuncWithErrors(NUM_RETRIES)); - TestSubscriber subscriber = new TestSubscriber(observer); + TestSubscriber subscriber = new TestSubscriber<>(observer); origin.retryWhen(new Function, Observable>() { @Override public Observable apply(Observable t1) { @@ -201,7 +201,7 @@ public Integer apply(Throwable t1) { public void testOnCompletedFromNotificationHandler() { Subscriber observer = TestHelper.mockSubscriber(); Observable origin = Observable.create(new FuncWithErrors(1)); - TestSubscriber subscriber = new TestSubscriber(observer); + TestSubscriber subscriber = new TestSubscriber<>(observer); origin.retryWhen(new Function, Observable>() { @Override public Observable apply(Observable t1) { @@ -496,7 +496,7 @@ public void cancel() { public void testSourceObservableCallsUnsubscribe() throws InterruptedException { final AtomicInteger subsCount = new AtomicInteger(0); - final TestSubscriber ts = new TestSubscriber(); + final TestSubscriber ts = new TestSubscriber<>(); Publisher onSubscribe = new Publisher() { @Override @@ -527,7 +527,7 @@ public void subscribe(Subscriber s) { public void testSourceObservableRetry1() throws InterruptedException { final AtomicInteger subsCount = new AtomicInteger(0); - final TestSubscriber ts = new TestSubscriber(); + final TestSubscriber ts = new TestSubscriber<>(); Publisher onSubscribe = new Publisher() { @Override @@ -546,7 +546,7 @@ public void subscribe(Subscriber s) { public void testSourceObservableRetry0() throws InterruptedException { final AtomicInteger subsCount = new AtomicInteger(0); - final TestSubscriber ts = new TestSubscriber(); + final TestSubscriber ts = new TestSubscriber<>(); Publisher onSubscribe = new Publisher() { @Override @@ -668,7 +668,7 @@ public void testUnsubscribeAfterError() { SlowObservable so = new SlowObservable(100, 0); Observable o = Observable.create(so).retry(5); - AsyncObserver async = new AsyncObserver(observer); + AsyncObserver async = new AsyncObserver<>(observer); o.subscribe(async); @@ -693,7 +693,7 @@ public void testTimeoutWithRetry() { SlowObservable so = new SlowObservable(100, 10); Observable o = Observable.create(so).timeout(80, TimeUnit.MILLISECONDS).retry(5); - AsyncObserver async = new AsyncObserver(observer); + AsyncObserver async = new AsyncObserver<>(observer); o.subscribe(async); @@ -715,7 +715,7 @@ public void testRetryWithBackpressure() throws InterruptedException { for (int i = 0; i < 400; i++) { Subscriber observer = TestHelper.mockSubscriber(); Observable origin = Observable.create(new FuncWithErrors(NUM_RETRIES)); - TestSubscriber ts = new TestSubscriber(observer); + TestSubscriber ts = new TestSubscriber<>(observer); origin.retry().observeOn(Schedulers.computation()).unsafeSubscribe(ts); ts.awaitTerminalEvent(5, TimeUnit.SECONDS); @@ -746,7 +746,7 @@ public void testRetryWithBackpressureParallel() throws InterruptedException { } final AtomicInteger timeouts = new AtomicInteger(); - final Map> data = new ConcurrentHashMap>(); + final Map> data = new ConcurrentHashMap<>(); int m = 5000; final CountDownLatch cdl = new CountDownLatch(m); @@ -758,11 +758,11 @@ public void run() { final AtomicInteger nexts = new AtomicInteger(); try { Observable origin = Observable.create(new FuncWithErrors(NUM_RETRIES)); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); origin.retry() .observeOn(Schedulers.computation()).unsafeSubscribe(ts); ts.awaitTerminalEvent(2500, TimeUnit.MILLISECONDS); - List onNextEvents = new ArrayList(ts.values()); + List onNextEvents = new ArrayList<>(ts.values()); if (onNextEvents.size() != NUM_RETRIES + 2) { for (Throwable t : ts.errors()) { onNextEvents.add(t.toString()); @@ -859,7 +859,7 @@ public Observable apply(GroupedObservable t1) { return t1.take(1); } }) - .unsafeSubscribe(new TestSubscriber(observer)); + .unsafeSubscribe(new TestSubscriber<>(observer)); InOrder inOrder = inOrder(observer); // should show 3 attempts @@ -903,7 +903,7 @@ public Observable apply(GroupedObservable t1) { return t1.take(1); } }) - .unsafeSubscribe(new TestSubscriber(observer)); + .unsafeSubscribe(new TestSubscriber<>(observer)); InOrder inOrder = inOrder(observer); // should show 3 attempts diff --git a/src/test/java/io/reactivex/internal/operators/OperatorRetryWithPredicateTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorRetryWithPredicateTest.java similarity index 96% rename from src/test/java/io/reactivex/internal/operators/OperatorRetryWithPredicateTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorRetryWithPredicateTest.java index 9161d388fb..7faeade17e 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorRetryWithPredicateTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorRetryWithPredicateTest.java @@ -235,7 +235,7 @@ public void testUnsubscribeAfterError() { .create(so) .retry(retry5); - OperatorRetryTest.AsyncObserver async = new OperatorRetryTest.AsyncObserver(observer); + OperatorRetryTest.AsyncObserver async = new OperatorRetryTest.AsyncObserver<>(observer); o.subscribe(async); @@ -262,7 +262,7 @@ public void testTimeoutWithRetry() { .timeout(80, TimeUnit.MILLISECONDS) .retry(retry5); - OperatorRetryTest.AsyncObserver async = new OperatorRetryTest.AsyncObserver(observer); + OperatorRetryTest.AsyncObserver async = new OperatorRetryTest.AsyncObserver<>(observer); o.subscribe(async); @@ -278,7 +278,7 @@ public void testTimeoutWithRetry() { @Test public void testIssue2826() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); final RuntimeException e = new RuntimeException("You shall not pass"); final AtomicInteger c = new AtomicInteger(); Observable.just(1).map(new Function() { @@ -311,7 +311,7 @@ public Integer apply(Integer t1) { @Test public void testIssue3008RetryWithPredicate() { - final List list = new CopyOnWriteArrayList(); + final List list = new CopyOnWriteArrayList<>(); final AtomicBoolean isFirst = new AtomicBoolean(true); Observable. just(1L, 2L, 3L).map(new Function(){ @Override @@ -339,7 +339,7 @@ public void accept(Long t) { @Test public void testIssue3008RetryInfinite() { - final List list = new CopyOnWriteArrayList(); + final List list = new CopyOnWriteArrayList<>(); final AtomicBoolean isFirst = new AtomicBoolean(true); Observable. just(1L, 2L, 3L).map(new Function(){ @Override @@ -363,7 +363,7 @@ public void accept(Long t) { @Test public void testBackpressure() { - final List requests = new ArrayList(); + final List requests = new ArrayList<>(); Observable source = Observable .just(1) @@ -375,7 +375,7 @@ public void accept(long t) { } }); - TestSubscriber ts = new TestSubscriber(3L); + TestSubscriber ts = new TestSubscriber<>(3L); source .retry(new BiPredicate() { @Override diff --git a/src/test/java/io/reactivex/internal/operators/OperatorSampleTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorSampleTest.java similarity index 92% rename from src/test/java/io/reactivex/internal/operators/OperatorSampleTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorSampleTest.java index 2e886d07c3..64e62869ae 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorSampleTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorSampleTest.java @@ -48,24 +48,9 @@ public void testSample() { @Override public void subscribe(final Subscriber observer1) { observer1.onSubscribe(EmptySubscription.INSTANCE); - innerScheduler.schedule(new Runnable() { - @Override - public void run() { - observer1.onNext(1L); - } - }, 1, TimeUnit.SECONDS); - innerScheduler.schedule(new Runnable() { - @Override - public void run() { - observer1.onNext(2L); - } - }, 2, TimeUnit.SECONDS); - innerScheduler.schedule(new Runnable() { - @Override - public void run() { - observer1.onComplete(); - } - }, 3, TimeUnit.SECONDS); + innerScheduler.schedule(() -> observer1.onNext(1L), 1, TimeUnit.SECONDS); + innerScheduler.schedule(() -> observer1.onNext(2L), 2, TimeUnit.SECONDS); + innerScheduler.schedule(() -> observer1.onComplete(), 3, TimeUnit.SECONDS); } }); diff --git a/src/test/java/io/reactivex/internal/operators/OperatorScanTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorScanTest.java similarity index 97% rename from src/test/java/io/reactivex/internal/operators/OperatorScanTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorScanTest.java index e38f3162c7..1e1a2e12af 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorScanTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorScanTest.java @@ -110,7 +110,7 @@ public Integer apply(Integer t1, Integer t2) { @Test public void shouldNotEmitUntilAfterSubscription() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.range(1, 100).scan(0, new BiFunction() { @Override @@ -259,7 +259,7 @@ public void testSeedFactory() { @Override public List get() { - return new ArrayList(); + return new ArrayList<>(); } }, new BiConsumer, Integer>() { @@ -285,7 +285,7 @@ public Integer apply(Integer t1, Integer t2) { } }).take(1); - TestSubscriber subscriber = new TestSubscriber(); + TestSubscriber subscriber = new TestSubscriber<>(); o.subscribe(subscriber); subscriber.assertValue(0); subscriber.assertTerminated(); @@ -294,7 +294,7 @@ public Integer apply(Integer t1, Integer t2) { @Test public void testScanShouldNotRequestZero() { - final AtomicReference producer = new AtomicReference(); + final AtomicReference producer = new AtomicReference<>(); Observable o = Observable.create(new Publisher() { @Override public void subscribe(final Subscriber subscriber) { @@ -343,7 +343,7 @@ public void onNext(Integer integer) { public void testInitialValueEmittedNoProducer() { PublishSubject source = PublishSubject.create(); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); source.scan(0, new BiFunction() { @Override @@ -361,7 +361,7 @@ public Integer apply(Integer t1, Integer t2) { public void testInitialValueEmittedWithProducer() { Observable source = Observable.never(); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); source.scan(0, new BiFunction() { @Override diff --git a/src/test/java/io/reactivex/internal/operators/OperatorSequenceEqualTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorSequenceEqualTest.java similarity index 95% rename from src/test/java/io/reactivex/internal/operators/OperatorSequenceEqualTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorSequenceEqualTest.java index 6ff76ae95e..76fb5df4cb 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorSequenceEqualTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorSequenceEqualTest.java @@ -121,11 +121,8 @@ public void testWithNull2() { public void testWithEqualityError() { Observable observable = Observable.sequenceEqual( Observable.just("one"), Observable.just("one"), - new BiPredicate() { - @Override - public boolean test(String t1, String t2) { - throw new TestException(); - } + (t1, t2) -> { + throw new TestException(); }); verifyError(observable); } diff --git a/src/test/java/io/reactivex/internal/operators/OperatorSerializeTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorSerializeTest.java similarity index 80% rename from src/test/java/io/reactivex/internal/operators/OperatorSerializeTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorSerializeTest.java index 7a0eacd934..f030fb11f8 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorSerializeTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorSerializeTest.java @@ -221,22 +221,17 @@ public TestSingleThreadedObservable(final String... values) { public void subscribe(final Subscriber observer) { observer.onSubscribe(EmptySubscription.INSTANCE); System.out.println("TestSingleThreadedObservable subscribed to ..."); - t = new Thread(new Runnable() { - - @Override - public void run() { - try { - System.out.println("running TestSingleThreadedObservable thread"); - for (String s : values) { - System.out.println("TestSingleThreadedObservable onNext: " + s); - observer.onNext(s); - } - observer.onComplete(); - } catch (Throwable e) { - throw new RuntimeException(e); + t = new Thread(() -> { + try { + System.out.println("running TestSingleThreadedObservable thread"); + for (String s : values) { + System.out.println("TestSingleThreadedObservable onNext: " + s); + observer.onNext(s); } + observer.onComplete(); + } catch (Throwable e) { + throw new RuntimeException(e); } - }); System.out.println("starting TestSingleThreadedObservable thread"); t.start(); @@ -273,56 +268,48 @@ public void subscribe(final Subscriber observer) { observer.onSubscribe(EmptySubscription.INSTANCE); System.out.println("TestMultiThreadedObservable subscribed to ..."); final NullPointerException npe = new NullPointerException(); - t = new Thread(new Runnable() { - - @Override - public void run() { - try { - System.out.println("running TestMultiThreadedObservable thread"); - for (final String s : values) { - threadPool.execute(new Runnable() { - - @Override - public void run() { - threadsRunning.incrementAndGet(); - try { - // perform onNext call - if (s == null) { - System.out.println("TestMultiThreadedObservable onNext: null"); - // force an error - throw npe; - } else - System.out.println("TestMultiThreadedObservable onNext: " + s); - observer.onNext(s); - // capture 'maxThreads' - int concurrentThreads = threadsRunning.get(); - int maxThreads = maxConcurrentThreads.get(); - if (concurrentThreads > maxThreads) { - maxConcurrentThreads.compareAndSet(maxThreads, concurrentThreads); - } - } catch (Throwable e) { - observer.onError(e); - } finally { - threadsRunning.decrementAndGet(); - } + t = new Thread(() -> { + try { + System.out.println("running TestMultiThreadedObservable thread"); + for (final String s : values) { + threadPool.execute(() -> { + threadsRunning.incrementAndGet(); + try { + // perform onNext call + if (s == null) { + System.out.println("TestMultiThreadedObservable onNext: null"); + // force an error + throw npe; + } else + System.out.println("TestMultiThreadedObservable onNext: " + s); + observer.onNext(s); + // capture 'maxThreads' + int concurrentThreads = threadsRunning.get(); + int maxThreads = maxConcurrentThreads.get(); + if (concurrentThreads > maxThreads) { + maxConcurrentThreads.compareAndSet(maxThreads, concurrentThreads); } - }); - } - // we are done spawning threads - threadPool.shutdown(); - } catch (Throwable e) { - throw new RuntimeException(e); + } catch (Throwable e) { + observer.onError(e); + } finally { + threadsRunning.decrementAndGet(); + } + }); } + // we are done spawning threads + threadPool.shutdown(); + } catch (Throwable e) { + throw new RuntimeException(e); + } - // wait until all threads are done, then mark it as COMPLETED - try { - // wait for all the threads to finish - threadPool.awaitTermination(2, TimeUnit.SECONDS); - } catch (InterruptedException e) { - throw new RuntimeException(e); - } - observer.onComplete(); + // wait until all threads are done, then mark it as COMPLETED + try { + // wait for all the threads to finish + threadPool.awaitTermination(2, TimeUnit.SECONDS); + } catch (InterruptedException e) { + throw new RuntimeException(e); } + observer.onComplete(); }); System.out.println("starting TestMultiThreadedObservable thread"); t.start(); diff --git a/src/test/java/io/reactivex/internal/operators/OperatorSingleTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorSingleTest.java similarity index 98% rename from src/test/java/io/reactivex/internal/operators/OperatorSingleTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorSingleTest.java index b2f0178d81..adfb18b3ec 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorSingleTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorSingleTest.java @@ -117,7 +117,7 @@ public void accept(long n) { @Test public void testSingleDoesNotRequestMoreThanItNeedsIf1Then2Requested() { - final List requests = new ArrayList(); + final List requests = new ArrayList<>(); Observable.just(1) // .doOnRequest(new LongConsumer() { @@ -157,7 +157,7 @@ public void onNext(Integer t) { @Test public void testSingleDoesNotRequestMoreThanItNeedsIf3Requested() { - final List requests = new ArrayList(); + final List requests = new ArrayList<>(); Observable.just(1) // .doOnRequest(new LongConsumer() { @@ -196,7 +196,7 @@ public void onNext(Integer t) { @Test public void testSingleRequestsExactlyWhatItNeedsIf1Requested() { - final List requests = new ArrayList(); + final List requests = new ArrayList<>(); Observable.just(1) // .doOnRequest(new LongConsumer() { diff --git a/src/test/java/io/reactivex/internal/operators/OperatorSkipLastTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorSkipLastTest.java similarity index 98% rename from src/test/java/io/reactivex/internal/operators/OperatorSkipLastTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorSkipLastTest.java index fe88d86257..5ba75666e6 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorSkipLastTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorSkipLastTest.java @@ -95,7 +95,7 @@ public void testSkipLastWithNull() { @Test public void testSkipLastWithBackpressure() { Observable o = Observable.range(0, Observable.bufferSize() * 2).skipLast(Observable.bufferSize() + 10); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); o.observeOn(Schedulers.computation()).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); diff --git a/src/test/java/io/reactivex/internal/operators/OperatorSkipLastTimedTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorSkipLastTimedTest.java similarity index 100% rename from src/test/java/io/reactivex/internal/operators/OperatorSkipLastTimedTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorSkipLastTimedTest.java diff --git a/src/test/java/io/reactivex/internal/operators/OperatorSkipTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorSkipTest.java similarity index 89% rename from src/test/java/io/reactivex/internal/operators/OperatorSkipTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorSkipTest.java index 629be744d7..063e3d116b 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorSkipTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorSkipTest.java @@ -48,7 +48,7 @@ public void testSkipNegativeElements() { @Test public void testSkipZeroElements() { - Observable skip = Observable.just("one", "two", "three").lift(new OperatorSkip(0)); + Observable skip = Observable.just("one", "two", "three").lift(new OperatorSkip<>(0)); Subscriber observer = TestHelper.mockSubscriber(); skip.subscribe(observer); @@ -62,7 +62,7 @@ public void testSkipZeroElements() { @Test public void testSkipOneElement() { - Observable skip = Observable.just("one", "two", "three").lift(new OperatorSkip(1)); + Observable skip = Observable.just("one", "two", "three").lift(new OperatorSkip<>(1)); Subscriber observer = TestHelper.mockSubscriber(); skip.subscribe(observer); @@ -76,7 +76,7 @@ public void testSkipOneElement() { @Test public void testSkipTwoElements() { - Observable skip = Observable.just("one", "two", "three").lift(new OperatorSkip(2)); + Observable skip = Observable.just("one", "two", "three").lift(new OperatorSkip<>(2)); Subscriber observer = TestHelper.mockSubscriber(); skip.subscribe(observer); @@ -91,7 +91,7 @@ public void testSkipTwoElements() { public void testSkipEmptyStream() { Observable w = Observable.empty(); - Observable skip = w.lift(new OperatorSkip(1)); + Observable skip = w.lift(new OperatorSkip<>(1)); Subscriber observer = TestHelper.mockSubscriber(); skip.subscribe(observer); @@ -129,7 +129,7 @@ public void testSkipError() { Observable ok = Observable.just("one"); Observable error = Observable.error(e); - Observable skip = Observable.concat(ok, error).lift(new OperatorSkip(100)); + Observable skip = Observable.concat(ok, error).lift(new OperatorSkip<>(100)); Subscriber observer = TestHelper.mockSubscriber(); skip.subscribe(observer); @@ -143,14 +143,9 @@ public void testSkipError() { @Test public void testBackpressureMultipleSmallAsyncRequests() throws InterruptedException { final AtomicLong requests = new AtomicLong(0); - TestSubscriber ts = new TestSubscriber((Long)null); + TestSubscriber ts = new TestSubscriber<>((Long) null); Observable.interval(100, TimeUnit.MILLISECONDS) - .doOnRequest(new LongConsumer() { - @Override - public void accept(long n) { - requests.addAndGet(n); - } - }).skip(4).subscribe(ts); + .doOnRequest(requests::addAndGet).skip(4).subscribe(ts); Thread.sleep(100); ts.request(1); ts.request(1); @@ -164,7 +159,7 @@ public void accept(long n) { @Test public void testRequestOverflowDoesNotOccur() { - TestSubscriber ts = new TestSubscriber(Long.MAX_VALUE-1); + TestSubscriber ts = new TestSubscriber<>(Long.MAX_VALUE - 1); Observable.range(1, 10).skip(5).subscribe(ts); ts.assertTerminated(); ts.assertComplete(); diff --git a/src/test/java/io/reactivex/internal/operators/OperatorSkipTimedTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorSkipTimedTest.java similarity index 100% rename from src/test/java/io/reactivex/internal/operators/OperatorSkipTimedTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorSkipTimedTest.java diff --git a/src/test/java/io/reactivex/internal/operators/OperatorSkipUntilTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorSkipUntilTest.java similarity index 100% rename from src/test/java/io/reactivex/internal/operators/OperatorSkipUntilTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorSkipUntilTest.java diff --git a/src/test/java/io/reactivex/internal/operators/OperatorSkipWhileTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorSkipWhileTest.java similarity index 93% rename from src/test/java/io/reactivex/internal/operators/OperatorSkipWhileTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorSkipWhileTest.java index 355ff08231..4d2685ed20 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorSkipWhileTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorSkipWhileTest.java @@ -27,13 +27,10 @@ public class OperatorSkipWhileTest { Subscriber w = TestHelper.mockSubscriber(); - private static final Predicate LESS_THAN_FIVE = new Predicate() { - @Override - public boolean test(Integer v) { - if (v == 42) - throw new RuntimeException("that's not the answer to everything!"); - return v < 5; - } + private static final Predicate LESS_THAN_FIVE = v -> { + if (v == 42) + throw new RuntimeException("that's not the answer to everything!"); + return v < 5; }; private static final Predicate INDEX_LESS_THAN_THREE = new Predicate() { diff --git a/src/test/java/io/reactivex/internal/operators/OperatorSubscribeOnTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorSubscribeOnTest.java similarity index 92% rename from src/test/java/io/reactivex/internal/operators/OperatorSubscribeOnTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorSubscribeOnTest.java index d796b4a52a..50baf30d82 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorSubscribeOnTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorSubscribeOnTest.java @@ -37,7 +37,7 @@ public void testIssue813() throws InterruptedException { final CountDownLatch latch = new CountDownLatch(1); final CountDownLatch doneLatch = new CountDownLatch(1); - TestSubscriber observer = new TestSubscriber(); + TestSubscriber observer = new TestSubscriber<>(); Observable .create(new Publisher() { @@ -76,14 +76,9 @@ public void subscribe( @Test @Ignore("Publisher.subscribe can't throw") public void testThrownErrorHandling() { - TestSubscriber ts = new TestSubscriber(); - Observable.create(new Publisher() { - - @Override - public void subscribe(Subscriber s) { - throw new RuntimeException("fail"); - } - + TestSubscriber ts = new TestSubscriber<>(); + Observable.create(s -> { + throw new RuntimeException("fail"); }).subscribeOn(Schedulers.computation()).subscribe(ts); ts.awaitTerminalEvent(1000, TimeUnit.MILLISECONDS); ts.assertTerminated(); @@ -91,7 +86,7 @@ public void subscribe(Subscriber s) { @Test public void testOnError() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.create(new Publisher() { @Override @@ -162,7 +157,7 @@ public Disposable schedule(final Runnable action, final long delayTime, final Ti @Test(timeout = 5000) public void testUnsubscribeInfiniteStream() throws InterruptedException { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); final AtomicInteger count = new AtomicInteger(); Observable.create(new Publisher() { @@ -188,7 +183,7 @@ public void subscribe(Subscriber sub) { @Test public void testBackpressureReschedulesCorrectly() throws InterruptedException { final CountDownLatch latch = new CountDownLatch(10); - TestSubscriber ts = new TestSubscriber(new Observer() { + TestSubscriber ts = new TestSubscriber<>(new Observer() { @Override public void onComplete() { @@ -218,7 +213,7 @@ public void onNext(Integer t) { @Test public void testSetProducerSynchronousRequest() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.just(1, 2, 3).lift(new Operator() { @Override diff --git a/src/test/java/io/reactivex/internal/operators/OperatorSwitchIfEmptyTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorSwitchIfEmptyTest.java similarity index 85% rename from src/test/java/io/reactivex/internal/operators/OperatorSwitchIfEmptyTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorSwitchIfEmptyTest.java index 906f9c621a..e770fe37b0 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorSwitchIfEmptyTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorSwitchIfEmptyTest.java @@ -36,12 +36,7 @@ public void testSwitchWhenNotEmpty() throws Exception { final AtomicBoolean subscribed = new AtomicBoolean(false); final Observable observable = Observable.just(4) .switchIfEmpty(Observable.just(2) - .doOnSubscribe(new Consumer() { - @Override - public void accept(Subscription s) { - subscribed.set(true); - } - })); + .doOnSubscribe(s -> subscribed.set(true))); assertEquals(4, observable.toBlocking().single().intValue()); assertFalse(subscribed.get()); @@ -98,10 +93,7 @@ public void subscribe(final Subscriber subscriber) { Observable.empty() .switchIfEmpty(withProducer) - .lift(new Observable.Operator() { - @Override - public Subscriber apply(final Subscriber child) { - return new Observer() { + .lift(child -> new Observer() { @Override public void onComplete() { @@ -116,10 +108,8 @@ public void onError(Throwable e) { public void onNext(Long aLong) { cancel(); } - - }; - } - }).subscribe(); + + }).subscribe(); assertTrue(bs.isCancelled()); @@ -144,7 +134,7 @@ public void subscribe(final Subscriber subscriber) { @Test public void testSwitchRequestAlternativeObservableWithBackpressure() { - TestSubscriber ts = new TestSubscriber(1L); + TestSubscriber ts = new TestSubscriber<>(1L); Observable.empty().switchIfEmpty(Observable.just(1, 2, 3)).subscribe(ts); @@ -157,7 +147,7 @@ public void testSwitchRequestAlternativeObservableWithBackpressure() { } @Test public void testBackpressureNoRequest() { - TestSubscriber ts = new TestSubscriber((Long)null); + TestSubscriber ts = new TestSubscriber<>((Long) null); Observable.empty().switchIfEmpty(Observable.just(1, 2, 3)).subscribe(ts); ts.assertNoValues(); ts.assertNoErrors(); @@ -165,7 +155,7 @@ public void testBackpressureNoRequest() { @Test public void testBackpressureOnFirstObservable() { - TestSubscriber ts = new TestSubscriber((Long)null); + TestSubscriber ts = new TestSubscriber<>((Long) null); Observable.just(1,2,3).switchIfEmpty(Observable.just(4, 5, 6)).subscribe(ts); ts.assertNotComplete(); ts.assertNoErrors(); @@ -174,7 +164,7 @@ public void testBackpressureOnFirstObservable() { @Test(timeout = 10000) public void testRequestsNotLost() throws InterruptedException { - final TestSubscriber ts = new TestSubscriber((Long)null); + final TestSubscriber ts = new TestSubscriber<>((Long) null); Observable.create(new Publisher() { @Override @@ -184,11 +174,7 @@ public void subscribe(final Subscriber subscriber) { @Override public void request(long n) { if (n > 0 && completed.compareAndSet(false, true)) { - Schedulers.io().createWorker().schedule(new Runnable() { - @Override - public void run() { - subscriber.onComplete(); - }}, 100, TimeUnit.MILLISECONDS); + Schedulers.io().createWorker().schedule(subscriber::onComplete, 100, TimeUnit.MILLISECONDS); } } diff --git a/src/test/java/io/reactivex/internal/operators/OperatorSwitchTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorSwitchTest.java similarity index 98% rename from src/test/java/io/reactivex/internal/operators/OperatorSwitchTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorSwitchTest.java index e61c191562..7a7b78f02d 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorSwitchTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorSwitchTest.java @@ -449,7 +449,7 @@ public void testBackpressure() { publishCompleted(o3, 55); - final TestSubscriber testSubscriber = new TestSubscriber(); + final TestSubscriber testSubscriber = new TestSubscriber<>(); Observable.switchOnNext(o).subscribe(new Observer() { private int requested = 0; @@ -548,7 +548,7 @@ public void onNext(String t) { @Test(timeout = 10000) public void testInitialRequestsAreAdditive() { - TestSubscriber ts = new TestSubscriber((Long)null); + TestSubscriber ts = new TestSubscriber<>((Long) null); Observable.switchOnNext( Observable.interval(100, TimeUnit.MILLISECONDS) .map( @@ -567,7 +567,7 @@ public Observable apply(Long t) { @Test(timeout = 10000) public void testInitialRequestsDontOverflow() { - TestSubscriber ts = new TestSubscriber((Long)null); + TestSubscriber ts = new TestSubscriber<>((Long) null); Observable.switchOnNext( Observable.interval(100, TimeUnit.MILLISECONDS) .map(new Function>() { @@ -585,7 +585,7 @@ public Observable apply(Long t) { @Test(timeout = 10000) public void testSecondaryRequestsDontOverflow() throws InterruptedException { - TestSubscriber ts = new TestSubscriber((Long)null); + TestSubscriber ts = new TestSubscriber<>((Long) null); Observable.switchOnNext( Observable.interval(100, TimeUnit.MILLISECONDS) .map(new Function>() { @@ -607,9 +607,9 @@ public Observable apply(Long t) { @Ignore("Request pattern changed and I can't decide if this is okay or not") public void testSecondaryRequestsAdditivelyAreMoreThanLongMaxValueInducesMaxValueRequestFromUpstream() throws InterruptedException { - final List requests = new CopyOnWriteArrayList(); + final List requests = new CopyOnWriteArrayList<>(); - TestSubscriber ts = new TestSubscriber(1L); + TestSubscriber ts = new TestSubscriber<>(1L); Observable.switchOnNext( Observable.interval(100, TimeUnit.MILLISECONDS) .map(new Function>() { diff --git a/src/test/java/io/reactivex/internal/operators/OperatorTakeLastOneTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorTakeLastOneTest.java similarity index 82% rename from src/test/java/io/reactivex/internal/operators/OperatorTakeLastOneTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorTakeLastOneTest.java index 7814126317..196e29144a 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorTakeLastOneTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorTakeLastOneTest.java @@ -29,7 +29,7 @@ public class OperatorTakeLastOneTest { @Test public void testLastOfManyReturnsLast() { - TestSubscriber s = new TestSubscriber(); + TestSubscriber s = new TestSubscriber<>(); Observable.range(1, 10).takeLast(1).subscribe(s); s.assertValue(10); s.assertNoErrors(); @@ -40,7 +40,7 @@ public void testLastOfManyReturnsLast() { @Test public void testLastOfEmptyReturnsEmpty() { - TestSubscriber s = new TestSubscriber(); + TestSubscriber s = new TestSubscriber<>(); Observable.empty().takeLast(1).subscribe(s); s.assertNoValues(); s.assertNoErrors(); @@ -51,7 +51,7 @@ public void testLastOfEmptyReturnsEmpty() { @Test public void testLastOfOneReturnsLast() { - TestSubscriber s = new TestSubscriber(); + TestSubscriber s = new TestSubscriber<>(); Observable.just(1).takeLast(1).subscribe(s); s.assertValue(1); s.assertNoErrors(); @@ -63,12 +63,7 @@ public void testLastOfOneReturnsLast() { @Test public void testUnsubscribesFromUpstream() { final AtomicBoolean unsubscribed = new AtomicBoolean(false); - Runnable unsubscribeAction = new Runnable() { - @Override - public void run() { - unsubscribed.set(true); - } - }; + Runnable unsubscribeAction = () -> unsubscribed.set(true); Observable.just(1).doOnCancel(unsubscribeAction) .takeLast(1).subscribe(); assertTrue(unsubscribed.get()); @@ -76,7 +71,7 @@ public void run() { @Test public void testLastWithBackpressure() { - MySubscriber s = new MySubscriber(0); + MySubscriber s = new MySubscriber<>(0); Observable.just(1).takeLast(1).subscribe(s); assertEquals(0, s.list.size()); s.requestMore(1); @@ -87,12 +82,7 @@ public void testLastWithBackpressure() { public void testTakeLastZeroProcessesAllItemsButIgnoresThem() { final AtomicInteger upstreamCount = new AtomicInteger(); final int num = 10; - long count = Observable.range(1,num).doOnNext(new Consumer() { - - @Override - public void accept(Integer t) { - upstreamCount.incrementAndGet(); - }}) + long count = Observable.range(1,num).doOnNext(t -> upstreamCount.incrementAndGet()) .takeLast(0).count().toBlocking().single(); assertEquals(num, upstreamCount.get()); assertEquals(0L, count); @@ -106,7 +96,7 @@ private static class MySubscriber extends Observer { this.initialRequest = initialRequest; } - final List list = new ArrayList(); + final List list = new ArrayList<>(); public void requestMore(long n) { request(n); diff --git a/src/test/java/io/reactivex/internal/operators/OperatorTakeLastTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorTakeLastTest.java similarity index 95% rename from src/test/java/io/reactivex/internal/operators/OperatorTakeLastTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorTakeLastTest.java index 64ebbf1fee..45ee511260 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorTakeLastTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorTakeLastTest.java @@ -106,7 +106,7 @@ public void testTakeLastWithNegativeCount() { @Test public void testBackpressure1() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.range(1, 100000).takeLast(1) .observeOn(Schedulers.newThread()) .map(newSlowProcessor()).subscribe(ts); @@ -117,7 +117,7 @@ public void testBackpressure1() { @Test public void testBackpressure2() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.range(1, 100000).takeLast(Observable.bufferSize() * 4) .observeOn(Schedulers.newThread()).map(newSlowProcessor()).subscribe(ts); ts.awaitTerminalEvent(); @@ -149,12 +149,7 @@ public void testIssue1522() { assertEquals(0, Observable .empty() .count() - .filter(new Predicate() { - @Override - public boolean test(Long v) { - return false; - } - }) + .filter(v -> false) .toList() .toBlocking().single().size()); } @@ -293,7 +288,7 @@ public void onNext(Integer integer) { @Test(timeout=10000) public void testRequestOverflow() { - final List list = new ArrayList(); + final List list = new ArrayList<>(); Observable.range(1, 100).takeLast(50).subscribe(new Observer() { @Override diff --git a/src/test/java/io/reactivex/internal/operators/OperatorTakeLastTimedTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorTakeLastTimedTest.java similarity index 99% rename from src/test/java/io/reactivex/internal/operators/OperatorTakeLastTimedTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorTakeLastTimedTest.java index df65395427..4567be82d7 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorTakeLastTimedTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorTakeLastTimedTest.java @@ -206,7 +206,7 @@ public void takeLastTimedWithZeroCapacity() { public void testContinuousDelivery() { TestScheduler scheduler = Schedulers.test(); - TestSubscriber ts = new TestSubscriber((Long)null); + TestSubscriber ts = new TestSubscriber<>((Long) null); PublishSubject ps = PublishSubject.create(); diff --git a/src/test/java/io/reactivex/internal/operators/OperatorTakeTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorTakeTest.java similarity index 81% rename from src/test/java/io/reactivex/internal/operators/OperatorTakeTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorTakeTest.java index f0bd83f101..275aa6be26 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorTakeTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorTakeTest.java @@ -66,23 +66,17 @@ public void testTake2() { @Test(expected = IllegalArgumentException.class) public void testTakeWithError() { Observable.fromIterable(Arrays.asList(1, 2, 3)).take(1) - .map(new Function() { - @Override - public Integer apply(Integer t1) { - throw new IllegalArgumentException("some error"); - } + .map(t1 -> { + throw new IllegalArgumentException("some error"); }).toBlocking().single(); } @Test public void testTakeWithErrorHappeningInOnNext() { Observable w = Observable.fromIterable(Arrays.asList(1, 2, 3)) - .take(2).map(new Function() { - @Override - public Integer apply(Integer t1) { - throw new IllegalArgumentException("some error"); - } - }); + .take(2).map(t1 -> { + throw new IllegalArgumentException("some error"); + }); Subscriber observer = TestHelper.mockSubscriber(); w.subscribe(observer); @@ -93,11 +87,8 @@ public Integer apply(Integer t1) { @Test public void testTakeWithErrorHappeningInTheLastOnNext() { - Observable w = Observable.fromIterable(Arrays.asList(1, 2, 3)).take(1).map(new Function() { - @Override - public Integer apply(Integer t1) { - throw new IllegalArgumentException("some error"); - } + Observable w = Observable.fromIterable(Arrays.asList(1, 2, 3)).take(1).map(t1 -> { + throw new IllegalArgumentException("some error"); }); Subscriber observer = TestHelper.mockSubscriber(); @@ -189,14 +180,7 @@ public void testUnsubscribeAfterTake() { @Test(timeout = 2000) public void testUnsubscribeFromSynchronousInfiniteObservable() { final AtomicLong count = new AtomicLong(); - INFINITE_OBSERVABLE.take(10).subscribe(new Consumer() { - - @Override - public void accept(Long l) { - count.set(l); - } - - }); + INFINITE_OBSERVABLE.take(10).subscribe(count::set); assertEquals(10, count.get()); } @@ -216,13 +200,8 @@ public void subscribe(Subscriber s) { } } - }).take(100).take(1).toBlocking().forEach(new Consumer() { - - @Override - public void accept(Integer t1) { - System.out.println("Receive: " + t1); - - } + }).take(100).take(1).toBlocking().forEach(t1 -> { + System.out.println("Receive: " + t1); }); @@ -242,22 +221,17 @@ public TestObservableFunc(String... values) { public void subscribe(final Subscriber observer) { observer.onSubscribe(EmptySubscription.INSTANCE); System.out.println("TestObservable subscribed to ..."); - t = new Thread(new Runnable() { - - @Override - public void run() { - try { - System.out.println("running TestObservable thread"); - for (String s : values) { - System.out.println("TestObservable onNext: " + s); - observer.onNext(s); - } - observer.onComplete(); - } catch (Throwable e) { - throw new RuntimeException(e); + t = new Thread(() -> { + try { + System.out.println("running TestObservable thread"); + for (String s : values) { + System.out.println("TestObservable onNext: " + s); + observer.onNext(s); } + observer.onComplete(); + } catch (Throwable e) { + throw new RuntimeException(e); } - }); System.out.println("starting TestObservable thread"); t.start(); @@ -283,7 +257,7 @@ public void subscribe(Subscriber op) { @Test(timeout = 2000) public void testTakeObserveOn() { Subscriber o = TestHelper.mockSubscriber(); - TestSubscriber ts = new TestSubscriber(o); + TestSubscriber ts = new TestSubscriber<>(o); INFINITE_OBSERVABLE.onBackpressureDrop() .observeOn(Schedulers.newThread()).take(1).subscribe(ts); @@ -298,7 +272,7 @@ public void testTakeObserveOn() { @Test public void testProducerRequestThroughTake() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); ts.request(3); final AtomicLong requested = new AtomicLong(); Observable.create(new Publisher() { @@ -326,7 +300,7 @@ public void cancel() { @Test public void testProducerRequestThroughTakeIsModified() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); ts.request(3); final AtomicLong requested = new AtomicLong(); Observable.create(new Publisher() { @@ -354,23 +328,18 @@ public void cancel() { @Test public void testInterrupt() throws InterruptedException { - final AtomicReference exception = new AtomicReference(); + final AtomicReference exception = new AtomicReference<>(); final CountDownLatch latch = new CountDownLatch(1); Observable.just(1).subscribeOn(Schedulers.computation()).take(1) - .subscribe(new Consumer() { - - @Override - public void accept(Integer t1) { - try { - Thread.sleep(100); - } catch (Exception e) { - exception.set(e); - e.printStackTrace(); - } finally { - latch.countDown(); - } + .subscribe(t1 -> { + try { + Thread.sleep(100); + } catch (Exception e) { + exception.set(e); + e.printStackTrace(); + } finally { + latch.countDown(); } - }); latch.await(); @@ -380,15 +349,13 @@ public void accept(Integer t1) { @Test public void testDoesntRequestMoreThanNeededFromUpstream() throws InterruptedException { final AtomicLong requests = new AtomicLong(); - TestSubscriber ts = new TestSubscriber((Long)null); + TestSubscriber ts = new TestSubscriber<>((Long) null); Observable.interval(100, TimeUnit.MILLISECONDS) // - .doOnRequest(new LongConsumer() { - @Override - public void accept(long n) { - System.out.println(n); - requests.addAndGet(n); - }}) + .doOnRequest(n -> { + System.out.println(n); + requests.addAndGet(n); + }) // .take(2) // @@ -426,14 +393,9 @@ public void onNext(Integer t) { public void testReentrantTake() { final PublishSubject source = PublishSubject.create(); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); - source.take(1).doOnNext(new Consumer() { - @Override - public void accept(Integer v) { - source.onNext(2); - } - }).subscribe(ts); + source.take(1).doOnNext(v -> source.onNext(2)).subscribe(ts); source.onNext(1); diff --git a/src/test/java/io/reactivex/internal/operators/OperatorTakeTimedTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorTakeTimedTest.java similarity index 100% rename from src/test/java/io/reactivex/internal/operators/OperatorTakeTimedTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorTakeTimedTest.java diff --git a/src/test/java/io/reactivex/internal/operators/OperatorTakeUntilPredicateTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorTakeUntilPredicateTest.java similarity index 97% rename from src/test/java/io/reactivex/internal/operators/OperatorTakeUntilPredicateTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorTakeUntilPredicateTest.java index 857b5af916..2ad089dcc0 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorTakeUntilPredicateTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorTakeUntilPredicateTest.java @@ -130,7 +130,7 @@ public boolean test(Integer v) { } @Test public void backpressure() { - TestSubscriber ts = new TestSubscriber(5L); + TestSubscriber ts = new TestSubscriber<>(5L); Observable.range(1, 1000).takeUntil(new Predicate() { @Override @@ -146,7 +146,7 @@ public boolean test(Integer v) { @Test public void testErrorIncludesLastValueAsCause() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); final TestException e = new TestException("Forced failure"); Predicate predicate = new Predicate() { @Override diff --git a/src/test/java/io/reactivex/internal/operators/OperatorTakeUntilTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorTakeUntilTest.java similarity index 97% rename from src/test/java/io/reactivex/internal/operators/OperatorTakeUntilTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorTakeUntilTest.java index 6ac26e91cc..5313c4b185 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorTakeUntilTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorTakeUntilTest.java @@ -187,7 +187,7 @@ public void testUntilFires() { PublishSubject source = PublishSubject.create(); PublishSubject until = PublishSubject.create(); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); source.takeUntil(until).unsafeSubscribe(ts); @@ -212,7 +212,7 @@ public void testMainCompletes() { PublishSubject source = PublishSubject.create(); PublishSubject until = PublishSubject.create(); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); source.takeUntil(until).unsafeSubscribe(ts); @@ -235,7 +235,7 @@ public void testDownstreamUnsubscribes() { PublishSubject source = PublishSubject.create(); PublishSubject until = PublishSubject.create(); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); source.takeUntil(until).take(1).unsafeSubscribe(ts); @@ -255,7 +255,7 @@ public void testDownstreamUnsubscribes() { public void testBackpressure() { PublishSubject until = PublishSubject.create(); - TestSubscriber ts = new TestSubscriber((Long)null); + TestSubscriber ts = new TestSubscriber<>((Long) null); Observable.range(1, 10).takeUntil(until).unsafeSubscribe(ts); diff --git a/src/test/java/io/reactivex/internal/operators/OperatorTakeWhileTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorTakeWhileTest.java similarity index 97% rename from src/test/java/io/reactivex/internal/operators/OperatorTakeWhileTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorTakeWhileTest.java index a0a3936792..ae8c00f621 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorTakeWhileTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorTakeWhileTest.java @@ -222,7 +222,7 @@ public boolean test(Integer t1) { return t1 < 100; } }); - TestSubscriber ts = new TestSubscriber(5L); + TestSubscriber ts = new TestSubscriber<>(5L); source.subscribe(ts); @@ -243,7 +243,7 @@ public boolean test(Integer t1) { return t1 < 2; } }); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); source.unsafeSubscribe(ts); @@ -255,7 +255,7 @@ public boolean test(Integer t1) { @Test public void testErrorCauseIncludesLastValue() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.just("abc").takeWhile(new Predicate() { @Override public boolean test(String t1) { diff --git a/src/test/java/io/reactivex/internal/operators/OperatorThrottleFirstTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorThrottleFirstTest.java similarity index 100% rename from src/test/java/io/reactivex/internal/operators/OperatorThrottleFirstTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorThrottleFirstTest.java diff --git a/src/test/java/io/reactivex/internal/operators/OperatorTimeIntervalTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorTimeIntervalTest.java similarity index 92% rename from src/test/java/io/reactivex/internal/operators/OperatorTimeIntervalTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorTimeIntervalTest.java index e39b43fa50..72ffa06e01 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorTimeIntervalTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorTimeIntervalTest.java @@ -57,11 +57,11 @@ public void testTimeInterval() { subject.onComplete(); inOrder.verify(observer, times(1)).onNext( - new Timed(1, 1000, TIME_UNIT)); + new Timed<>(1, 1000, TIME_UNIT)); inOrder.verify(observer, times(1)).onNext( - new Timed(2, 2000, TIME_UNIT)); + new Timed<>(2, 2000, TIME_UNIT)); inOrder.verify(observer, times(1)).onNext( - new Timed(3, 3000, TIME_UNIT)); + new Timed<>(3, 3000, TIME_UNIT)); inOrder.verify(observer, times(1)).onComplete(); inOrder.verifyNoMoreInteractions(); } diff --git a/src/test/java/io/reactivex/internal/operators/OperatorTimeoutTests.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorTimeoutTests.java similarity index 87% rename from src/test/java/io/reactivex/internal/operators/OperatorTimeoutTests.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorTimeoutTests.java index d9978c50cb..0393feaf3a 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorTimeoutTests.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorTimeoutTests.java @@ -47,7 +47,7 @@ public void setUp() { @Test public void shouldNotTimeoutIfOnNextWithinTimeout() { Subscriber observer = TestHelper.mockSubscriber(); - TestSubscriber ts = new TestSubscriber(observer); + TestSubscriber ts = new TestSubscriber<>(observer); withTimeout.subscribe(ts); @@ -62,7 +62,7 @@ public void shouldNotTimeoutIfOnNextWithinTimeout() { @Test public void shouldNotTimeoutIfSecondOnNextWithinTimeout() { Subscriber observer = TestHelper.mockSubscriber(); - TestSubscriber ts = new TestSubscriber(observer); + TestSubscriber ts = new TestSubscriber<>(observer); withTimeout.subscribe(ts); @@ -79,7 +79,7 @@ public void shouldNotTimeoutIfSecondOnNextWithinTimeout() { @Test public void shouldTimeoutIfOnNextNotWithinTimeout() { Subscriber observer = TestHelper.mockSubscriber(); - TestSubscriber ts = new TestSubscriber(observer); + TestSubscriber ts = new TestSubscriber<>(observer); withTimeout.subscribe(ts); @@ -91,7 +91,7 @@ public void shouldTimeoutIfOnNextNotWithinTimeout() { @Test public void shouldTimeoutIfSecondOnNextNotWithinTimeout() { Subscriber observer = TestHelper.mockSubscriber(); - TestSubscriber ts = new TestSubscriber(observer); + TestSubscriber ts = new TestSubscriber<>(observer); withTimeout.subscribe(observer); testScheduler.advanceTimeBy(2, TimeUnit.SECONDS); underlyingSubject.onNext("One"); @@ -104,7 +104,7 @@ public void shouldTimeoutIfSecondOnNextNotWithinTimeout() { @Test public void shouldCompleteIfUnderlyingComletes() { Subscriber observer = TestHelper.mockSubscriber(); - TestSubscriber ts = new TestSubscriber(observer); + TestSubscriber ts = new TestSubscriber<>(observer); withTimeout.subscribe(observer); testScheduler.advanceTimeBy(2, TimeUnit.SECONDS); underlyingSubject.onComplete(); @@ -117,7 +117,7 @@ public void shouldCompleteIfUnderlyingComletes() { @Test public void shouldErrorIfUnderlyingErrors() { Subscriber observer = TestHelper.mockSubscriber(); - TestSubscriber ts = new TestSubscriber(observer); + TestSubscriber ts = new TestSubscriber<>(observer); withTimeout.subscribe(observer); testScheduler.advanceTimeBy(2, TimeUnit.SECONDS); underlyingSubject.onError(new UnsupportedOperationException()); @@ -132,7 +132,7 @@ public void shouldSwitchToOtherIfOnNextNotWithinTimeout() { Observable source = underlyingSubject.timeout(TIMEOUT, TIME_UNIT, other, testScheduler); Subscriber observer = TestHelper.mockSubscriber(); - TestSubscriber ts = new TestSubscriber(observer); + TestSubscriber ts = new TestSubscriber<>(observer); source.subscribe(ts); testScheduler.advanceTimeBy(2, TimeUnit.SECONDS); @@ -155,7 +155,7 @@ public void shouldSwitchToOtherIfOnErrorNotWithinTimeout() { Observable source = underlyingSubject.timeout(TIMEOUT, TIME_UNIT, other, testScheduler); Subscriber observer = TestHelper.mockSubscriber(); - TestSubscriber ts = new TestSubscriber(observer); + TestSubscriber ts = new TestSubscriber<>(observer); source.subscribe(ts); testScheduler.advanceTimeBy(2, TimeUnit.SECONDS); @@ -178,7 +178,7 @@ public void shouldSwitchToOtherIfOnCompletedNotWithinTimeout() { Observable source = underlyingSubject.timeout(TIMEOUT, TIME_UNIT, other, testScheduler); Subscriber observer = TestHelper.mockSubscriber(); - TestSubscriber ts = new TestSubscriber(observer); + TestSubscriber ts = new TestSubscriber<>(observer); source.subscribe(ts); testScheduler.advanceTimeBy(2, TimeUnit.SECONDS); @@ -201,7 +201,7 @@ public void shouldSwitchToOtherAndCanBeUnsubscribedIfOnNextNotWithinTimeout() { Observable source = underlyingSubject.timeout(TIMEOUT, TIME_UNIT, other, testScheduler); Subscriber observer = TestHelper.mockSubscriber(); - TestSubscriber ts = new TestSubscriber(observer); + TestSubscriber ts = new TestSubscriber<>(observer); source.subscribe(ts); testScheduler.advanceTimeBy(2, TimeUnit.SECONDS); @@ -232,30 +232,26 @@ public void shouldTimeoutIfSynchronizedObservableEmitFirstOnNextNotWithinTimeout final CountDownLatch timeoutSetuped = new CountDownLatch(1); final Subscriber observer = TestHelper.mockSubscriber(); - final TestSubscriber ts = new TestSubscriber(observer); - - new Thread(new Runnable() { - - @Override - public void run() { - Observable.create(new Publisher() { - - @Override - public void subscribe(Subscriber subscriber) { - subscriber.onSubscribe(EmptySubscription.INSTANCE); - try { - timeoutSetuped.countDown(); - exit.await(); - } catch (InterruptedException e) { - e.printStackTrace(); - } - subscriber.onNext("a"); - subscriber.onComplete(); + final TestSubscriber ts = new TestSubscriber<>(observer); + + new Thread(() -> { + Observable.create(new Publisher() { + + @Override + public void subscribe(Subscriber subscriber) { + subscriber.onSubscribe(EmptySubscription.INSTANCE); + try { + timeoutSetuped.countDown(); + exit.await(); + } catch (InterruptedException e) { + e.printStackTrace(); } + subscriber.onNext("a"); + subscriber.onComplete(); + } - }).timeout(1, TimeUnit.SECONDS, testScheduler) - .subscribe(ts); - } + }).timeout(1, TimeUnit.SECONDS, testScheduler) + .subscribe(ts); }).start(); timeoutSetuped.await(); @@ -284,7 +280,7 @@ public void subscribe(Subscriber subscriber) { Observable observableWithTimeout = never.timeout(1000, TimeUnit.MILLISECONDS, testScheduler); Subscriber observer = TestHelper.mockSubscriber(); - TestSubscriber ts = new TestSubscriber(observer); + TestSubscriber ts = new TestSubscriber<>(observer); observableWithTimeout.subscribe(ts); testScheduler.advanceTimeBy(2000, TimeUnit.MILLISECONDS); @@ -315,7 +311,7 @@ public void subscribe(Subscriber subscriber) { testScheduler); Subscriber observer = TestHelper.mockSubscriber(); - TestSubscriber ts = new TestSubscriber(observer); + TestSubscriber ts = new TestSubscriber<>(observer); observableWithTimeout.subscribe(ts); testScheduler.advanceTimeBy(2000, TimeUnit.MILLISECONDS); @@ -346,7 +342,7 @@ public void subscribe(Subscriber subscriber) { testScheduler); Subscriber observer = TestHelper.mockSubscriber(); - TestSubscriber ts = new TestSubscriber(observer); + TestSubscriber ts = new TestSubscriber<>(observer); observableWithTimeout.subscribe(ts); testScheduler.advanceTimeBy(2000, TimeUnit.MILLISECONDS); diff --git a/src/test/java/io/reactivex/internal/operators/OperatorTimeoutWithSelectorTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorTimeoutWithSelectorTest.java similarity index 99% rename from src/test/java/io/reactivex/internal/operators/OperatorTimeoutWithSelectorTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorTimeoutWithSelectorTest.java index 0a3d30a651..739727835a 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorTimeoutWithSelectorTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorTimeoutWithSelectorTest.java @@ -374,7 +374,7 @@ public Void answer(InvocationOnMock invocation) throws Throwable { }).when(o).onComplete(); - final TestSubscriber ts = new TestSubscriber(o); + final TestSubscriber ts = new TestSubscriber<>(o); new Thread(new Runnable() { diff --git a/src/test/java/io/reactivex/internal/operators/OperatorTimestampTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorTimestampTest.java similarity index 79% rename from src/test/java/io/reactivex/internal/operators/OperatorTimestampTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorTimestampTest.java index 302a53202a..09e97ff6d8 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorTimestampTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorTimestampTest.java @@ -50,9 +50,9 @@ public void timestampWithScheduler() { InOrder inOrder = inOrder(observer); - inOrder.verify(observer, times(1)).onNext(new Timed(1, 0, TimeUnit.MILLISECONDS)); - inOrder.verify(observer, times(1)).onNext(new Timed(2, 100, TimeUnit.MILLISECONDS)); - inOrder.verify(observer, times(1)).onNext(new Timed(3, 200, TimeUnit.MILLISECONDS)); + inOrder.verify(observer, times(1)).onNext(new Timed<>(1, 0, TimeUnit.MILLISECONDS)); + inOrder.verify(observer, times(1)).onNext(new Timed<>(2, 100, TimeUnit.MILLISECONDS)); + inOrder.verify(observer, times(1)).onNext(new Timed<>(3, 200, TimeUnit.MILLISECONDS)); verify(observer, never()).onError(any(Throwable.class)); verify(observer, never()).onComplete(); @@ -74,9 +74,9 @@ public void timestampWithScheduler2() { InOrder inOrder = inOrder(observer); - inOrder.verify(observer, times(1)).onNext(new Timed(1, 0, TimeUnit.MILLISECONDS)); - inOrder.verify(observer, times(1)).onNext(new Timed(2, 0, TimeUnit.MILLISECONDS)); - inOrder.verify(observer, times(1)).onNext(new Timed(3, 200, TimeUnit.MILLISECONDS)); + inOrder.verify(observer, times(1)).onNext(new Timed<>(1, 0, TimeUnit.MILLISECONDS)); + inOrder.verify(observer, times(1)).onNext(new Timed<>(2, 0, TimeUnit.MILLISECONDS)); + inOrder.verify(observer, times(1)).onNext(new Timed<>(3, 200, TimeUnit.MILLISECONDS)); verify(observer, never()).onError(any(Throwable.class)); verify(observer, never()).onComplete(); diff --git a/src/test/java/io/reactivex/internal/operators/OperatorToMapTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorToMapTest.java similarity index 94% rename from src/test/java/io/reactivex/internal/operators/OperatorToMapTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorToMapTest.java index ba8ee122eb..b2b3b900b5 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorToMapTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorToMapTest.java @@ -52,7 +52,7 @@ public void testToMap() { Observable> mapped = source.toMap(lengthFunc); - Map expected = new HashMap(); + Map expected = new HashMap<>(); expected.put(1, "a"); expected.put(2, "bb"); expected.put(3, "ccc"); @@ -71,7 +71,7 @@ public void testToMapWithValueSelector() { Observable> mapped = source.toMap(lengthFunc, duplicate); - Map expected = new HashMap(); + Map expected = new HashMap<>(); expected.put(1, "aa"); expected.put(2, "bbbb"); expected.put(3, "cccccc"); @@ -99,7 +99,7 @@ public Integer apply(String t1) { }; Observable> mapped = source.toMap(lengthFuncErr); - Map expected = new HashMap(); + Map expected = new HashMap<>(); expected.put(1, "a"); expected.put(2, "bb"); expected.put(3, "ccc"); @@ -129,7 +129,7 @@ public String apply(String t1) { Observable> mapped = source.toMap(lengthFunc, duplicateErr); - Map expected = new HashMap(); + Map expected = new HashMap<>(); expected.put(1, "aa"); expected.put(2, "bbbb"); expected.put(3, "cccccc"); @@ -175,7 +175,7 @@ public String apply(String v) { } }, mapFactory); - Map expected = new LinkedHashMap(); + Map expected = new LinkedHashMap<>(); expected.put(2, "bb"); expected.put(3, "ccc"); expected.put(4, "dddd"); @@ -211,7 +211,7 @@ public String apply(String v) { } }, mapFactory); - Map expected = new LinkedHashMap(); + Map expected = new LinkedHashMap<>(); expected.put(2, "bb"); expected.put(3, "ccc"); expected.put(4, "dddd"); diff --git a/src/test/java/io/reactivex/internal/operators/OperatorToMultimapTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorToMultimapTest.java similarity index 93% rename from src/test/java/io/reactivex/internal/operators/OperatorToMultimapTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorToMultimapTest.java index 43b0a8f942..e181a8f056 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorToMultimapTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorToMultimapTest.java @@ -52,7 +52,7 @@ public void testToMultimap() { Observable>> mapped = source.toMultimap(lengthFunc); - Map> expected = new HashMap>(); + Map> expected = new HashMap<>(); expected.put(1, Arrays.asList("a", "b")); expected.put(2, Arrays.asList("cc", "dd")); @@ -69,7 +69,7 @@ public void testToMultimapWithValueSelector() { Observable>> mapped = source.toMultimap(lengthFunc, duplicate); - Map> expected = new HashMap>(); + Map> expected = new HashMap<>(); expected.put(1, Arrays.asList("aa", "bb")); expected.put(2, Arrays.asList("cccc", "dddd")); @@ -111,11 +111,11 @@ public String apply(String v) { mapFactory, new Function>() { @Override public Collection apply(Integer e) { - return new ArrayList(); + return new ArrayList<>(); } }); - Map> expected = new HashMap>(); + Map> expected = new HashMap<>(); expected.put(2, Arrays.asList("cc", "dd")); expected.put(3, Arrays.asList("eee", "fff")); @@ -134,9 +134,9 @@ public void testToMultimapWithCollectionFactory() { @Override public Collection apply(Integer t1) { if (t1 == 2) { - return new ArrayList(); + return new ArrayList<>(); } else { - return new HashSet(); + return new HashSet<>(); } } }; @@ -150,16 +150,16 @@ public String apply(String v) { Supplier>> mapSupplier = new Supplier>>() { @Override public Map> get() { - return new HashMap>(); + return new HashMap<>(); } }; Observable>> mapped = source .toMultimap(lengthFunc, identity, mapSupplier, collectionFactory); - Map> expected = new HashMap>(); + Map> expected = new HashMap<>(); expected.put(2, Arrays.asList("cc", "dd")); - expected.put(3, new HashSet(Arrays.asList("eee"))); + expected.put(3, new HashSet<>(Arrays.asList("eee"))); mapped.subscribe(objectObserver); @@ -184,7 +184,7 @@ public Integer apply(String t1) { Observable>> mapped = source.toMultimap(lengthFuncErr); - Map> expected = new HashMap>(); + Map> expected = new HashMap<>(); expected.put(1, Arrays.asList("a", "b")); expected.put(2, Arrays.asList("cc", "dd")); @@ -211,7 +211,7 @@ public String apply(String t1) { Observable>> mapped = source.toMultimap(lengthFunc, duplicateErr); - Map> expected = new HashMap>(); + Map> expected = new HashMap<>(); expected.put(1, Arrays.asList("aa", "bb")); expected.put(2, Arrays.asList("cccc", "dddd")); @@ -241,7 +241,7 @@ public String apply(String v) { } }, mapFactory); - Map> expected = new HashMap>(); + Map> expected = new HashMap<>(); expected.put(2, Arrays.asList("cc", "dd")); expected.put(3, Arrays.asList("eee", "fff")); @@ -262,7 +262,7 @@ public Collection apply(Integer t1) { if (t1 == 2) { throw new RuntimeException("Forced failure"); } else { - return new HashSet(); + return new HashSet<>(); } } }; @@ -276,14 +276,14 @@ public String apply(String v) { Supplier>> mapSupplier = new Supplier>>() { @Override public Map> get() { - return new HashMap>(); + return new HashMap<>(); } }; Observable>> mapped = source.toMultimap(lengthFunc, identity, mapSupplier, collectionFactory); - Map> expected = new HashMap>(); + Map> expected = new HashMap<>(); expected.put(2, Arrays.asList("cc", "dd")); expected.put(3, Collections.singleton("eee")); diff --git a/src/test/java/io/reactivex/internal/operators/OperatorToObservableListTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorToObservableListTest.java similarity index 94% rename from src/test/java/io/reactivex/internal/operators/OperatorToObservableListTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorToObservableListTest.java index 660b4ae2f0..b2a4f6f1e3 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorToObservableListTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorToObservableListTest.java @@ -99,7 +99,7 @@ public void testListWithBlockingFirst() { @Test public void testBackpressureHonored() { Observable> w = Observable.just(1, 2, 3, 4, 5).toList(); - TestSubscriber> ts = new TestSubscriber>((Long)null); + TestSubscriber> ts = new TestSubscriber<>((Long) null); w.subscribe(ts); @@ -132,15 +132,12 @@ public void testAsyncRequested() { Observable> sorted = source.toList(); final CyclicBarrier cb = new CyclicBarrier(2); - final TestSubscriber> ts = new TestSubscriber>((Long)null); + final TestSubscriber> ts = new TestSubscriber<>((Long) null); sorted.subscribe(ts); - w.schedule(new Runnable() { - @Override - public void run() { - await(cb); - ts.request(1); - } + w.schedule(() -> { + await(cb); + ts.request(1); }); source.onNext(1); await(cb); diff --git a/src/test/java/io/reactivex/internal/operators/OperatorToObservableSortedListTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorToObservableSortedListTest.java similarity index 88% rename from src/test/java/io/reactivex/internal/operators/OperatorToObservableSortedListTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorToObservableSortedListTest.java index bf7d316178..eef0d787de 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorToObservableSortedListTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorToObservableSortedListTest.java @@ -47,14 +47,7 @@ public void testSortedList() { @Test public void testSortedListWithCustomFunction() { Observable w = Observable.just(1, 3, 2, 5, 4); - Observable> observable = w.toSortedList(new Comparator() { - - @Override - public int compare(Integer t1, Integer t2) { - return t2 - t1; - } - - }); + Observable> observable = w.toSortedList((t1, t2) -> t2 - t1); Subscriber> observer = TestHelper.mockSubscriber(); observable.subscribe(observer); @@ -71,7 +64,7 @@ public void testWithFollowingFirst() { @Test public void testBackpressureHonored() { Observable> w = Observable.just(1, 3, 2, 5, 4).toSortedList(); - TestSubscriber> ts = new TestSubscriber>((Long)null); + TestSubscriber> ts = new TestSubscriber<>((Long) null); w.subscribe(ts); @@ -104,14 +97,11 @@ public void testAsyncRequested() { Observable> sorted = source.toSortedList(); final CyclicBarrier cb = new CyclicBarrier(2); - final TestSubscriber> ts = new TestSubscriber>((Long)null); + final TestSubscriber> ts = new TestSubscriber<>((Long) null); sorted.subscribe(ts); - w.schedule(new Runnable() { - @Override - public void run() { - await(cb); - ts.request(1); - } + w.schedule(() -> { + await(cb); + ts.request(1); }); source.onNext(1); await(cb); diff --git a/src/test/java/io/reactivex/internal/operators/OperatorUnsubscribeOnTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorUnsubscribeOnTest.java similarity index 95% rename from src/test/java/io/reactivex/internal/operators/OperatorUnsubscribeOnTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorUnsubscribeOnTest.java index 48df08e311..948a70f449 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorUnsubscribeOnTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorUnsubscribeOnTest.java @@ -32,7 +32,7 @@ public void testUnsubscribeWhenSubscribeOnAndUnsubscribeOnAreOnSameThread() thro UIEventLoopScheduler UI_EVENT_LOOP = new UIEventLoopScheduler(); try { final ThreadSubscription subscription = new ThreadSubscription(); - final AtomicReference subscribeThread = new AtomicReference(); + final AtomicReference subscribeThread = new AtomicReference<>(); Observable w = Observable.create(new Publisher() { @Override @@ -45,7 +45,7 @@ public void subscribe(Subscriber t1) { } }); - TestSubscriber observer = new TestSubscriber(); + TestSubscriber observer = new TestSubscriber<>(); w.subscribeOn(UI_EVENT_LOOP).observeOn(Schedulers.computation()).unsubscribeOn(UI_EVENT_LOOP).subscribe(observer); observer.awaitTerminalEvent(1, TimeUnit.SECONDS); @@ -76,7 +76,7 @@ public void testUnsubscribeWhenSubscribeOnAndUnsubscribeOnAreOnDifferentThreads( UIEventLoopScheduler UI_EVENT_LOOP = new UIEventLoopScheduler(); try { final ThreadSubscription subscription = new ThreadSubscription(); - final AtomicReference subscribeThread = new AtomicReference(); + final AtomicReference subscribeThread = new AtomicReference<>(); Observable w = Observable.create(new Publisher() { @Override @@ -89,7 +89,7 @@ public void subscribe(Subscriber t1) { } }); - TestSubscriber observer = new TestSubscriber(); + TestSubscriber observer = new TestSubscriber<>(); w.subscribeOn(Schedulers.newThread()).observeOn(Schedulers.computation()).unsubscribeOn(UI_EVENT_LOOP).subscribe(observer); observer.awaitTerminalEvent(1, TimeUnit.SECONDS); @@ -152,14 +152,9 @@ public UIEventLoopScheduler() { * DON'T DO THIS IN PRODUCTION CODE */ final CountDownLatch latch = new CountDownLatch(1); - eventLoop.scheduleDirect(new Runnable() { - - @Override - public void run() { - t = Thread.currentThread(); - latch.countDown(); - } - + eventLoop.scheduleDirect(() -> { + t = Thread.currentThread(); + latch.countDown(); }); try { latch.await(); diff --git a/src/test/java/io/reactivex/internal/operators/OperatorWindowWithObservableTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorWindowWithObservableTest.java similarity index 96% rename from src/test/java/io/reactivex/internal/operators/OperatorWindowWithObservableTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorWindowWithObservableTest.java index 1e3383abff..ac67c863d5 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorWindowWithObservableTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorWindowWithObservableTest.java @@ -40,7 +40,7 @@ public void testWindowViaObservableNormal1() { final Subscriber o = TestHelper.mockSubscriber(); - final List> values = new ArrayList>(); + final List> values = new ArrayList<>(); Subscriber> wo = new Observer>() { @Override @@ -98,7 +98,7 @@ public void testWindowViaObservableBoundaryCompletes() { final Subscriber o = TestHelper.mockSubscriber(); - final List> values = new ArrayList>(); + final List> values = new ArrayList<>(); Subscriber> wo = new Observer>() { @Override @@ -154,7 +154,7 @@ public void testWindowViaObservableBoundaryThrows() { final Subscriber o = TestHelper.mockSubscriber(); - final List> values = new ArrayList>(); + final List> values = new ArrayList<>(); Subscriber> wo = new Observer>() { @Override @@ -204,7 +204,7 @@ public void testWindowViaObservableSourceThrows() { final Subscriber o = TestHelper.mockSubscriber(); - final List> values = new ArrayList>(); + final List> values = new ArrayList<>(); Subscriber> wo = new Observer>() { @Override @@ -292,7 +292,7 @@ public Observable get() { } }; - TestSubscriber> ts = new TestSubscriber>(); + TestSubscriber> ts = new TestSubscriber<>(); source.window(boundary).unsafeSubscribe(ts); assertFalse(ts.isCancelled()); @@ -309,7 +309,7 @@ public Observable get() { } }; - TestSubscriber> ts = new TestSubscriber>(); + TestSubscriber> ts = new TestSubscriber<>(); source.window(boundaryFunc).subscribe(ts); assertTrue(source.hasSubscribers()); @@ -335,7 +335,7 @@ public Observable get() { } }; - TestSubscriber> ts = new TestSubscriber>(); + TestSubscriber> ts = new TestSubscriber<>(); source.window(boundaryFunc).subscribe(ts); assertTrue(source.hasSubscribers()); @@ -363,7 +363,7 @@ public Observable get() { } }; - TestSubscriber> ts = new TestSubscriber>(); + TestSubscriber> ts = new TestSubscriber<>(); source.window(boundaryFunc).subscribe(ts); assertTrue(source.hasSubscribers()); @@ -391,7 +391,7 @@ public Observable get() { } }; - final TestSubscriber ts = new TestSubscriber(1L); + final TestSubscriber ts = new TestSubscriber<>(1L); final TestSubscriber> ts1 = new TestSubscriber>(1L) { @Override public void onNext(Observable t) { @@ -430,7 +430,7 @@ public Observable get() { } }; - TestSubscriber> ts = new TestSubscriber>(); + TestSubscriber> ts = new TestSubscriber<>(); source.window(boundaryFunc).subscribe(ts); source.onNext(1); diff --git a/src/test/java/io/reactivex/internal/operators/OperatorWindowWithSizeTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorWindowWithSizeTest.java similarity index 76% rename from src/test/java/io/reactivex/internal/operators/OperatorWindowWithSizeTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorWindowWithSizeTest.java index 4bb9200414..cc4cf68dff 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorWindowWithSizeTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorWindowWithSizeTest.java @@ -36,20 +36,10 @@ public class OperatorWindowWithSizeTest { private static List> toLists(Observable> observables) { - final List> lists = new ArrayList>(); - Observable.concat(observables.map(new Function, Observable>>() { - @Override - public Observable> apply(Observable xs) { - return xs.toList(); - } - })) + final List> lists = new ArrayList<>(); + Observable.concat(observables.map(Observable::toList)) .toBlocking() - .forEach(new Consumer>() { - @Override - public void accept(List xs) { - lists.add(xs); - } - }); + .forEach(lists::add); return lists; } @@ -107,16 +97,9 @@ public void testSkipAndCountWindowsWithGaps() { @Test public void testWindowUnsubscribeNonOverlapping() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); final AtomicInteger count = new AtomicInteger(); - Observable.merge(Observable.range(1, 10000).doOnNext(new Consumer() { - - @Override - public void accept(Integer t1) { - count.incrementAndGet(); - } - - }).window(5).take(2)).subscribe(ts); + Observable.merge(Observable.range(1, 10000).doOnNext(t1 -> count.incrementAndGet()).window(5).take(2)).subscribe(ts); ts.awaitTerminalEvent(500, TimeUnit.MILLISECONDS); ts.assertTerminated(); ts.assertValues(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); @@ -126,17 +109,10 @@ public void accept(Integer t1) { @Test public void testWindowUnsubscribeNonOverlappingAsyncSource() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); final AtomicInteger count = new AtomicInteger(); Observable.merge(Observable.range(1, 100000) - .doOnNext(new Consumer() { - - @Override - public void accept(Integer t1) { - count.incrementAndGet(); - } - - }) + .doOnNext(t1 -> count.incrementAndGet()) .observeOn(Schedulers.computation()) .window(5) .take(2)) @@ -150,16 +126,9 @@ public void accept(Integer t1) { @Test public void testWindowUnsubscribeOverlapping() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); final AtomicInteger count = new AtomicInteger(); - Observable.merge(Observable.range(1, 10000).doOnNext(new Consumer() { - - @Override - public void accept(Integer t1) { - count.incrementAndGet(); - } - - }).window(5, 4).take(2)).subscribe(ts); + Observable.merge(Observable.range(1, 10000).doOnNext(t1 -> count.incrementAndGet()).window(5, 4).take(2)).subscribe(ts); ts.awaitTerminalEvent(500, TimeUnit.MILLISECONDS); ts.assertTerminated(); // System.out.println(ts.getOnNextEvents()); @@ -169,17 +138,10 @@ public void accept(Integer t1) { @Test public void testWindowUnsubscribeOverlappingAsyncSource() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); final AtomicInteger count = new AtomicInteger(); Observable.merge(Observable.range(1, 100000) - .doOnNext(new Consumer() { - - @Override - public void accept(Integer t1) { - count.incrementAndGet(); - } - - }) + .doOnNext(t1 -> count.incrementAndGet()) .observeOn(Schedulers.computation()) .window(5, 4) .take(2), 128) @@ -192,7 +154,7 @@ public void accept(Integer t1) { } private List list(String... args) { - List list = new ArrayList(); + List list = new ArrayList<>(); for (String arg : args) { list.add(arg); } @@ -203,7 +165,7 @@ private List list(String... args) { public void testBackpressureOuter() { Observable> source = Observable.range(1, 10).window(3); - final List list = new ArrayList(); + final List list = new ArrayList<>(); final Subscriber o = TestHelper.mockSubscriber(); @@ -271,19 +233,14 @@ public void subscribe(Subscriber s) { @Test public void testTakeFlatMapCompletes() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); final int indicator = 999999999; hotStream() .window(10) .take(2) - .flatMap(new Function, Observable>() { - @Override - public Observable apply(Observable w) { - return w.startWith(indicator); - } - }).subscribe(ts); + .flatMap(w -> w.startWith(indicator)).subscribe(ts); ts.awaitTerminalEvent(2, TimeUnit.SECONDS); ts.assertComplete(); @@ -293,20 +250,10 @@ public Observable apply(Observable w) { @SuppressWarnings("unchecked") @Test public void testBackpressureOuterInexact() { - TestSubscriber> ts = new TestSubscriber>((Long)null); + TestSubscriber> ts = new TestSubscriber<>((Long) null); Observable.range(1, 5).window(2, 1) - .map(new Function, Observable>>() { - @Override - public Observable> apply(Observable t) { - return t.toList(); - } - }).concatMap(new Function>, Publisher>>() { - @Override - public Publisher> apply(Observable> v) { - return v; - } - }) + .map(Observable::toList).concatMap(v -> v) .subscribe(ts); ts.assertNoErrors(); diff --git a/src/test/java/io/reactivex/internal/operators/OperatorWindowWithStartEndObservableTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorWindowWithStartEndObservableTest.java similarity index 63% rename from src/test/java/io/reactivex/internal/operators/OperatorWindowWithStartEndObservableTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorWindowWithStartEndObservableTest.java index 4e430c9172..9d9197a0ff 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorWindowWithStartEndObservableTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorWindowWithStartEndObservableTest.java @@ -43,8 +43,8 @@ public void before() { @Test public void testObservableBasedOpenerAndCloser() { - final List list = new ArrayList(); - final List> lists = new ArrayList>(); + final List list = new ArrayList<>(); + final List> lists = new ArrayList<>(); Observable source = Observable.create(new Publisher() { @Override @@ -59,29 +59,18 @@ public void subscribe(Subscriber observer) { } }); - Observable openings = Observable.create(new Publisher() { - @Override - public void subscribe(Subscriber observer) { - observer.onSubscribe(EmptySubscription.INSTANCE); - push(observer, new Object(), 50); - push(observer, new Object(), 200); - complete(observer, 250); - } + Observable openings = Observable.create(observer -> { + observer.onSubscribe(EmptySubscription.INSTANCE); + push(observer, new Object(), 50); + push(observer, new Object(), 200); + complete(observer, 250); }); - Function> closer = new Function>() { - @Override - public Observable apply(Object opening) { - return Observable.create(new Publisher() { - @Override - public void subscribe(Subscriber observer) { - observer.onSubscribe(EmptySubscription.INSTANCE); - push(observer, new Object(), 100); - complete(observer, 101); - } - }); - } - }; + Function> closer = opening -> Observable.create(observer -> { + observer.onSubscribe(EmptySubscription.INSTANCE); + push(observer, new Object(), 100); + complete(observer, 101); + }); Observable> windowed = source.window(openings, closer); windowed.subscribe(observeWindow(list, lists)); @@ -94,8 +83,8 @@ public void subscribe(Subscriber observer) { @Test public void testObservableBasedCloser() { - final List list = new ArrayList(); - final List> lists = new ArrayList>(); + final List list = new ArrayList<>(); + final List> lists = new ArrayList<>(); Observable source = Observable.create(new Publisher() { @Override @@ -114,19 +103,16 @@ public void subscribe(Subscriber observer) { int calls; @Override public Observable get() { - return Observable.create(new Publisher() { - @Override - public void subscribe(Subscriber observer) { - observer.onSubscribe(EmptySubscription.INSTANCE); - int c = calls++; - if (c == 0) { - push(observer, new Object(), 100); - } else - if (c == 1) { - push(observer, new Object(), 100); - } else { - complete(observer, 101); - } + return Observable.create(observer -> { + observer.onSubscribe(EmptySubscription.INSTANCE); + int c = calls++; + if (c == 0) { + push(observer, new Object(), 100); + } else + if (c == 1) { + push(observer, new Object(), 100); + } else { + complete(observer, 101); } }); } @@ -143,7 +129,7 @@ public void subscribe(Subscriber observer) { } private List list(String... args) { - List list = new ArrayList(); + List list = new ArrayList<>(); for (String arg : args) { list.add(arg); } @@ -151,46 +137,31 @@ private List list(String... args) { } private void push(final Subscriber observer, final T value, int delay) { - innerScheduler.schedule(new Runnable() { - @Override - public void run() { - observer.onNext(value); - } - }, delay, TimeUnit.MILLISECONDS); + innerScheduler.schedule(() -> observer.onNext(value), delay, TimeUnit.MILLISECONDS); } private void complete(final Subscriber observer, int delay) { - innerScheduler.schedule(new Runnable() { - @Override - public void run() { - observer.onComplete(); - } - }, delay, TimeUnit.MILLISECONDS); + innerScheduler.schedule(observer::onComplete, delay, TimeUnit.MILLISECONDS); } private Consumer> observeWindow(final List list, final List> lists) { - return new Consumer>() { + return stringObservable -> stringObservable.subscribe(new Observer() { @Override - public void accept(Observable stringObservable) { - stringObservable.subscribe(new Observer() { - @Override - public void onComplete() { - lists.add(new ArrayList(list)); - list.clear(); - } + public void onComplete() { + lists.add(new ArrayList<>(list)); + list.clear(); + } - @Override - public void onError(Throwable e) { - fail(e.getMessage()); - } + @Override + public void onError(Throwable e) { + fail(e.getMessage()); + } - @Override - public void onNext(String args) { - list.add(args); - } - }); + @Override + public void onNext(String args) { + list.add(args); } - }; + }); } @Test @@ -200,14 +171,9 @@ public void testNoUnsubscribeAndNoLeak() { PublishSubject open = PublishSubject.create(); final PublishSubject close = PublishSubject.create(); - TestSubscriber> ts = new TestSubscriber>(); + TestSubscriber> ts = new TestSubscriber<>(); - source.window(open, new Function>() { - @Override - public Observable apply(Integer t) { - return close; - } - }).unsafeSubscribe(ts); + source.window(open, t -> close).unsafeSubscribe(ts); open.onNext(1); source.onNext(1); @@ -237,14 +203,9 @@ public void testUnsubscribeAll() { PublishSubject open = PublishSubject.create(); final PublishSubject close = PublishSubject.create(); - TestSubscriber> ts = new TestSubscriber>(); + TestSubscriber> ts = new TestSubscriber<>(); - source.window(open, new Function>() { - @Override - public Observable apply(Integer t) { - return close; - } - }).unsafeSubscribe(ts); + source.window(open, t -> close).unsafeSubscribe(ts); open.onNext(1); diff --git a/src/test/java/io/reactivex/internal/operators/OperatorWindowWithTimeTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorWindowWithTimeTest.java similarity index 68% rename from src/test/java/io/reactivex/internal/operators/OperatorWindowWithTimeTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorWindowWithTimeTest.java index 46d976992d..78631b386f 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorWindowWithTimeTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorWindowWithTimeTest.java @@ -44,8 +44,8 @@ public void before() { @Test public void testTimedAndCount() { - final List list = new ArrayList(); - final List> lists = new ArrayList>(); + final List list = new ArrayList<>(); + final List> lists = new ArrayList<>(); Observable source = Observable.create(new Publisher() { @Override @@ -78,8 +78,8 @@ public void subscribe(Subscriber observer) { @Test public void testTimed() { - final List list = new ArrayList(); - final List> lists = new ArrayList>(); + final List list = new ArrayList<>(); + final List> lists = new ArrayList<>(); Observable source = Observable.create(new Publisher() { @Override @@ -107,7 +107,7 @@ public void subscribe(Subscriber observer) { } private List list(String... args) { - List list = new ArrayList(); + List list = new ArrayList<>(); for (String arg : args) { list.add(arg); } @@ -115,54 +115,39 @@ private List list(String... args) { } private void push(final Subscriber observer, final T value, int delay) { - innerScheduler.schedule(new Runnable() { - @Override - public void run() { - observer.onNext(value); - } - }, delay, TimeUnit.MILLISECONDS); + innerScheduler.schedule(() -> observer.onNext(value), delay, TimeUnit.MILLISECONDS); } private void complete(final Subscriber observer, int delay) { - innerScheduler.schedule(new Runnable() { - @Override - public void run() { - observer.onComplete(); - } - }, delay, TimeUnit.MILLISECONDS); + innerScheduler.schedule(observer::onComplete, delay, TimeUnit.MILLISECONDS); } private Consumer> observeWindow(final List list, final List> lists) { - return new Consumer>() { + return stringObservable -> stringObservable.subscribe(new Observer() { @Override - public void accept(Observable stringObservable) { - stringObservable.subscribe(new Observer() { - @Override - public void onComplete() { - lists.add(new ArrayList(list)); - list.clear(); - } - - @Override - public void onError(Throwable e) { - Assert.fail(e.getMessage()); - } - - @Override - public void onNext(T args) { - list.add(args); - } - }); + public void onComplete() { + lists.add(new ArrayList<>(list)); + list.clear(); } - }; + + @Override + public void onError(Throwable e) { + Assert.fail(e.getMessage()); + } + + @Override + public void onNext(T args) { + list.add(args); + } + }); } @Test public void testExactWindowSize() { Observable> source = Observable.range(1, 10) .window(1, TimeUnit.MINUTES, scheduler, 3); - final List list = new ArrayList(); - final List> lists = new ArrayList>(); + final List list = new ArrayList<>(); + final List> lists = new ArrayList<>(); source.subscribe(observeWindow(list, lists)); @@ -179,7 +164,7 @@ public void testExactWindowSize() { @Test public void testTakeFlatMapCompletes() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); final AtomicInteger wip = new AtomicInteger(); @@ -188,31 +173,10 @@ public void testTakeFlatMapCompletes() { OperatorWindowWithSizeTest.hotStream() .window(300, TimeUnit.MILLISECONDS) .take(10) - .doOnComplete(new Runnable() { - @Override - public void run() { - System.out.println("Main done!"); - } - }) - .flatMap(new Function, Observable>() { - @Override - public Observable apply(Observable w) { - return w.startWith(indicator) - .doOnComplete(new Runnable() { - @Override - public void run() { - System.out.println("inner done: " + wip.incrementAndGet()); - } - }) - ; - } - }) - .doOnNext(new Consumer() { - @Override - public void accept(Integer pv) { - System.out.println(pv); - } - }) + .doOnComplete(() -> System.out.println("Main done!")) + .flatMap(w -> w.startWith(indicator).doOnComplete(() -> + System.out.println("inner done: " + wip.incrementAndGet())) + ).doOnNext(System.out::println) .subscribe(ts); ts.awaitTerminalEvent(5, TimeUnit.SECONDS); diff --git a/src/test/java/io/reactivex/internal/operators/OperatorWithLatestFromTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorWithLatestFromTest.java similarity index 89% rename from src/test/java/io/reactivex/internal/operators/OperatorWithLatestFromTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorWithLatestFromTest.java index f5f62d2ad8..fb3fb5a15e 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorWithLatestFromTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorWithLatestFromTest.java @@ -28,17 +28,9 @@ import io.reactivex.subscribers.TestSubscriber; public class OperatorWithLatestFromTest { - static final BiFunction COMBINER = new BiFunction() { - @Override - public Integer apply(Integer t1, Integer t2) { - return (t1 << 8) + t2; - } - }; - static final BiFunction COMBINER_ERROR = new BiFunction() { - @Override - public Integer apply(Integer t1, Integer t2) { - throw new TestException("Forced failure"); - } + static final BiFunction COMBINER = (t1, t2) -> (t1 << 8) + t2; + static final BiFunction COMBINER_ERROR = (t1, t2) -> { + throw new TestException("Forced failure"); }; @Test public void testSimple() { @@ -83,7 +75,7 @@ public void testEmptySource() { Observable result = source.withLatestFrom(other, COMBINER); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); result.subscribe(ts); @@ -109,7 +101,7 @@ public void testEmptyOther() { Observable result = source.withLatestFrom(other, COMBINER); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); result.subscribe(ts); @@ -136,7 +128,7 @@ public void testUnsubscription() { Observable result = source.withLatestFrom(other, COMBINER); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); result.subscribe(ts); @@ -163,7 +155,7 @@ public void testSourceThrows() { Observable result = source.withLatestFrom(other, COMBINER); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); result.subscribe(ts); @@ -190,7 +182,7 @@ public void testOtherThrows() { Observable result = source.withLatestFrom(other, COMBINER); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); result.subscribe(ts); @@ -218,7 +210,7 @@ public void testFunctionThrows() { Observable result = source.withLatestFrom(other, COMBINER_ERROR); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); result.subscribe(ts); @@ -244,7 +236,7 @@ public void testNoDownstreamUnsubscribe() { Observable result = source.withLatestFrom(other, COMBINER); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); result.unsafeSubscribe(ts); @@ -260,7 +252,7 @@ public void testBackpressure() { Observable result = source.withLatestFrom(other, COMBINER); - TestSubscriber ts = new TestSubscriber((Long)null); + TestSubscriber ts = new TestSubscriber<>((Long) null); result.subscribe(ts); diff --git a/src/test/java/io/reactivex/internal/operators/OperatorZipCompletionTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorZipCompletionTest.java similarity index 93% rename from src/test/java/io/reactivex/internal/operators/OperatorZipCompletionTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorZipCompletionTest.java index c2f74d843f..d0d15b21bd 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorZipCompletionTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorZipCompletionTest.java @@ -40,12 +40,7 @@ public class OperatorZipCompletionTest { @Before public void setUp() { - concat2Strings = new BiFunction() { - @Override - public String apply(String t1, String t2) { - return t1 + "-" + t2; - } - }; + concat2Strings = (t1, t2) -> t1 + "-" + t2; s1 = PublishSubject.create(); s2 = PublishSubject.create(); diff --git a/src/test/java/io/reactivex/internal/operators/OperatorZipIterableTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorZipIterableTest.java similarity index 74% rename from src/test/java/io/reactivex/internal/operators/OperatorZipIterableTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorZipIterableTest.java index f2e8b407e0..d50e8782b0 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorZipIterableTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorZipIterableTest.java @@ -41,12 +41,7 @@ public class OperatorZipIterableTest { @Before public void setUp() { - concat2Strings = new BiFunction() { - @Override - public String apply(String t1, String t2) { - return t1 + "-" + t2; - } - }; + concat2Strings = (t1, t2) -> t1 + "-" + t2; s1 = PublishSubject.create(); s2 = PublishSubject.create(); @@ -58,22 +53,8 @@ public String apply(String t1, String t2) { zipped.subscribe(observer); } - BiFunction zipr2 = new BiFunction() { - - @Override - public String apply(Object t1, Object t2) { - return "" + t1 + t2; - } - - }; - Function3 zipr3 = new Function3() { - - @Override - public String apply(Object t1, Object t2, Object t3) { - return "" + t1 + t2 + t3; - } - - }; + BiFunction zipr2 = (t1, t2) -> "" + t1 + t2; + Function3 zipr3 = (t1, t2, t3) -> "" + t1 + t2 + t3; @Test public void testZipIterableSameSize() { @@ -219,11 +200,8 @@ public void testZipIterableIteratorThrows() { Subscriber o = TestHelper.mockSubscriber(); InOrder io = inOrder(o); - Iterable r2 = new Iterable() { - @Override - public Iterator iterator() { - throw new TestException(); - } + Iterable r2 = () -> { + throw new TestException(); }; r1.zipWith(r2, zipr2).subscribe(o); @@ -246,33 +224,26 @@ public void testZipIterableHasNextThrows() { Subscriber o = TestHelper.mockSubscriber(); InOrder io = inOrder(o); - Iterable r2 = new Iterable() { + Iterable r2 = () -> new Iterator() { + int count; + + @Override + public boolean hasNext() { + if (count == 0) { + return true; + } + throw new TestException(); + } @Override - public Iterator iterator() { - return new Iterator() { - int count; - - @Override - public boolean hasNext() { - if (count == 0) { - return true; - } - throw new TestException(); - } - - @Override - public String next() { - count++; - return "1"; - } - - @Override - public void remove() { - throw new UnsupportedOperationException("Not supported yet."); - } - - }; + public String next() { + count++; + return "1"; + } + + @Override + public void remove() { + throw new UnsupportedOperationException("Not supported yet."); } }; @@ -296,27 +267,20 @@ public void testZipIterableNextThrows() { Subscriber o = TestHelper.mockSubscriber(); InOrder io = inOrder(o); - Iterable r2 = new Iterable() { + Iterable r2 = () -> new Iterator() { + @Override + public boolean hasNext() { + return true; + } + + @Override + public String next() { + throw new TestException(); + } @Override - public Iterator iterator() { - return new Iterator() { - @Override - public boolean hasNext() { - return true; - } - - @Override - public String next() { - throw new TestException(); - } - - @Override - public void remove() { - throw new UnsupportedOperationException("Not supported yet."); - } - - }; + public void remove() { + throw new UnsupportedOperationException("Not supported yet."); } }; @@ -331,33 +295,19 @@ public void remove() { verify(o, never()).onComplete(); } - - Consumer printer = new Consumer() { - @Override - public void accept(String pv) { - System.out.println(pv); - } - }; - - static final class SquareStr implements Function { - final AtomicInteger counter = new AtomicInteger(); - @Override - public String apply(Integer t1) { - counter.incrementAndGet(); - System.out.println("Omg I'm calculating so hard: " + t1 + "*" + t1 + "=" + (t1*t1)); - return " " + (t1*t1); - } - } @Test public void testTake2() { Observable o = Observable.just(1, 2, 3, 4, 5); Iterable it = Arrays.asList("a", "b", "c", "d", "e"); + + final AtomicInteger counter = new AtomicInteger(); + o.map(t1 -> { + counter.incrementAndGet(); + System.out.println("Omg I'm calculating so hard: " + t1 + "*" + t1 + "=" + (t1*t1)); + return " " + (t1*t1); + }).zipWith(it, concat2Strings).take(2).subscribe(System.out::println); - SquareStr squareStr = new SquareStr(); - - o.map(squareStr).zipWith(it, concat2Strings).take(2).subscribe(printer); - - assertEquals(2, squareStr.counter.get()); + assertEquals(2, counter.get()); } } \ No newline at end of file diff --git a/src/test/java/io/reactivex/internal/operators/OperatorZipTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorZipTest.java similarity index 76% rename from src/test/java/io/reactivex/internal/operators/OperatorZipTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/OperatorZipTest.java index 660679191f..736a7bf7fe 100644 --- a/src/test/java/io/reactivex/internal/operators/OperatorZipTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/OperatorZipTest.java @@ -47,12 +47,7 @@ public class OperatorZipTest { @Before public void setUp() { - concat2Strings = new BiFunction() { - @Override - public String apply(String t1, String t2) { - return t1 + "-" + t2; - } - }; + concat2Strings = (t1, t2) -> t1 + "-" + t2; s1 = PublishSubject.create(); s2 = PublishSubject.create(); @@ -152,22 +147,8 @@ public void testStartpingDifferentLengthObservableSequences2() { } - BiFunction zipr2 = new BiFunction() { - - @Override - public String apply(Object t1, Object t2) { - return "" + t1 + t2; - } - - }; - Function3 zipr3 = new Function3() { - - @Override - public String apply(Object t1, Object t2, Object t3) { - return "" + t1 + t2 + t3; - } - - }; + BiFunction zipr2 = (t1, t2) -> "" + t1 + t2; + Function3 zipr3 = (t1, t2, t3) -> "" + t1 + t2 + t3; /** * Testing internal private logic due to the complexity so I want to use TDD to test as a I build it rather than relying purely on the overall functionality expected by the public methods. @@ -350,7 +331,7 @@ public void testAggregatorUnsubscribe() { PublishSubject r2 = PublishSubject.create(); /* define a Subscriber to receive aggregated events */ Subscriber observer = TestHelper.mockSubscriber(); - TestSubscriber ts = new TestSubscriber(observer); + TestSubscriber ts = new TestSubscriber<>(observer); Observable.zip(r1, r2, zipr2).subscribe(ts); @@ -538,70 +519,34 @@ public void testOnErrorTermination() { } private BiFunction getConcat2Strings() { - return new BiFunction() { - - @Override - public String apply(String t1, String t2) { - return t1 + "-" + t2; - } - }; + return (t1, t2) -> t1 + "-" + t2; } private BiFunction getDivideZipr() { - BiFunction zipr = new BiFunction() { - - @Override - public Integer apply(Integer i1, Integer i2) { - return i1 / i2; - } - - }; - return zipr; + return (i1, i2) -> i1 / i2; } private Function3 getConcat3StringsZipr() { - Function3 zipr = new Function3() { - - @Override - public String apply(String a1, String a2, String a3) { - if (a1 == null) { - a1 = ""; - } - if (a2 == null) { - a2 = ""; - } - if (a3 == null) { - a3 = ""; - } - return a1 + a2 + a3; + return (a1, a2, a3) -> { + if (a1 == null) { + a1 = ""; } - + if (a2 == null) { + a2 = ""; + } + if (a3 == null) { + a3 = ""; + } + return a1 + a2 + a3; }; - return zipr; } private BiFunction getConcatStringIntegerZipr() { - BiFunction zipr = new BiFunction() { - - @Override - public String apply(String s, Integer i) { - return getStringValue(s) + getStringValue(i); - } - - }; - return zipr; + return (s, i) -> getStringValue(s) + getStringValue(i); } private Function3 getConcatStringIntegerIntArrayZipr() { - Function3 zipr = new Function3() { - - @Override - public String apply(String s, Integer i, int[] iArray) { - return getStringValue(s) + getStringValue(i) + getStringValue(iArray); - } - - }; - return zipr; + return (s, i, iArray) -> getStringValue(s) + getStringValue(i) + getStringValue(iArray); } private static String getStringValue(Object o) { @@ -727,12 +672,7 @@ public void testStartWithOnCompletedTwice() { final Subscriber observer = TestHelper.mockSubscriber(); Observable.zip(Observable.just(1), - Observable.just(1), new BiFunction() { - @Override - public Integer apply(Integer a, Integer b) { - return a + b; - } - }).subscribe(new Observer() { + Observable.just(1), (a, b) -> a + b).subscribe(new Observer() { @Override public void onComplete() { @@ -760,22 +700,12 @@ public void onNext(Integer args) { @Test public void testStart() { Observable os = OBSERVABLE_OF_5_INTEGERS - .zipWith(OBSERVABLE_OF_5_INTEGERS, new BiFunction() { - - @Override - public String apply(Integer a, Integer b) { - return a + "-" + b; - } - }); + .zipWith(OBSERVABLE_OF_5_INTEGERS, (a, b) -> a + "-" + b); - final ArrayList list = new ArrayList(); - os.subscribe(new Consumer() { - - @Override - public void accept(String s) { - System.out.println(s); - list.add(s); - } + final ArrayList list = new ArrayList<>(); + os.subscribe(s -> { + System.out.println(s); + list.add(s); }); assertEquals(5, list.size()); @@ -787,15 +717,9 @@ public void accept(String s) { @Test public void testStartAsync() throws InterruptedException { Observable os = ASYNC_OBSERVABLE_OF_INFINITE_INTEGERS(new CountDownLatch(1)).onBackpressureBuffer() - .zipWith(ASYNC_OBSERVABLE_OF_INFINITE_INTEGERS(new CountDownLatch(1)).onBackpressureBuffer(), new BiFunction() { - - @Override - public String apply(Integer a, Integer b) { - return a + "-" + b; - } - }).take(5); + .zipWith(ASYNC_OBSERVABLE_OF_INFINITE_INTEGERS(new CountDownLatch(1)).onBackpressureBuffer(), (a, b) -> a + "-" + b).take(5); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); os.subscribe(ts); ts.awaitTerminalEvent(); @@ -812,15 +736,9 @@ public void testStartInfiniteAndFinite() throws InterruptedException { final CountDownLatch latch = new CountDownLatch(1); final CountDownLatch infiniteObservable = new CountDownLatch(1); Observable os = OBSERVABLE_OF_5_INTEGERS - .zipWith(ASYNC_OBSERVABLE_OF_INFINITE_INTEGERS(infiniteObservable), new BiFunction() { - - @Override - public String apply(Integer a, Integer b) { - return a + "-" + b; - } - }); + .zipWith(ASYNC_OBSERVABLE_OF_INFINITE_INTEGERS(infiniteObservable), (a, b) -> a + "-" + b); - final ArrayList list = new ArrayList(); + final ArrayList list = new ArrayList<>(); os.subscribe(new Observer() { @Override @@ -857,23 +775,12 @@ public void onNext(String s) { public void testEmitNull() { Observable oi = Observable.just(1, null, 3); Observable os = Observable.just("a", "b", null); - Observable o = Observable.zip(oi, os, new BiFunction() { - - @Override - public String apply(Integer t1, String t2) { - return t1 + "-" + t2; - } - - }); - - final ArrayList list = new ArrayList(); - o.subscribe(new Consumer() { + Observable o = Observable.zip(oi, os, (t1, t2) -> t1 + "-" + t2); - @Override - public void accept(String s) { - System.out.println(s); - list.add(s); - } + final ArrayList list = new ArrayList<>(); + o.subscribe(s -> { + System.out.println(s); + list.add(s); }); assertEquals(3, list.size()); @@ -906,23 +813,12 @@ static String value(Try notification) { public void testEmitMaterializedNotifications() { Observable>> oi = Observable.just(1, 2, 3).materialize(); Observable>> os = Observable.just("a", "b", "c").materialize(); - Observable o = Observable.zip(oi, os, new BiFunction>, Try>, String>() { + Observable o = Observable.zip(oi, os, (t1, t2) -> kind(t1) + "_" + value(t1) + "-" + kind(t2) + "_" + value(t2)); - @Override - public String apply(Try> t1, Try> t2) { - return kind(t1) + "_" + value(t1) + "-" + kind(t2) + "_" + value(t2); - } - - }); - - final ArrayList list = new ArrayList(); - o.subscribe(new Consumer() { - - @Override - public void accept(String s) { - System.out.println(s); - list.add(s); - } + final ArrayList list = new ArrayList<>(); + o.subscribe(s -> { + System.out.println(s); + list.add(s); }); assertEquals(4, list.size()); @@ -935,23 +831,12 @@ public void accept(String s) { @Test public void testStartEmptyObservables() { - Observable o = Observable.zip(Observable. empty(), Observable. empty(), new BiFunction() { + Observable o = Observable.zip(Observable. empty(), Observable. empty(), (t1, t2) -> t1 + "-" + t2); - @Override - public String apply(Integer t1, String t2) { - return t1 + "-" + t2; - } - - }); - - final ArrayList list = new ArrayList(); - o.subscribe(new Consumer() { - - @Override - public void accept(String s) { - System.out.println(s); - list.add(s); - } + final ArrayList list = new ArrayList<>(); + o.subscribe(s -> { + System.out.println(s); + list.add(s); }); assertEquals(0, list.size()); @@ -963,15 +848,12 @@ public void testStartEmptyList() { final Object invoked = new Object(); Collection> observables = Collections.emptyList(); - Observable o = Observable.zip(observables, new Function() { - @Override - public Object apply(final Object[] args) { - assertEquals("No argument should have been passed", 0, args.length); - return invoked; - } + Observable o = Observable.zip(observables, args -> { + assertEquals("No argument should have been passed", 0, args.length); + return invoked; }); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); o.subscribe(ts); ts.awaitTerminalEvent(200, TimeUnit.MILLISECONDS); ts.assertNoValues(); @@ -987,12 +869,9 @@ public void testStartEmptyListBlocking() { final Object invoked = new Object(); Collection> observables = Collections.emptyList(); - Observable o = Observable.zip(observables, new Function() { - @Override - public Object apply(final Object[] args) { - assertEquals("No argument should have been passed", 0, args.length); - return invoked; - } + Observable o = Observable.zip(observables, args -> { + assertEquals("No argument should have been passed", 0, args.length); + return invoked; }); o.toBlocking().last(); @@ -1005,15 +884,8 @@ public void testBackpressureSync() { Observable o1 = createInfiniteObservable(generatedA); Observable o2 = createInfiniteObservable(generatedB); - TestSubscriber ts = new TestSubscriber(); - Observable.zip(o1, o2, new BiFunction() { - - @Override - public String apply(Integer t1, Integer t2) { - return t1 + "-" + t2; - } - - }).take(Observable.bufferSize() * 2).subscribe(ts); + TestSubscriber ts = new TestSubscriber<>(); + Observable.zip(o1, o2, (t1, t2) -> t1 + "-" + t2).take(Observable.bufferSize() * 2).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); @@ -1029,15 +901,8 @@ public void testBackpressureAsync() { Observable o1 = createInfiniteObservable(generatedA).subscribeOn(Schedulers.computation()); Observable o2 = createInfiniteObservable(generatedB).subscribeOn(Schedulers.computation()); - TestSubscriber ts = new TestSubscriber(); - Observable.zip(o1, o2, new BiFunction() { - - @Override - public String apply(Integer t1, Integer t2) { - return t1 + "-" + t2; - } - - }).take(Observable.bufferSize() * 2).subscribe(ts); + TestSubscriber ts = new TestSubscriber<>(); + Observable.zip(o1, o2, (t1, t2) -> t1 + "-" + t2).take(Observable.bufferSize() * 2).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); @@ -1053,15 +918,8 @@ public void testDownstreamBackpressureRequestsWithFiniteSyncObservables() { Observable o1 = createInfiniteObservable(generatedA).take(Observable.bufferSize() * 2); Observable o2 = createInfiniteObservable(generatedB).take(Observable.bufferSize() * 2); - TestSubscriber ts = new TestSubscriber(); - Observable.zip(o1, o2, new BiFunction() { - - @Override - public String apply(Integer t1, Integer t2) { - return t1 + "-" + t2; - } - - }).observeOn(Schedulers.computation()).take(Observable.bufferSize() * 2).subscribe(ts); + TestSubscriber ts = new TestSubscriber<>(); + Observable.zip(o1, o2, (t1, t2) -> t1 + "-" + t2).observeOn(Schedulers.computation()).take(Observable.bufferSize() * 2).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); @@ -1078,15 +936,8 @@ public void testDownstreamBackpressureRequestsWithInfiniteAsyncObservables() { Observable o1 = createInfiniteObservable(generatedA).subscribeOn(Schedulers.computation()); Observable o2 = createInfiniteObservable(generatedB).subscribeOn(Schedulers.computation()); - TestSubscriber ts = new TestSubscriber(); - Observable.zip(o1, o2, new BiFunction() { - - @Override - public String apply(Integer t1, Integer t2) { - return t1 + "-" + t2; - } - - }).observeOn(Schedulers.computation()).take(Observable.bufferSize() * 2).subscribe(ts); + TestSubscriber ts = new TestSubscriber<>(); + Observable.zip(o1, o2, (t1, t2) -> t1 + "-" + t2).observeOn(Schedulers.computation()).take(Observable.bufferSize() * 2).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); @@ -1103,15 +954,8 @@ public void testDownstreamBackpressureRequestsWithInfiniteSyncObservables() { Observable o1 = createInfiniteObservable(generatedA); Observable o2 = createInfiniteObservable(generatedB); - TestSubscriber ts = new TestSubscriber(); - Observable.zip(o1, o2, new BiFunction() { - - @Override - public String apply(Integer t1, Integer t2) { - return t1 + "-" + t2; - } - - }).observeOn(Schedulers.computation()).take(Observable.bufferSize() * 2).subscribe(ts); + TestSubscriber ts = new TestSubscriber<>(); + Observable.zip(o1, o2, (t1, t2) -> t1 + "-" + t2).observeOn(Schedulers.computation()).take(Observable.bufferSize() * 2).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); @@ -1122,28 +966,22 @@ public String apply(Integer t1, Integer t2) { } private Observable createInfiniteObservable(final AtomicInteger generated) { - Observable observable = Observable.fromIterable(new Iterable() { - @Override - public Iterator iterator() { - return new Iterator() { + return Observable.fromIterable(() -> new Iterator() { - @Override - public void remove() { - } + @Override + public void remove() { + } - @Override - public Integer next() { - return generated.getAndIncrement(); - } + @Override + public Integer next() { + return generated.getAndIncrement(); + } - @Override - public boolean hasNext() { - return true; - } - }; + @Override + public boolean hasNext() { + return true; } }); - return observable; } Observable OBSERVABLE_OF_5_INTEGERS = OBSERVABLE_OF_5_INTEGERS(new AtomicInteger()); @@ -1176,21 +1014,17 @@ Observable ASYNC_OBSERVABLE_OF_INFINITE_INTEGERS(final CountDownLatch l public void subscribe(final Subscriber o) { final BooleanSubscription bs = new BooleanSubscription(); o.onSubscribe(bs); - Thread t = new Thread(new Runnable() { - - @Override - public void run() { - System.out.println("-------> subscribe to infinite sequence"); - System.out.println("Starting thread: " + Thread.currentThread()); - int i = 1; - while (!bs.isCancelled()) { - o.onNext(i++); - Thread.yield(); - } - o.onComplete(); - latch.countDown(); - System.out.println("Ending thread: " + Thread.currentThread()); + Thread t = new Thread(() -> { + System.out.println("-------> subscribe to infinite sequence"); + System.out.println("Starting thread: " + Thread.currentThread()); + int i = 1; + while (!bs.isCancelled()) { + o.onNext(i++); + Thread.yield(); } + o.onComplete(); + latch.countDown(); + System.out.println("Ending thread: " + Thread.currentThread()); }); t.start(); @@ -1202,23 +1036,9 @@ public void run() { @Test(timeout = 30000) public void testIssue1812() { // https://github.com/ReactiveX/RxJava/issues/1812 - Observable zip1 = Observable.zip(Observable.range(0, 1026), Observable.range(0, 1026), - new BiFunction() { - - @Override - public Integer apply(Integer i1, Integer i2) { - return i1 + i2; - } - }); - Observable zip2 = Observable.zip(zip1, Observable.range(0, 1026), - new BiFunction() { - - @Override - public Integer apply(Integer i1, Integer i2) { - return i1 + i2; - } - }); - List expected = new ArrayList(); + Observable zip1 = Observable.zip(Observable.range(0, 1026), Observable.range(0, 1026), (i1, i2) -> i1 + i2); + Observable zip2 = Observable.zip(zip1, Observable.range(0, 1026), (i1, i2) -> i1 + i2); + List expected = new ArrayList<>(); for (int i = 0; i < 1026; i++) { expected.add(i * 3); } @@ -1226,12 +1046,7 @@ public Integer apply(Integer i1, Integer i2) { } @Test public void testUnboundedDownstreamOverrequesting() { - Observable source = Observable.range(1, 2).zipWith(Observable.range(1, 2), new BiFunction() { - @Override - public Integer apply(Integer t1, Integer t2) { - return t1 + 10 * t2; - } - }); + Observable source = Observable.range(1, 2).zipWith(Observable.range(1, 2), (t1, t2) -> t1 + 10 * t2); TestSubscriber ts = new TestSubscriber() { @Override @@ -1257,12 +1072,7 @@ public void testZipRace() { // used so that this test will not timeout on slow machines. int i = 0; while (System.currentTimeMillis()-startTime < 9000 && i++ < 100000) { - int value = Observable.zip(src, src, new BiFunction() { - @Override - public Integer apply(Integer t1, Integer t2) { - return t1 + t2 * 10; - } - }).toBlocking().single(0); + int value = Observable.zip(src, src, (t1, t2) -> t1 + t2 * 10).toBlocking().single(0); Assert.assertEquals(11, value); } @@ -1274,14 +1084,9 @@ public Integer apply(Integer t1, Integer t2) { @Test public void testZipRequest1() { Observable src = Observable.just(1).subscribeOn(Schedulers.computation()); - TestSubscriber ts = new TestSubscriber(1L); + TestSubscriber ts = new TestSubscriber<>(1L); - Observable.zip(src, src, new BiFunction() { - @Override - public Integer apply(Integer t1, Integer t2) { - return t1 + t2 * 10; - } - }).subscribe(ts); + Observable.zip(src, src, (t1, t2) -> t1 + t2 * 10).subscribe(ts); ts.awaitTerminalEvent(1, TimeUnit.SECONDS); ts.assertNoErrors(); diff --git a/src/test/java/io/reactivex/internal/operators/PublisherDelaySubscriptionOtherTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/PublisherDelaySubscriptionOtherTest.java similarity index 78% rename from src/test/java/io/reactivex/internal/operators/PublisherDelaySubscriptionOtherTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/PublisherDelaySubscriptionOtherTest.java index a3631ed02a..2f2d3b323c 100644 --- a/src/test/java/io/reactivex/internal/operators/PublisherDelaySubscriptionOtherTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/PublisherDelaySubscriptionOtherTest.java @@ -28,17 +28,12 @@ public class PublisherDelaySubscriptionOtherTest { public void testNoPrematureSubscription() { PublishSubject other = PublishSubject.create(); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); final AtomicInteger subscribed = new AtomicInteger(); Observable.just(1) - .doOnSubscribe(new Consumer() { - @Override - public void accept(Subscription s) { - subscribed.getAndIncrement(); - } - }) + .doOnSubscribe(s -> subscribed.getAndIncrement()) .delaySubscription(other) .subscribe(ts); @@ -61,17 +56,12 @@ public void accept(Subscription s) { public void testNoMultipleSubscriptions() { PublishSubject other = PublishSubject.create(); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); final AtomicInteger subscribed = new AtomicInteger(); Observable.just(1) - .doOnSubscribe(new Consumer() { - @Override - public void accept(Subscription s) { - subscribed.getAndIncrement(); - } - }) + .doOnSubscribe(s -> subscribed.getAndIncrement()) .delaySubscription(other) .subscribe(ts); @@ -95,17 +85,12 @@ public void accept(Subscription s) { public void testCompleteTriggersSubscription() { PublishSubject other = PublishSubject.create(); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); final AtomicInteger subscribed = new AtomicInteger(); Observable.just(1) - .doOnSubscribe(new Consumer() { - @Override - public void accept(Subscription s) { - subscribed.getAndIncrement(); - } - }) + .doOnSubscribe(s -> subscribed.getAndIncrement()) .delaySubscription(other) .subscribe(ts); @@ -128,17 +113,12 @@ public void accept(Subscription s) { public void testNoPrematureSubscriptionToError() { PublishSubject other = PublishSubject.create(); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); final AtomicInteger subscribed = new AtomicInteger(); Observable.error(new TestException()) - .doOnSubscribe(new Consumer() { - @Override - public void accept(Subscription s) { - subscribed.getAndIncrement(); - } - }) + .doOnSubscribe(s -> subscribed.getAndIncrement()) .delaySubscription(other) .subscribe(ts); @@ -161,17 +141,12 @@ public void accept(Subscription s) { public void testNoSubscriptionIfOtherErrors() { PublishSubject other = PublishSubject.create(); - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); final AtomicInteger subscribed = new AtomicInteger(); Observable.error(new TestException()) - .doOnSubscribe(new Consumer() { - @Override - public void accept(Subscription s) { - subscribed.getAndIncrement(); - } - }) + .doOnSubscribe(s -> subscribed.getAndIncrement()) .delaySubscription(other) .subscribe(ts); @@ -195,17 +170,12 @@ public void testBackpressurePassesThrough() { PublishSubject other = PublishSubject.create(); - TestSubscriber ts = new TestSubscriber((Long)null); + TestSubscriber ts = new TestSubscriber<>((Long) null); final AtomicInteger subscribed = new AtomicInteger(); Observable.just(1, 2, 3, 4, 5) - .doOnSubscribe(new Consumer() { - @Override - public void accept(Subscription s) { - subscribed.getAndIncrement(); - } - }) + .doOnSubscribe(s -> subscribed.getAndIncrement()) .delaySubscription(other) .subscribe(ts); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpBlockingOperatorLatestTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpBlockingOperatorLatestTest.java similarity index 100% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpBlockingOperatorLatestTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpBlockingOperatorLatestTest.java diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpBlockingOperatorMostRecentTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpBlockingOperatorMostRecentTest.java similarity index 100% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpBlockingOperatorMostRecentTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpBlockingOperatorMostRecentTest.java diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpBlockingOperatorNextTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpBlockingOperatorNextTest.java similarity index 94% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpBlockingOperatorNextTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpBlockingOperatorNextTest.java index 258e777de3..1abf372fd4 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpBlockingOperatorNextTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpBlockingOperatorNextTest.java @@ -240,21 +240,17 @@ public void testNoBufferingOrBlockingOfSequence() throws Throwable { @Override public void accept(final NbpSubscriber o) { o.onSubscribe(EmptyDisposable.INSTANCE); - new Thread(new Runnable() { - - @Override - public void run() { - try { - while (running.get()) { - o.onNext(count.incrementAndGet()); - timeHasPassed.countDown(); - } - o.onComplete(); - } catch (Throwable e) { - o.onError(e); - } finally { - finished.countDown(); + new Thread(() -> { + try { + while (running.get()) { + o.onNext(count.incrementAndGet()); + timeHasPassed.countDown(); } + o.onComplete(); + } catch (Throwable e) { + o.onError(e); + } finally { + finished.countDown(); } }).start(); } diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpBlockingOperatorToIteratorTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpBlockingOperatorToIteratorTest.java similarity index 78% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpBlockingOperatorToIteratorTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpBlockingOperatorToIteratorTest.java index 020b72c4c7..ce2b4e10be 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpBlockingOperatorToIteratorTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpBlockingOperatorToIteratorTest.java @@ -47,15 +47,12 @@ public void testToIterator() { @Test(expected = TestException.class) public void testToIteratorWithException() { - NbpObservable obs = NbpObservable.create(new NbpOnSubscribe() { - - @Override - public void accept(NbpSubscriber NbpObserver) { - NbpObserver.onSubscribe(EmptyDisposable.INSTANCE); - NbpObserver.onNext("one"); - NbpObserver.onError(new TestException()); + NbpObservable obs = NbpObservable.create(subscriber -> { + subscriber.onSubscribe(EmptyDisposable.INSTANCE); + subscriber.onNext("one"); + subscriber.onError(new TestException()); } - }); + ); Iterator it = obs.toBlocking().iterator(); @@ -69,12 +66,10 @@ public void accept(NbpSubscriber NbpObserver) { @Ignore("subscribe() should not throw") @Test(expected = TestException.class) public void testExceptionThrownFromOnSubscribe() { - Iterable strings = NbpObservable.create(new NbpOnSubscribe() { - @Override - public void accept(NbpSubscriber NbpSubscriber) { + Iterable strings = NbpObservable.create(subscriber -> { throw new TestException("intentional"); } - }).toBlocking(); + ).toBlocking(); for (String string : strings) { // never reaches here System.out.println(string); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpBufferUntilSubscriberTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpBufferUntilSubscriberTest.java similarity index 53% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpBufferUntilSubscriberTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpBufferUntilSubscriberTest.java index 585afa1a9f..1d1da2b675 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpBufferUntilSubscriberTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpBufferUntilSubscriberTest.java @@ -39,36 +39,25 @@ public void testIssue1677() throws InterruptedException { final NbpPublishSubject s = NbpPublishSubject.create(); final AtomicBoolean completed = new AtomicBoolean(); NbpObservable.fromArray(numbers) - .takeUntil(s) - .window(50) - .flatMap(new Function, NbpObservable>() { - @Override - public NbpObservable apply(NbpObservable integerObservable) { - return integerObservable - .subscribeOn(Schedulers.computation()) - .map(new Function() { - @Override - public Object apply(Integer integer) { - if (integer >= 5 && completed.compareAndSet(false, true)) { - s.onComplete(); - } - // do some work - Math.pow(Math.random(), Math.random()); - return integer * 2; - } - }); - } - }) - .toList() - .doOnNext(new Consumer>() { - @Override - public void accept(List integers) { - counter.incrementAndGet(); - latch.countDown(); - innerLatch.countDown(); - } - }) - .subscribe(); + .takeUntil(s) + .window(50) + .flatMap(integerObservable -> integerObservable + .subscribeOn(Schedulers.computation()) + .map(integer -> { + if (integer >= 5 && completed.compareAndSet(false, true)) { + s.onComplete(); + } + // do some work + Math.pow(Math.random(), Math.random()); + return integer * 2; + })) + .toList() + .doOnNext(integers -> { + counter.incrementAndGet(); + latch.countDown(); + innerLatch.countDown(); + }) + .subscribe(); if (!innerLatch.await(30, TimeUnit.SECONDS)) Assert.fail("Failed inner latch wait, iteration " + iters); } diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpCachedObservableTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpCachedObservableTest.java similarity index 81% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpCachedObservableTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpCachedObservableTest.java index b84f28bbb0..11548d0944 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpCachedObservableTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpCachedObservableTest.java @@ -38,7 +38,7 @@ public void testColdReplayNoBackpressure() { assertFalse("Source is connected!", source.isConnected()); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); source.subscribe(ts); @@ -63,15 +63,11 @@ public void testCache() throws InterruptedException { @Override public void accept(final NbpSubscriber NbpObserver) { NbpObserver.onSubscribe(EmptyDisposable.INSTANCE); - new Thread(new Runnable() { - - @Override - public void run() { - counter.incrementAndGet(); - System.out.println("published NbpObservable being executed"); - NbpObserver.onNext("one"); - NbpObserver.onComplete(); - } + new Thread(() -> { + counter.incrementAndGet(); + System.out.println("published NbpObservable being executed"); + NbpObserver.onNext("one"); + NbpObserver.onComplete(); }).start(); } }).cache(); @@ -80,23 +76,17 @@ public void run() { final CountDownLatch latch = new CountDownLatch(2); // subscribe once - o.subscribe(new Consumer() { - @Override - public void accept(String v) { - assertEquals("one", v); - System.out.println("v: " + v); - latch.countDown(); - } + o.subscribe(v -> { + assertEquals("one", v); + System.out.println("v: " + v); + latch.countDown(); }); // subscribe again - o.subscribe(new Consumer() { - @Override - public void accept(String v) { - assertEquals("one", v); - System.out.println("v: " + v); - latch.countDown(); - } + o.subscribe(v -> { + assertEquals("one", v); + System.out.println("v: " + v); + latch.countDown(); }); if (!latch.await(1000, TimeUnit.MILLISECONDS)) { @@ -117,7 +107,7 @@ public void testUnsubscribeSource() { @Test public void testTake() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpCachedObservable cached = NbpCachedObservable.from(NbpObservable.range(1, 100)); cached.take(10).subscribe(ts); @@ -133,7 +123,7 @@ public void testTake() { public void testAsync() { NbpObservable source = NbpObservable.range(1, 10000); for (int i = 0; i < 100; i++) { - NbpTestSubscriber ts1 = new NbpTestSubscriber(); + NbpTestSubscriber ts1 = new NbpTestSubscriber<>(); NbpCachedObservable cached = NbpCachedObservable.from(source); @@ -144,7 +134,7 @@ public void testAsync() { ts1.assertComplete(); assertEquals(10000, ts1.values().size()); - NbpTestSubscriber ts2 = new NbpTestSubscriber(); + NbpTestSubscriber ts2 = new NbpTestSubscriber<>(); cached.observeOn(Schedulers.computation()).subscribe(ts2); ts2.awaitTerminalEvent(2, TimeUnit.SECONDS); @@ -162,14 +152,14 @@ public void testAsyncComeAndGo() { NbpObservable output = cached.observeOn(Schedulers.computation()); - List> list = new ArrayList>(100); + List> list = new ArrayList<>(100); for (int i = 0; i < 100; i++) { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); list.add(ts); output.skip(i * 10).take(10).subscribe(ts); } - List expected = new ArrayList(); + List expected = new ArrayList<>(); for (int i = 0; i < 10; i++) { expected.add((long)(i - 10)); } @@ -203,7 +193,7 @@ public void accept(NbpSubscriber t) { } }); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); firehose.cache().observeOn(Schedulers.computation()).takeLast(100).subscribe(ts); ts.awaitTerminalEvent(3, TimeUnit.SECONDS); @@ -220,14 +210,14 @@ public void testValuesAndThenError() { .cache(); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); source.subscribe(ts); ts.assertValues(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); ts.assertNotComplete(); ts.assertError(TestException.class); - NbpTestSubscriber ts2 = new NbpTestSubscriber(); + NbpTestSubscriber ts2 = new NbpTestSubscriber<>(); source.subscribe(ts2); ts2.assertValues(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); @@ -240,12 +230,7 @@ public void unsafeChildThrows() { final AtomicInteger count = new AtomicInteger(); NbpObservable source = NbpObservable.range(1, 100) - .doOnNext(new Consumer() { - @Override - public void accept(Integer t) { - count.getAndIncrement(); - } - }) + .doOnNext(t -> count.getAndIncrement()) .cache(); NbpTestSubscriber ts = new NbpTestSubscriber() { diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeAmbTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeAmbTest.java similarity index 85% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeAmbTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeAmbTest.java index b4b7516993..c6d48528b0 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeAmbTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeAmbTest.java @@ -54,24 +54,16 @@ public void accept(final NbpSubscriber NbpSubscriber) { long delay = interval; for (final String value : values) { - parentSubscription.add(innerScheduler.schedule(new Runnable() { - @Override - public void run() { - NbpSubscriber.onNext(value); - } - } - , delay, TimeUnit.MILLISECONDS)); + parentSubscription.add(innerScheduler.schedule(() -> NbpSubscriber.onNext(value) + , delay, TimeUnit.MILLISECONDS)); delay += interval; } - parentSubscription.add(innerScheduler.schedule(new Runnable() { - @Override - public void run() { - if (e == null) { - NbpSubscriber.onComplete(); - } else { - NbpSubscriber.onError(e); - } - } + parentSubscription.add(innerScheduler.schedule(() -> { + if (e == null) { + NbpSubscriber.onComplete(); + } else { + NbpSubscriber.onError(e); + } }, delay, TimeUnit.MILLISECONDS)); } }); @@ -159,12 +151,7 @@ public void testAmb3() { @Test public void testSubscriptionOnlyHappensOnce() throws InterruptedException { final AtomicLong count = new AtomicLong(); - Consumer incrementer = new Consumer() { - @Override - public void accept(Disposable s) { - count.incrementAndGet(); - } - }; + Consumer incrementer = s -> count.incrementAndGet(); //this aync stream should emit first NbpObservable o1 = NbpObservable.just(1).doOnSubscribe(incrementer) @@ -172,7 +159,7 @@ public void accept(Disposable s) { //this stream emits second NbpObservable o2 = NbpObservable.just(1).doOnSubscribe(incrementer) .delay(100, TimeUnit.MILLISECONDS).subscribeOn(Schedulers.computation()); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpObservable.amb(o1, o2).subscribe(ts); ts.awaitTerminalEvent(5, TimeUnit.SECONDS); ts.assertNoErrors(); @@ -186,15 +173,12 @@ public void testSynchronousSources() { // then second NbpObservable does not get subscribed to before first // subscription completes hence first NbpObservable emits result through // amb - int result = NbpObservable.just(1).doOnNext(new Consumer() { - @Override - public void accept(Integer t) { - try { - Thread.sleep(100); - } catch (InterruptedException e) { - // - } - } + int result = NbpObservable.just(1).doOnNext(t -> { + try { + Thread.sleep(100); + } catch (InterruptedException e) { + // + } }).ambWith(NbpObservable.just(2)).toBlocking().single(); assertEquals(1, result); } @@ -206,7 +190,7 @@ public void testAmbCancelsOthers() { NbpPublishSubject source2 = NbpPublishSubject.create(); NbpPublishSubject source3 = NbpPublishSubject.create(); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpObservable.amb(source1, source2, source3).subscribe(ts); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeCombineLatestTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeCombineLatestTest.java similarity index 78% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeCombineLatestTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeCombineLatestTest.java index 4e6fd54f81..7c616723e0 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeCombineLatestTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeCombineLatestTest.java @@ -41,11 +41,8 @@ public void testCombineLatestWithFunctionThatThrowsAnException() { NbpPublishSubject w1 = NbpPublishSubject.create(); NbpPublishSubject w2 = NbpPublishSubject.create(); - NbpObservable combined = NbpObservable.combineLatest(w1, w2, new BiFunction() { - @Override - public String apply(String v1, String v2) { - throw new RuntimeException("I don't work."); - } + NbpObservable combined = NbpObservable.combineLatest(w1, w2, (v1, v2) -> { + throw new RuntimeException("I don't work."); }); combined.subscribe(w); @@ -217,41 +214,26 @@ public void testCombineLatest3TypesB() { } private Function3 getConcat3StringsCombineLatestFunction() { - Function3 combineLatestFunction = new Function3() { - @Override - public String apply(String a1, String a2, String a3) { - if (a1 == null) { - a1 = ""; - } - if (a2 == null) { - a2 = ""; - } - if (a3 == null) { - a3 = ""; - } - return a1 + a2 + a3; + return (a1, a2, a3) -> { + if (a1 == null) { + a1 = ""; } + if (a2 == null) { + a2 = ""; + } + if (a3 == null) { + a3 = ""; + } + return a1 + a2 + a3; }; - return combineLatestFunction; } private BiFunction getConcatStringIntegerCombineLatestFunction() { - BiFunction combineLatestFunction = new BiFunction() { - @Override - public String apply(String s, Integer i) { - return getStringValue(s) + getStringValue(i); - } - }; - return combineLatestFunction; + return (s, i) -> getStringValue(s) + getStringValue(i); } private Function3 getConcatStringIntegerIntArrayCombineLatestFunction() { - return new Function3() { - @Override - public String apply(String s, Integer i, int[] iArray) { - return getStringValue(s) + getStringValue(i) + getStringValue(iArray); - } - }; + return (s, i, iArray) -> getStringValue(s) + getStringValue(i) + getStringValue(iArray); } private static String getStringValue(Object o) { @@ -266,12 +248,7 @@ private static String getStringValue(Object o) { } } - BiFunction or = new BiFunction() { - @Override - public Integer apply(Integer t1, Integer t2) { - return t1 | t2; - } - }; + BiFunction or = (t1, t2) -> t1 | t2; @Test public void combineSimple() { @@ -426,17 +403,11 @@ public void test0Sources() { @Test public void test1ToNSources() { int n = 30; - Function> func = new Function>() { - - @Override - public List apply(Object[] args) { - return Arrays.asList(args); - } - }; + Function> func = Arrays::asList; for (int i = 1; i <= n; i++) { System.out.println("test1ToNSources: " + i + " sources"); - List> sources = new ArrayList>(); - List values = new ArrayList(); + List> sources = new ArrayList<>(); + List values = new ArrayList<>(); for (int j = 0; j < i; j++) { sources.add(NbpObservable.just(j)); values.add(j); @@ -457,17 +428,11 @@ public List apply(Object[] args) { @Test(timeout = 5000) public void test1ToNSourcesScheduled() throws InterruptedException { int n = 10; - Function> func = new Function>() { - - @Override - public List apply(Object[] args) { - return Arrays.asList(args); - } - }; + Function> func = Arrays::asList; for (int i = 1; i <= n; i++) { System.out.println("test1ToNSourcesScheduled: " + i + " sources"); - List> sources = new ArrayList>(); - List values = new ArrayList(); + List> sources = new ArrayList<>(); + List values = new ArrayList<>(); for (int j = 0; j < i; j++) { sources.add(NbpObservable.just(j).subscribeOn(Schedulers.io())); values.add(j); @@ -514,13 +479,7 @@ public void test2SourcesOverload() { NbpObservable s1 = NbpObservable.just(1); NbpObservable s2 = NbpObservable.just(2); - NbpObservable> result = NbpObservable.combineLatest(s1, s2, - new BiFunction>() { - @Override - public List apply(Integer t1, Integer t2) { - return Arrays.asList(t1, t2); - } - }); + NbpObservable> result = NbpObservable.combineLatest(s1, s2, (t1, t2) -> Arrays.asList(t1, t2)); NbpSubscriber o = TestHelper.mockNbpSubscriber(); @@ -537,13 +496,7 @@ public void test3SourcesOverload() { NbpObservable s2 = NbpObservable.just(2); NbpObservable s3 = NbpObservable.just(3); - NbpObservable> result = NbpObservable.combineLatest(s1, s2, s3, - new Function3>() { - @Override - public List apply(Integer t1, Integer t2, Integer t3) { - return Arrays.asList(t1, t2, t3); - } - }); + NbpObservable> result = NbpObservable.combineLatest(s1, s2, s3, Arrays::asList); NbpSubscriber o = TestHelper.mockNbpSubscriber(); @@ -561,13 +514,7 @@ public void test4SourcesOverload() { NbpObservable s3 = NbpObservable.just(3); NbpObservable s4 = NbpObservable.just(4); - NbpObservable> result = NbpObservable.combineLatest(s1, s2, s3, s4, - new Function4>() { - @Override - public List apply(Integer t1, Integer t2, Integer t3, Integer t4) { - return Arrays.asList(t1, t2, t3, t4); - } - }); + NbpObservable> result = NbpObservable.combineLatest(s1, s2, s3, s4, Arrays::asList); NbpSubscriber o = TestHelper.mockNbpSubscriber(); @@ -586,13 +533,7 @@ public void test5SourcesOverload() { NbpObservable s4 = NbpObservable.just(4); NbpObservable s5 = NbpObservable.just(5); - NbpObservable> result = NbpObservable.combineLatest(s1, s2, s3, s4, s5, - new Function5>() { - @Override - public List apply(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5) { - return Arrays.asList(t1, t2, t3, t4, t5); - } - }); + NbpObservable> result = NbpObservable.combineLatest(s1, s2, s3, s4, s5, Arrays::asList); NbpSubscriber o = TestHelper.mockNbpSubscriber(); @@ -612,13 +553,7 @@ public void test6SourcesOverload() { NbpObservable s5 = NbpObservable.just(5); NbpObservable s6 = NbpObservable.just(6); - NbpObservable> result = NbpObservable.combineLatest(s1, s2, s3, s4, s5, s6, - new Function6>() { - @Override - public List apply(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5, Integer t6) { - return Arrays.asList(t1, t2, t3, t4, t5, t6); - } - }); + NbpObservable> result = NbpObservable.combineLatest(s1, s2, s3, s4, s5, s6, Arrays::asList); NbpSubscriber o = TestHelper.mockNbpSubscriber(); @@ -639,13 +574,7 @@ public void test7SourcesOverload() { NbpObservable s6 = NbpObservable.just(6); NbpObservable s7 = NbpObservable.just(7); - NbpObservable> result = NbpObservable.combineLatest(s1, s2, s3, s4, s5, s6, s7, - new Function7>() { - @Override - public List apply(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5, Integer t6, Integer t7) { - return Arrays.asList(t1, t2, t3, t4, t5, t6, t7); - } - }); + NbpObservable> result = NbpObservable.combineLatest(s1, s2, s3, s4, s5, s6, s7, Arrays::asList); NbpSubscriber o = TestHelper.mockNbpSubscriber(); @@ -667,13 +596,7 @@ public void test8SourcesOverload() { NbpObservable s7 = NbpObservable.just(7); NbpObservable s8 = NbpObservable.just(8); - NbpObservable> result = NbpObservable.combineLatest(s1, s2, s3, s4, s5, s6, s7, s8, - new Function8>() { - @Override - public List apply(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5, Integer t6, Integer t7, Integer t8) { - return Arrays.asList(t1, t2, t3, t4, t5, t6, t7, t8); - } - }); + NbpObservable> result = NbpObservable.combineLatest(s1, s2, s3, s4, s5, s6, s7, s8, Arrays::asList); NbpSubscriber o = TestHelper.mockNbpSubscriber(); @@ -696,13 +619,7 @@ public void test9SourcesOverload() { NbpObservable s8 = NbpObservable.just(8); NbpObservable s9 = NbpObservable.just(9); - NbpObservable> result = NbpObservable.combineLatest(s1, s2, s3, s4, s5, s6, s7, s8, s9, - new Function9>() { - @Override - public List apply(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5, Integer t6, Integer t7, Integer t8, Integer t9) { - return Arrays.asList(t1, t2, t3, t4, t5, t6, t7, t8, t9); - } - }); + NbpObservable> result = NbpObservable.combineLatest(s1, s2, s3, s4, s5, s6, s7, s8, s9, Arrays::asList); NbpSubscriber o = TestHelper.mockNbpSubscriber(); @@ -715,15 +632,7 @@ public List apply(Integer t1, Integer t2, Integer t3, Integer t4, Integ @Test public void testZeroSources() { - NbpObservable result = NbpObservable.combineLatest( - Collections.> emptyList(), new Function() { - - @Override - public Object apply(Object[] args) { - return args; - } - - }); + NbpObservable result = NbpObservable.combineLatest(Collections.emptyList(), args -> args); NbpSubscriber o = TestHelper.mockNbpSubscriber(); @@ -742,24 +651,16 @@ public void testWithCombineLatestIssue1717() throws InterruptedException { final int SIZE = 2000; NbpObservable timer = NbpObservable.interval(0, 1, TimeUnit.MILLISECONDS) .observeOn(Schedulers.newThread()) - .doOnEach(new Consumer>>() { - @Override - public void accept(Try> n) { - // System.out.println(n); - if (count.incrementAndGet() >= SIZE) { - latch.countDown(); - } + .doOnEach(n -> { + //System.out.println(n); + if (count.incrementAndGet() >= SIZE) { + latch.countDown(); } }).take(SIZE); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); - NbpObservable.combineLatest(timer, NbpObservable. never(), new BiFunction() { - @Override - public Long apply(Long t1, Integer t2) { - return t1; - } - }).subscribe(ts); + NbpObservable.combineLatest(timer, NbpObservable.never(), (t1, t2) -> t1).subscribe(ts); if (!latch.await(SIZE + 1000, TimeUnit.MILLISECONDS)) { fail("timed out"); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeDeferTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeDeferTest.java similarity index 100% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeDeferTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeDeferTest.java diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeDelaySubscriptionOtherTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeDelaySubscriptionOtherTest.java similarity index 78% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeDelaySubscriptionOtherTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeDelaySubscriptionOtherTest.java index 7e633495f5..4088fe7ddd 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeDelaySubscriptionOtherTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeDelaySubscriptionOtherTest.java @@ -29,17 +29,12 @@ public class NbpOnSubscribeDelaySubscriptionOtherTest { public void testNoPrematureSubscription() { NbpPublishSubject other = NbpPublishSubject.create(); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); final AtomicInteger subscribed = new AtomicInteger(); NbpObservable.just(1) - .doOnSubscribe(new Consumer() { - @Override - public void accept(Disposable d) { - subscribed.getAndIncrement(); - } - }) + .doOnSubscribe(d -> subscribed.getAndIncrement()) .delaySubscription(other) .subscribe(ts); @@ -62,17 +57,12 @@ public void accept(Disposable d) { public void testNoMultipleSubscriptions() { NbpPublishSubject other = NbpPublishSubject.create(); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); final AtomicInteger subscribed = new AtomicInteger(); NbpObservable.just(1) - .doOnSubscribe(new Consumer() { - @Override - public void accept(Disposable d) { - subscribed.getAndIncrement(); - } - }) + .doOnSubscribe(d -> subscribed.getAndIncrement()) .delaySubscription(other) .subscribe(ts); @@ -96,17 +86,12 @@ public void accept(Disposable d) { public void testCompleteTriggersSubscription() { NbpPublishSubject other = NbpPublishSubject.create(); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); final AtomicInteger subscribed = new AtomicInteger(); NbpObservable.just(1) - .doOnSubscribe(new Consumer() { - @Override - public void accept(Disposable d) { - subscribed.getAndIncrement(); - } - }) + .doOnSubscribe(d -> subscribed.getAndIncrement()) .delaySubscription(other) .subscribe(ts); @@ -129,17 +114,12 @@ public void accept(Disposable d) { public void testNoPrematureSubscriptionToError() { NbpPublishSubject other = NbpPublishSubject.create(); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); final AtomicInteger subscribed = new AtomicInteger(); NbpObservable.error(new TestException()) - .doOnSubscribe(new Consumer() { - @Override - public void accept(Disposable d) { - subscribed.getAndIncrement(); - } - }) + .doOnSubscribe(d -> subscribed.getAndIncrement()) .delaySubscription(other) .subscribe(ts); @@ -162,17 +142,12 @@ public void accept(Disposable d) { public void testNoSubscriptionIfOtherErrors() { NbpPublishSubject other = NbpPublishSubject.create(); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); final AtomicInteger subscribed = new AtomicInteger(); NbpObservable.error(new TestException()) - .doOnSubscribe(new Consumer() { - @Override - public void accept(Disposable d) { - subscribed.getAndIncrement(); - } - }) + .doOnSubscribe(d -> subscribed.getAndIncrement()) .delaySubscription(other) .subscribe(ts); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeFromIterableTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeFromIterableTest.java similarity index 67% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeFromIterableTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeFromIterableTest.java index 6c5b9fcbaf..7f71986cbc 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeFromIterableTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeFromIterableTest.java @@ -54,29 +54,21 @@ public void testListIterable() { */ @Test public void testRawIterable() { - Iterable it = new Iterable() { + Iterable it = () -> new Iterator() { + int i = 0; @Override - public Iterator iterator() { - return new Iterator() { - - int i = 0; - - @Override - public boolean hasNext() { - return i < 3; - } - - @Override - public String next() { - return String.valueOf(++i); - } + public boolean hasNext() { + return i < 3; + } - @Override - public void remove() { - } + @Override + public String next() { + return String.valueOf(++i); + } - }; + @Override + public void remove() { } }; @@ -112,7 +104,7 @@ public void testObservableFromIterable() { public void testNoBackpressure() { NbpObservable o = NbpObservable.fromIterable(Arrays.asList(1, 2, 3, 4, 5)); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); o.subscribe(ts); @@ -125,7 +117,7 @@ public void testSubscribeMultipleTimes() { NbpObservable o = NbpObservable.fromIterable(Arrays.asList(1, 2, 3)); for (int i = 0; i < 10; i++) { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); o.subscribe(ts); @@ -138,35 +130,28 @@ public void testSubscribeMultipleTimes() { @Test public void testDoesNotCallIteratorHasNextMoreThanRequiredWithBackpressure() { final AtomicBoolean called = new AtomicBoolean(false); - Iterable iterable = new Iterable() { + Iterable iterable = () -> new Iterator() { + int count = 1; @Override - public Iterator iterator() { - return new Iterator() { - - int count = 1; - - @Override - public void remove() { - // ignore - } - - @Override - public boolean hasNext() { - if (count > 1) { - called.set(true); - return false; - } else - return true; - } - - @Override - public Integer next() { - return count++; - } - - }; + public void remove() { + // ignore } + + @Override + public boolean hasNext() { + if (count > 1) { + called.set(true); + return false; + } else + return true; + } + + @Override + public Integer next() { + return count++; + } + }; NbpObservable.fromIterable(iterable).take(1).subscribe(); assertFalse(called.get()); @@ -175,35 +160,28 @@ public Integer next() { @Test public void testDoesNotCallIteratorHasNextMoreThanRequiredFastPath() { final AtomicBoolean called = new AtomicBoolean(false); - Iterable iterable = new Iterable() { + Iterable iterable = () -> new Iterator() { + @Override + public void remove() { + // ignore + } + + int count = 1; @Override - public Iterator iterator() { - return new Iterator() { - - @Override - public void remove() { - // ignore - } - - int count = 1; - - @Override - public boolean hasNext() { - if (count > 1) { - called.set(true); - return false; - } else - return true; - } - - @Override - public Integer next() { - return count++; - } - - }; + public boolean hasNext() { + if (count > 1) { + called.set(true); + return false; + } else + return true; } + + @Override + public Integer next() { + return count++; + } + }; NbpObservable.fromIterable(iterable).subscribe(new NbpObserver() { diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRangeTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRangeTest.java similarity index 90% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRangeTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRangeTest.java index 4b4f5ed449..d2b6a27250 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRangeTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRangeTest.java @@ -48,12 +48,7 @@ public void testRangeUnsubscribe() { final AtomicInteger count = new AtomicInteger(); - NbpObservable.range(1, 1000).doOnNext(new Consumer() { - @Override - public void accept(Integer t1) { - count.incrementAndGet(); - } - }) + NbpObservable.range(1, 1000).doOnNext(t1 -> count.incrementAndGet()) .take(3).subscribe(NbpObserver); verify(NbpObserver, times(1)).onNext(1); @@ -92,14 +87,14 @@ public void testRangeWithOverflow5() { @Test public void testNoBackpressure() { - ArrayList list = new ArrayList(Observable.bufferSize() * 2); + ArrayList list = new ArrayList<>(Observable.bufferSize() * 2); for (int i = 1; i <= Observable.bufferSize() * 2 + 1; i++) { list.add(i); } NbpObservable o = NbpObservable.range(1, list.size()); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); o.subscribe(ts); @@ -136,7 +131,7 @@ public void onNext(Integer t) { @Test(timeout = 1000) public void testNearMaxValueWithoutBackpressure() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpObservable.range(Integer.MAX_VALUE - 1, 2).subscribe(ts); ts.assertComplete(); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRefCountTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRefCountTest.java similarity index 62% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRefCountTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRefCountTest.java index d0c57576ec..de991434ef 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRefCountTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeRefCountTest.java @@ -40,26 +40,13 @@ public void testRefCountAsync() { final AtomicInteger subscribeCount = new AtomicInteger(); final AtomicInteger nextCount = new AtomicInteger(); NbpObservable r = NbpObservable.interval(0, 5, TimeUnit.MILLISECONDS) - .doOnSubscribe(new Consumer() { - @Override - public void accept(Disposable s) { - subscribeCount.incrementAndGet(); - } - }) - .doOnNext(new Consumer() { - @Override - public void accept(Long l) { - nextCount.incrementAndGet(); - } - }) + .doOnSubscribe(s -> subscribeCount.incrementAndGet()) + .doOnNext(l -> nextCount.incrementAndGet()) .publish().refCount(); final AtomicInteger receivedCount = new AtomicInteger(); - Disposable s1 = r.subscribe(new Consumer() { - @Override - public void accept(Long l) { - receivedCount.incrementAndGet(); - } + Disposable s1 = r.subscribe(l -> { + receivedCount.incrementAndGet(); }); Disposable s2 = r.subscribe(); @@ -87,26 +74,13 @@ public void testRefCountSynchronous() { final AtomicInteger subscribeCount = new AtomicInteger(); final AtomicInteger nextCount = new AtomicInteger(); NbpObservable r = NbpObservable.just(1, 2, 3, 4, 5, 6, 7, 8, 9) - .doOnSubscribe(new Consumer() { - @Override - public void accept(Disposable s) { - subscribeCount.incrementAndGet(); - } - }) - .doOnNext(new Consumer() { - @Override - public void accept(Integer l) { - nextCount.incrementAndGet(); - } - }) + .doOnSubscribe(s -> subscribeCount.incrementAndGet()) + .doOnNext(l -> nextCount.incrementAndGet()) .publish().refCount(); final AtomicInteger receivedCount = new AtomicInteger(); - Disposable s1 = r.subscribe(new Consumer() { - @Override - public void accept(Integer l) { - receivedCount.incrementAndGet(); - } + Disposable s1 = r.subscribe(l -> { + receivedCount.incrementAndGet(); }); Disposable s2 = r.subscribe(); @@ -133,22 +107,16 @@ public void accept(Integer l) { public void testRefCountSynchronousTake() { final AtomicInteger nextCount = new AtomicInteger(); NbpObservable r = NbpObservable.just(1, 2, 3, 4, 5, 6, 7, 8, 9) - .doOnNext(new Consumer() { - @Override - public void accept(Integer l) { - System.out.println("onNext --------> " + l); - nextCount.incrementAndGet(); - } + .doOnNext(l -> { + System.out.println("onNext --------> " + l); + nextCount.incrementAndGet(); }) .take(4) .publish().refCount(); final AtomicInteger receivedCount = new AtomicInteger(); - r.subscribe(new Consumer() { - @Override - public void accept(Integer l) { - receivedCount.incrementAndGet(); - } + r.subscribe(l -> { + receivedCount.incrementAndGet(); }); System.out.println("onNext: " + nextCount.get()); @@ -162,27 +130,21 @@ public void testRepeat() { final AtomicInteger subscribeCount = new AtomicInteger(); final AtomicInteger unsubscribeCount = new AtomicInteger(); NbpObservable r = NbpObservable.interval(0, 1, TimeUnit.MILLISECONDS) - .doOnSubscribe(new Consumer() { - @Override - public void accept(Disposable s) { - System.out.println("******************************* Subscribe received"); - // when we are subscribed - subscribeCount.incrementAndGet(); - } + .doOnSubscribe(s -> { + System.out.println("******************************* Subscribe received"); + // when we are subscribed + subscribeCount.incrementAndGet(); }) - .doOnCancel(new Runnable() { - @Override - public void run() { - System.out.println("******************************* Unsubscribe received"); - // when we are unsubscribed - unsubscribeCount.incrementAndGet(); - } + .doOnCancel(() -> { + System.out.println("******************************* Unsubscribe received"); + // when we are unsubscribed + unsubscribeCount.incrementAndGet(); }) .publish().refCount(); for (int i = 0; i < 10; i++) { - NbpTestSubscriber ts1 = new NbpTestSubscriber(); - NbpTestSubscriber ts2 = new NbpTestSubscriber(); + NbpTestSubscriber ts1 = new NbpTestSubscriber<>(); + NbpTestSubscriber ts2 = new NbpTestSubscriber<>(); r.subscribe(ts1); r.subscribe(ts2); try { @@ -207,24 +169,18 @@ public void testConnectUnsubscribe() throws InterruptedException { final CountDownLatch subscribeLatch = new CountDownLatch(1); NbpObservable o = synchronousInterval() - .doOnSubscribe(new Consumer() { - @Override - public void accept(Disposable s) { - System.out.println("******************************* Subscribe received"); - // when we are subscribed - subscribeLatch.countDown(); - } + .doOnSubscribe(s -> { + System.out.println("******************************* Subscribe received"); + // when we are subscribed + subscribeLatch.countDown(); }) - .doOnCancel(new Runnable() { - @Override - public void run() { - System.out.println("******************************* Unsubscribe received"); - // when we are unsubscribed - unsubscribeLatch.countDown(); - } + .doOnCancel(() -> { + System.out.println("******************************* Unsubscribe received"); + // when we are unsubscribed + unsubscribeLatch.countDown(); }); - NbpTestSubscriber s = new NbpTestSubscriber(); + NbpTestSubscriber s = new NbpTestSubscriber<>(); o.publish().refCount().subscribeOn(Schedulers.newThread()).subscribe(s); System.out.println("send unsubscribe"); // wait until connected @@ -253,23 +209,17 @@ public void testConnectUnsubscribeRaceConditionLoop() throws InterruptedExceptio public void testConnectUnsubscribeRaceCondition() throws InterruptedException { final AtomicInteger subUnsubCount = new AtomicInteger(); NbpObservable o = synchronousInterval() - .doOnCancel(new Runnable() { - @Override - public void run() { - System.out.println("******************************* Unsubscribe received"); - // when we are unsubscribed - subUnsubCount.decrementAndGet(); - } + .doOnCancel(() -> { + System.out.println("******************************* Unsubscribe received"); + // when we are unsubscribed + subUnsubCount.decrementAndGet(); }) - .doOnSubscribe(new Consumer() { - @Override - public void accept(Disposable s) { - System.out.println("******************************* SUBSCRIBE received"); - subUnsubCount.incrementAndGet(); - } + .doOnSubscribe(s -> { + System.out.println("******************************* SUBSCRIBE received"); + subUnsubCount.incrementAndGet(); }); - NbpTestSubscriber s = new NbpTestSubscriber(); + NbpTestSubscriber s = new NbpTestSubscriber<>(); o.publish().refCount().subscribeOn(Schedulers.computation()).subscribe(s); System.out.println("send unsubscribe"); @@ -294,12 +244,7 @@ private NbpObservable synchronousInterval() { @Override public void accept(NbpSubscriber NbpSubscriber) { final AtomicBoolean cancel = new AtomicBoolean(); - NbpSubscriber.onSubscribe(new Disposable() { - @Override - public void dispose() { - cancel.set(true); - } - }); + NbpSubscriber.onSubscribe(() -> cancel.set(true)); for (;;) { if (cancel.get()) { break; @@ -322,12 +267,7 @@ public void onlyFirstShouldSubscribeAndLastUnsubscribe() { @Override public void accept(NbpSubscriber NbpObserver) { subscriptionCount.incrementAndGet(); - NbpObserver.onSubscribe(new Disposable() { - @Override - public void dispose() { - unsubscriptionCount.incrementAndGet(); - } - }); + NbpObserver.onSubscribe(unsubscriptionCount::incrementAndGet); } }); NbpObservable refCounted = o.publish().refCount(); @@ -351,12 +291,9 @@ public void testRefCount() { NbpObservable interval = NbpObservable.interval(100, TimeUnit.MILLISECONDS, s).publish().refCount(); // subscribe list1 - final List list1 = new ArrayList(); - Disposable s1 = interval.subscribe(new Consumer() { - @Override - public void accept(Long t1) { - list1.add(t1); - } + final List list1 = new ArrayList<>(); + Disposable s1 = interval.subscribe(t1 -> { + list1.add(t1); }); s.advanceTimeBy(200, TimeUnit.MILLISECONDS); @@ -366,12 +303,9 @@ public void accept(Long t1) { assertEquals(1L, list1.get(1).longValue()); // subscribe list2 - final List list2 = new ArrayList(); - Disposable s2 = interval.subscribe(new Consumer() { - @Override - public void accept(Long t1) { - list2.add(t1); - } + final List list2 = new ArrayList<>(); + Disposable s2 = interval.subscribe(t1 -> { + list2.add(t1); }); s.advanceTimeBy(300, TimeUnit.MILLISECONDS); @@ -411,12 +345,9 @@ public void accept(Long t1) { // subscribing a new one should start over because the source should have been unsubscribed // subscribe list3 - final List list3 = new ArrayList(); - interval.subscribe(new Consumer() { - @Override - public void accept(Long t1) { - list3.add(t1); - } + final List list3 = new ArrayList<>(); + interval.subscribe(t1 -> { + list3.add(t1); }); s.advanceTimeBy(200, TimeUnit.MILLISECONDS); @@ -474,16 +405,10 @@ public void testAlreadyUnsubscribedInterleavesWithClient() { public void testConnectDisconnectConnectAndSubjectState() { NbpObservable o1 = NbpObservable.just(10); NbpObservable o2 = NbpObservable.just(20); - NbpObservable combined = NbpObservable.combineLatest(o1, o2, new BiFunction() { - @Override - public Integer apply(Integer t1, Integer t2) { - return t1 + t2; - } - }) - .publish().refCount(); + NbpObservable combined = NbpObservable.combineLatest(o1, o2, (t1, t2) -> t1 + t2).publish().refCount(); - NbpTestSubscriber ts1 = new NbpTestSubscriber(); - NbpTestSubscriber ts2 = new NbpTestSubscriber(); + NbpTestSubscriber ts1 = new NbpTestSubscriber<>(); + NbpTestSubscriber ts2 = new NbpTestSubscriber<>(); combined.subscribe(ts1); combined.subscribe(ts2); @@ -502,61 +427,25 @@ public void testUpstreamErrorAllowsRetry() throws InterruptedException { final AtomicInteger intervalSubscribed = new AtomicInteger(); NbpObservable interval = NbpObservable.interval(200,TimeUnit.MILLISECONDS) - .doOnSubscribe(new Consumer() { - @Override - public void accept(Disposable s) { - System.out.println("Subscribing to interval " + intervalSubscribed.incrementAndGet()); - } - } - ) - .flatMap(new Function>() { - @Override - public NbpObservable apply(Long t1) { - return NbpObservable.defer(new Supplier>() { - @Override - public NbpObservable get() { - return NbpObservable.error(new Exception("Some exception")); - } - }); - } - }) - .onErrorResumeNext(new Function>() { - @Override - public NbpObservable apply(Throwable t1) { - return NbpObservable.error(t1); - } - }) + .doOnSubscribe(s -> System.out.println("Subscribing to interval " + intervalSubscribed.incrementAndGet()) + ) + .flatMap(t1 -> NbpObservable.defer(() -> NbpObservable.error(new Exception("Some exception")))) + .onErrorResumeNext(NbpObservable::error) .publish() .refCount(); interval - .doOnError(new Consumer() { - @Override - public void accept(Throwable t1) { - System.out.println("NbpSubscriber 1 onError: " + t1); - } - }) + .doOnError(t1 -> System.out.println("NbpSubscriber 1 onError: " + t1)) .retry(5) - .subscribe(new Consumer() { - @Override - public void accept(String t1) { - System.out.println("NbpSubscriber 1: " + t1); - } + .subscribe(t1 -> { + System.out.println("NbpSubscriber 1: " + t1); }); Thread.sleep(100); interval - .doOnError(new Consumer() { - @Override - public void accept(Throwable t1) { - System.out.println("NbpSubscriber 2 onError: " + t1); - } - }) + .doOnError(t1 -> System.out.println("NbpSubscriber 2 onError: " + t1)) .retry(5) - .subscribe(new Consumer() { - @Override - public void accept(String t1) { - System.out.println("NbpSubscriber 2: " + t1); - } + .subscribe(t1 -> { + System.out.println("NbpSubscriber 2: " + t1); }); Thread.sleep(1300); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeTimerTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeTimerTest.java similarity index 93% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeTimerTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeTimerTest.java index 3dd4b1761f..8fe9f9af75 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeTimerTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeTimerTest.java @@ -57,7 +57,7 @@ public void testTimerOnce() { @Test public void testTimerPeriodically() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpObservable.interval(100, 100, TimeUnit.MILLISECONDS, scheduler).subscribe(ts); @@ -84,7 +84,7 @@ public void testTimerPeriodically() { @Test public void testInterval() { NbpObservable w = NbpObservable.interval(1, TimeUnit.SECONDS, scheduler); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); w.subscribe(ts); ts.assertNoValues(); @@ -109,8 +109,8 @@ public void testInterval() { public void testWithMultipleSubscribersStartingAtSameTime() { NbpObservable w = NbpObservable.interval(1, TimeUnit.SECONDS, scheduler); - NbpTestSubscriber ts1 = new NbpTestSubscriber(); - NbpTestSubscriber ts2 = new NbpTestSubscriber(); + NbpTestSubscriber ts1 = new NbpTestSubscriber<>(); + NbpTestSubscriber ts2 = new NbpTestSubscriber<>(); w.subscribe(ts1); w.subscribe(ts2); @@ -146,7 +146,7 @@ public void testWithMultipleSubscribersStartingAtSameTime() { public void testWithMultipleStaggeredSubscribers() { NbpObservable w = NbpObservable.interval(1, TimeUnit.SECONDS, scheduler); - NbpTestSubscriber ts1 = new NbpTestSubscriber(); + NbpTestSubscriber ts1 = new NbpTestSubscriber<>(); w.subscribe(ts1); @@ -154,7 +154,7 @@ public void testWithMultipleStaggeredSubscribers() { scheduler.advanceTimeTo(2, TimeUnit.SECONDS); - NbpTestSubscriber ts2 = new NbpTestSubscriber(); + NbpTestSubscriber ts2 = new NbpTestSubscriber<>(); w.subscribe(ts2); @@ -186,7 +186,7 @@ public void testWithMultipleStaggeredSubscribers() { public void testWithMultipleStaggeredSubscribersAndPublish() { NbpConnectableObservable w = NbpObservable.interval(1, TimeUnit.SECONDS, scheduler).publish(); - NbpTestSubscriber ts1 = new NbpTestSubscriber(); + NbpTestSubscriber ts1 = new NbpTestSubscriber<>(); w.subscribe(ts1); w.connect(); @@ -195,7 +195,7 @@ public void testWithMultipleStaggeredSubscribersAndPublish() { scheduler.advanceTimeTo(2, TimeUnit.SECONDS); - NbpTestSubscriber ts2 = new NbpTestSubscriber(); + NbpTestSubscriber ts2 = new NbpTestSubscriber<>(); w.subscribe(ts2); ts1.assertValues(0L, 1L); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeToObservableFutureTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeToObservableFutureTest.java similarity index 93% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeToObservableFutureTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeToObservableFutureTest.java index c67b253b48..d043bf1220 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeToObservableFutureTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeToObservableFutureTest.java @@ -37,7 +37,7 @@ public void testSuccess() throws Exception { NbpSubscriber o = TestHelper.mockNbpSubscriber(); - NbpTestSubscriber ts = new NbpTestSubscriber(o); + NbpTestSubscriber ts = new NbpTestSubscriber<>(o); NbpObservable.fromFuture(future).subscribe(ts); @@ -58,7 +58,7 @@ public void testFailure() throws Exception { NbpSubscriber o = TestHelper.mockNbpSubscriber(); - NbpTestSubscriber ts = new NbpTestSubscriber(o); + NbpTestSubscriber ts = new NbpTestSubscriber<>(o); NbpObservable.fromFuture(future).subscribe(ts); @@ -79,7 +79,7 @@ public void testCancelledBeforeSubscribe() throws Exception { NbpSubscriber o = TestHelper.mockNbpSubscriber(); - NbpTestSubscriber ts = new NbpTestSubscriber(o); + NbpTestSubscriber ts = new NbpTestSubscriber<>(o); ts.dispose(); NbpObservable.fromFuture(future).subscribe(ts); @@ -125,7 +125,7 @@ public Object get(long timeout, TimeUnit unit) throws InterruptedException, Exec NbpSubscriber o = TestHelper.mockNbpSubscriber(); - NbpTestSubscriber ts = new NbpTestSubscriber(o); + NbpTestSubscriber ts = new NbpTestSubscriber<>(o); NbpObservable futureObservable = NbpObservable.fromFuture(future); futureObservable.subscribeOn(Schedulers.computation()).subscribe(ts); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeUsingTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeUsingTest.java similarity index 66% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeUsingTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeUsingTest.java index a223107dac..631c8704fb 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeUsingTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOnSubscribeUsingTest.java @@ -44,14 +44,7 @@ public void accept(Resource r) { } - private final Consumer disposeSubscription = new Consumer() { - - @Override - public void accept(Disposable s) { - s.dispose(); - } - - }; + private final Consumer disposeSubscription = Disposable::dispose; @Test public void testUsing() { @@ -67,19 +60,9 @@ private void performTestUsing(boolean disposeEagerly) { final Resource resource = mock(Resource.class); when(resource.getTextFromWeb()).thenReturn("Hello world!"); - Supplier resourceFactory = new Supplier() { - @Override - public Resource get() { - return resource; - } - }; + Supplier resourceFactory = () -> resource; - Function> observableFactory = new Function>() { - @Override - public NbpObservable apply(Resource res) { - return NbpObservable.fromArray(res.getTextFromWeb().split(" ")); - } - }; + Function> observableFactory = res -> NbpObservable.fromArray(res.getTextFromWeb().split(" ")); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); @@ -109,38 +92,28 @@ public void testUsingWithSubscribingTwiceDisposeEagerly() { private void performTestUsingWithSubscribingTwice(boolean disposeEagerly) { // When subscribe is called, a new resource should be created. - Supplier resourceFactory = new Supplier() { + Supplier resourceFactory = () -> new Resource() { + + boolean first = true; + @Override - public Resource get() { - return new Resource() { - - boolean first = true; - - @Override - public String getTextFromWeb() { - if (first) { - first = false; - return "Hello world!"; - } - return "Nothing"; - } - - @Override - public void dispose() { - // do nothing - } - - }; + public String getTextFromWeb() { + if (first) { + first = false; + return "Hello world!"; + } + return "Nothing"; } - }; - Function> observableFactory = new Function>() { @Override - public NbpObservable apply(Resource res) { - return NbpObservable.fromArray(res.getTextFromWeb().split(" ")); + public void dispose() { + // do nothing } + }; + Function> observableFactory = res -> NbpObservable.fromArray(res.getTextFromWeb().split(" ")); + NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); NbpObservable o = NbpObservable.using(resourceFactory, observableFactory, @@ -171,19 +144,11 @@ public void testUsingWithResourceFactoryErrorDisposeEagerly() { } private void performTestUsingWithResourceFactoryError(boolean disposeEagerly) { - Supplier resourceFactory = new Supplier() { - @Override - public Disposable get() { - throw new TestException(); - } + Supplier resourceFactory = () -> { + throw new TestException(); }; - Function> observableFactory = new Function>() { - @Override - public NbpObservable apply(Disposable s) { - return NbpObservable.empty(); - } - }; + Function> observableFactory = s -> NbpObservable.empty(); NbpObservable.using(resourceFactory, observableFactory, disposeSubscription) .toBlocking() @@ -202,18 +167,10 @@ public void testUsingWithObservableFactoryErrorDisposeEagerly() { private void performTestUsingWithObservableFactoryError(boolean disposeEagerly) { final Runnable unsubscribe = mock(Runnable.class); - Supplier resourceFactory = new Supplier() { - @Override - public Disposable get() { - return Disposables.from(unsubscribe); - } - }; + Supplier resourceFactory = () -> Disposables.from(unsubscribe); - Function> observableFactory = new Function>() { - @Override - public NbpObservable apply(Disposable subscription) { - throw new TestException(); - } + Function> observableFactory = subscription -> { + throw new TestException(); }; try { @@ -241,24 +198,11 @@ public void testUsingWithObservableFactoryErrorInOnSubscribeDisposeEagerly() { private void performTestUsingWithObservableFactoryErrorInOnSubscribe(boolean disposeEagerly) { final Runnable unsubscribe = mock(Runnable.class); - Supplier resourceFactory = new Supplier() { - @Override - public Disposable get() { - return Disposables.from(unsubscribe); - } - }; + Supplier resourceFactory = () -> Disposables.from(unsubscribe); - Function> observableFactory = new Function>() { - @Override - public NbpObservable apply(Disposable subscription) { - return NbpObservable.create(new NbpOnSubscribe() { - @Override - public void accept(NbpSubscriber t1) { - throw new TestException(); - } - }); - } - }; + Function> observableFactory = subscription -> NbpObservable.create(t1 -> { + throw new TestException(); + }); try { NbpObservable @@ -275,17 +219,13 @@ public void accept(NbpSubscriber t1) { @Test public void testUsingDisposesEagerlyBeforeCompletion() { - final List events = new ArrayList(); + final List events = new ArrayList<>(); Supplier resourceFactory = createResourceFactory(events); final Runnable completion = createOnCompletedAction(events); final Runnable unsub =createUnsubAction(events); - Function> observableFactory = new Function>() { - @Override - public NbpObservable apply(Resource resource) { - return NbpObservable.fromArray(resource.getTextFromWeb().split(" ")); - } - }; + Function> observableFactory = resource -> + NbpObservable.fromArray(resource.getTextFromWeb().split(" ")); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); @@ -302,17 +242,13 @@ public NbpObservable apply(Resource resource) { @Test public void testUsingDoesNotDisposesEagerlyBeforeCompletion() { - final List events = new ArrayList(); + final List events = new ArrayList<>(); Supplier resourceFactory = createResourceFactory(events); final Runnable completion = createOnCompletedAction(events); final Runnable unsub = createUnsubAction(events); - Function> observableFactory = new Function>() { - @Override - public NbpObservable apply(Resource resource) { - return NbpObservable.fromArray(resource.getTextFromWeb().split(" ")); - } - }; + Function> observableFactory = resource -> + NbpObservable.fromArray(resource.getTextFromWeb().split(" ")); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); @@ -331,18 +267,14 @@ public NbpObservable apply(Resource resource) { @Test public void testUsingDisposesEagerlyBeforeError() { - final List events = new ArrayList(); + final List events = new ArrayList<>(); Supplier resourceFactory = createResourceFactory(events); final Consumer onError = createOnErrorAction(events); final Runnable unsub = createUnsubAction(events); - Function> observableFactory = new Function>() { - @Override - public NbpObservable apply(Resource resource) { - return NbpObservable.fromArray(resource.getTextFromWeb().split(" ")) + Function> observableFactory = resource -> + NbpObservable.fromArray(resource.getTextFromWeb().split(" ")) .concatWith(NbpObservable.error(new RuntimeException())); - } - }; NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); @@ -359,18 +291,14 @@ public NbpObservable apply(Resource resource) { @Test public void testUsingDoesNotDisposesEagerlyBeforeError() { - final List events = new ArrayList(); + final List events = new ArrayList<>(); final Supplier resourceFactory = createResourceFactory(events); final Consumer onError = createOnErrorAction(events); final Runnable unsub = createUnsubAction(events); - Function> observableFactory = new Function>() { - @Override - public NbpObservable apply(Resource resource) { - return NbpObservable.fromArray(resource.getTextFromWeb().split(" ")) + Function> observableFactory = resource -> + NbpObservable.fromArray(resource.getTextFromWeb().split(" ")) .concatWith(NbpObservable.error(new RuntimeException())); - } - }; NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); @@ -385,50 +313,30 @@ public NbpObservable apply(Resource resource) { } private static Runnable createUnsubAction(final List events) { - return new Runnable() { - @Override - public void run() { - events.add("unsub"); - } - }; + return () -> events.add("unsub"); } private static Consumer createOnErrorAction(final List events) { - return new Consumer() { - @Override - public void accept(Throwable t) { - events.add("error"); - } - }; + return t -> events.add("error"); } private static Supplier createResourceFactory(final List events) { - return new Supplier() { + return () -> new Resource() { + + @Override + public String getTextFromWeb() { + return "hello world"; + } + @Override - public Resource get() { - return new Resource() { - - @Override - public String getTextFromWeb() { - return "hello world"; - } - - @Override - public void dispose() { - events.add("disposed"); - } - }; + public void dispose() { + events.add("disposed"); } }; } private static Runnable createOnCompletedAction(final List events) { - return new Runnable() { - @Override - public void run() { - events.add("completed"); - } - }; + return () -> events.add("completed"); } } \ No newline at end of file diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorAllTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorAllTest.java similarity index 65% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorAllTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorAllTest.java index 2a391cbf57..a4a0c217ad 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorAllTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorAllTest.java @@ -35,15 +35,10 @@ public void testAll() { NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); - obs.all(new Predicate() { - @Override - public boolean test(String s) { - return s.length() == 3; - } - }) + obs.all(s -> s.length() == 3) .subscribe(NbpObserver); - verify(NbpObserver).onSubscribe((Disposable)any()); + verify(NbpObserver).onSubscribe(any()); verify(NbpObserver).onNext(true); verify(NbpObserver).onComplete(); verifyNoMoreInteractions(NbpObserver); @@ -55,15 +50,10 @@ public void testNotAll() { NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); - obs.all(new Predicate() { - @Override - public boolean test(String s) { - return s.length() == 3; - } - }) + obs.all(s -> s.length() == 3) .subscribe(NbpObserver); - verify(NbpObserver).onSubscribe((Disposable)any()); + verify(NbpObserver).onSubscribe(any()); verify(NbpObserver).onNext(false); verify(NbpObserver).onComplete(); verifyNoMoreInteractions(NbpObserver); @@ -75,15 +65,10 @@ public void testEmpty() { NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); - obs.all(new Predicate() { - @Override - public boolean test(String s) { - return s.length() == 3; - } - }) + obs.all(s -> s.length() == 3) .subscribe(NbpObserver); - verify(NbpObserver).onSubscribe((Disposable)any()); + verify(NbpObserver).onSubscribe(any()); verify(NbpObserver).onNext(true); verify(NbpObserver).onComplete(); verifyNoMoreInteractions(NbpObserver); @@ -96,15 +81,10 @@ public void testError() { NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); - obs.all(new Predicate() { - @Override - public boolean test(String s) { - return s.length() == 3; - } - }) + obs.all(s -> s.length() == 3) .subscribe(NbpObserver); - verify(NbpObserver).onSubscribe((Disposable)any()); + verify(NbpObserver).onSubscribe(any()); verify(NbpObserver).onError(error); verifyNoMoreInteractions(NbpObserver); } @@ -112,30 +92,15 @@ public boolean test(String s) { @Test public void testFollowingFirst() { NbpObservable o = NbpObservable.fromArray(1, 3, 5, 6); - NbpObservable allOdd = o.all(new Predicate() { - @Override - public boolean test(Integer i) { - return i % 2 == 1; - } - }); + NbpObservable allOdd = o.all(i -> i % 2 == 1); assertFalse(allOdd.toBlocking().first()); } @Test(timeout = 5000) public void testIssue1935NoUnsubscribeDownstream() { NbpObservable source = NbpObservable.just(1) - .all(new Predicate() { - @Override - public boolean test(Integer t1) { - return false; - } - }) - .flatMap(new Function>() { - @Override - public NbpObservable apply(Boolean t1) { - return NbpObservable.just(2).delay(500, TimeUnit.MILLISECONDS); - } - }); + .all(t1 -> false) + .flatMap(t1 -> NbpObservable.just(2).delay(500, TimeUnit.MILLISECONDS)); assertEquals((Object)2, source.toBlocking().first()); } @@ -143,15 +108,12 @@ public NbpObservable apply(Boolean t1) { @Test public void testPredicateThrowsExceptionAndValueInCauseMessage() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); final IllegalArgumentException ex = new IllegalArgumentException(); - NbpObservable.just("Boo!").all(new Predicate() { - @Override - public boolean test(String v) { - throw ex; - } + NbpObservable.just("Boo!").all(v -> { + throw ex; }) .subscribe(ts); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorAnyTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorAnyTest.java similarity index 76% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorAnyTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorAnyTest.java index 0fe1aca1e3..883e32ca98 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorAnyTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorAnyTest.java @@ -30,12 +30,7 @@ public class NbpOperatorAnyTest { @Test public void testAnyWithTwoItems() { NbpObservable w = NbpObservable.just(1, 2); - NbpObservable NbpObservable = w.any(new Predicate() { - @Override - public boolean test(Integer v) { - return true; - } - }); + NbpObservable NbpObservable = w.any(v -> true); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); @@ -65,12 +60,7 @@ public void testIsEmptyWithTwoItems() { @Test public void testAnyWithOneItem() { NbpObservable w = NbpObservable.just(1); - NbpObservable NbpObservable = w.any(new Predicate() { - @Override - public boolean test(Integer v) { - return true; - } - }); + NbpObservable NbpObservable = w.any(v -> true); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); @@ -100,12 +90,7 @@ public void testIsEmptyWithOneItem() { @Test public void testAnyWithEmpty() { NbpObservable w = NbpObservable.empty(); - NbpObservable NbpObservable = w.any(new Predicate() { - @Override - public boolean test(Integer v) { - return true; - } - }); + NbpObservable NbpObservable = w.any(v -> true); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); @@ -135,12 +120,7 @@ public void testIsEmptyWithEmpty() { @Test public void testAnyWithPredicate1() { NbpObservable w = NbpObservable.just(1, 2, 3); - NbpObservable NbpObservable = w.any(new Predicate() { - @Override - public boolean test(Integer t1) { - return t1 < 2; - } - }); + NbpObservable NbpObservable = w.any(t1 -> t1 < 2); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); @@ -155,12 +135,7 @@ public boolean test(Integer t1) { @Test public void testExists1() { NbpObservable w = NbpObservable.just(1, 2, 3); - NbpObservable NbpObservable = w.any(new Predicate() { - @Override - public boolean test(Integer t1) { - return t1 < 2; - } - }); + NbpObservable NbpObservable = w.any(t1 -> t1 < 2); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); @@ -175,12 +150,7 @@ public boolean test(Integer t1) { @Test public void testAnyWithPredicate2() { NbpObservable w = NbpObservable.just(1, 2, 3); - NbpObservable NbpObservable = w.any(new Predicate() { - @Override - public boolean test(Integer t1) { - return t1 < 1; - } - }); + NbpObservable NbpObservable = w.any(t1 -> t1 < 1); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); @@ -196,12 +166,7 @@ public boolean test(Integer t1) { public void testAnyWithEmptyAndPredicate() { // If the source is empty, always output false. NbpObservable w = NbpObservable.empty(); - NbpObservable NbpObservable = w.any(new Predicate() { - @Override - public boolean test(Integer t) { - return true; - } - }); + NbpObservable NbpObservable = w.any(t -> true); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); @@ -216,38 +181,25 @@ public boolean test(Integer t) { @Test public void testWithFollowingFirst() { NbpObservable o = NbpObservable.fromArray(1, 3, 5, 6); - NbpObservable anyEven = o.any(new Predicate() { - @Override - public boolean test(Integer i) { - return i % 2 == 0; - } - }); + NbpObservable anyEven = o.any(i -> i % 2 == 0); assertTrue(anyEven.toBlocking().first()); } @Test(timeout = 5000) public void testIssue1935NoUnsubscribeDownstream() { NbpObservable source = NbpObservable.just(1).isEmpty() - .flatMap(new Function>() { - @Override - public NbpObservable apply(Boolean t1) { - return NbpObservable.just(2).delay(500, TimeUnit.MILLISECONDS); - } - }); + .flatMap(t1 -> NbpObservable.just(2).delay(500, TimeUnit.MILLISECONDS)); assertEquals((Object)2, source.toBlocking().first()); } @Test public void testPredicateThrowsExceptionAndValueInCauseMessage() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); final IllegalArgumentException ex = new IllegalArgumentException(); - NbpObservable.just("Boo!").any(new Predicate() { - @Override - public boolean test(String v) { - throw ex; - } + NbpObservable.just("Boo!").any(v -> { + throw ex; }).subscribe(ts); ts.assertTerminated(); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorAsObservableTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorAsObservableTest.java similarity index 100% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorAsObservableTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorAsObservableTest.java diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorBufferTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorBufferTest.java similarity index 80% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorBufferTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorBufferTest.java index badd79c735..908402ee90 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorBufferTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorBufferTest.java @@ -75,9 +75,9 @@ public void accept(NbpSubscriber NbpObserver) { buffered.subscribe(NbpObserver); InOrder inOrder = Mockito.inOrder(NbpObserver); - inOrder.verify(NbpObserver, Mockito.times(1)).onNext(list("one", "two", "three")); - inOrder.verify(NbpObserver, Mockito.times(1)).onNext(list("two", "three", "four")); - inOrder.verify(NbpObserver, Mockito.times(1)).onNext(list("three", "four", "five")); + inOrder.verify(NbpObserver, Mockito.times(1)).onNext(Arrays.asList("one", "two", "three")); + inOrder.verify(NbpObserver, Mockito.times(1)).onNext(Arrays.asList("two", "three", "four")); + inOrder.verify(NbpObserver, Mockito.times(1)).onNext(Arrays.asList("three", "four", "five")); inOrder.verify(NbpObserver, Mockito.never()).onNext(Mockito.anyListOf(String.class)); inOrder.verify(NbpObserver, Mockito.never()).onError(Mockito.any(Throwable.class)); inOrder.verify(NbpObserver, Mockito.never()).onComplete(); @@ -91,8 +91,8 @@ public void testSkipAndCountGaplessBuffers() { buffered.subscribe(NbpObserver); InOrder inOrder = Mockito.inOrder(NbpObserver); - inOrder.verify(NbpObserver, Mockito.times(1)).onNext(list("one", "two", "three")); - inOrder.verify(NbpObserver, Mockito.times(1)).onNext(list("four", "five")); + inOrder.verify(NbpObserver, Mockito.times(1)).onNext(Arrays.asList("one", "two", "three")); + inOrder.verify(NbpObserver, Mockito.times(1)).onNext(Arrays.asList("four", "five")); inOrder.verify(NbpObserver, Mockito.never()).onNext(Mockito.anyListOf(String.class)); inOrder.verify(NbpObserver, Mockito.never()).onError(Mockito.any(Throwable.class)); inOrder.verify(NbpObserver, Mockito.times(1)).onComplete(); @@ -106,8 +106,8 @@ public void testSkipAndCountBuffersWithGaps() { buffered.subscribe(NbpObserver); InOrder inOrder = Mockito.inOrder(NbpObserver); - inOrder.verify(NbpObserver, Mockito.times(1)).onNext(list("one", "two")); - inOrder.verify(NbpObserver, Mockito.times(1)).onNext(list("four", "five")); + inOrder.verify(NbpObserver, Mockito.times(1)).onNext(Arrays.asList("one", "two")); + inOrder.verify(NbpObserver, Mockito.times(1)).onNext(Arrays.asList("four", "five")); inOrder.verify(NbpObserver, Mockito.never()).onNext(Mockito.anyListOf(String.class)); inOrder.verify(NbpObserver, Mockito.never()).onError(Mockito.any(Throwable.class)); inOrder.verify(NbpObserver, Mockito.times(1)).onComplete(); @@ -133,13 +133,13 @@ public void accept(NbpSubscriber NbpObserver) { InOrder inOrder = Mockito.inOrder(NbpObserver); scheduler.advanceTimeTo(100, TimeUnit.MILLISECONDS); - inOrder.verify(NbpObserver, Mockito.times(1)).onNext(list("one", "two")); + inOrder.verify(NbpObserver, Mockito.times(1)).onNext(Arrays.asList("one", "two")); scheduler.advanceTimeTo(200, TimeUnit.MILLISECONDS); - inOrder.verify(NbpObserver, Mockito.times(1)).onNext(list("three", "four")); + inOrder.verify(NbpObserver, Mockito.times(1)).onNext(Arrays.asList("three", "four")); scheduler.advanceTimeTo(300, TimeUnit.MILLISECONDS); - inOrder.verify(NbpObserver, Mockito.times(1)).onNext(list("five")); + inOrder.verify(NbpObserver, Mockito.times(1)).onNext(Arrays.asList("five")); inOrder.verify(NbpObserver, Mockito.never()).onNext(Mockito.anyListOf(String.class)); inOrder.verify(NbpObserver, Mockito.never()).onError(Mockito.any(Throwable.class)); inOrder.verify(NbpObserver, Mockito.times(1)).onComplete(); @@ -170,10 +170,10 @@ public void accept(NbpSubscriber NbpObserver) { InOrder inOrder = Mockito.inOrder(NbpObserver); scheduler.advanceTimeTo(101, TimeUnit.MILLISECONDS); - inOrder.verify(NbpObserver, Mockito.times(1)).onNext(list("one", "two", "three")); + inOrder.verify(NbpObserver, Mockito.times(1)).onNext(Arrays.asList("one", "two", "three")); scheduler.advanceTimeTo(201, TimeUnit.MILLISECONDS); - inOrder.verify(NbpObserver, Mockito.times(1)).onNext(list("four", "five")); + inOrder.verify(NbpObserver, Mockito.times(1)).onNext(Arrays.asList("four", "five")); inOrder.verify(NbpObserver, Mockito.never()).onNext(Mockito.anyListOf(String.class)); inOrder.verify(NbpObserver, Mockito.never()).onError(Mockito.any(Throwable.class)); inOrder.verify(NbpObserver, Mockito.times(1)).onComplete(); @@ -194,37 +194,26 @@ public void accept(NbpSubscriber NbpObserver) { } }); - NbpObservable openings = NbpObservable.create(new NbpOnSubscribe() { - @Override - public void accept(NbpSubscriber NbpObserver) { - NbpObserver.onSubscribe(EmptyDisposable.INSTANCE); - push(NbpObserver, new Object(), 50); - push(NbpObserver, new Object(), 200); - complete(NbpObserver, 250); - } + NbpObservable openings = NbpObservable.create(s -> { + s.onSubscribe(EmptyDisposable.INSTANCE); + push(s, new Object(), 50); + push(s, new Object(), 200); + complete(s, 250); }); - Function> closer = new Function>() { - @Override - public NbpObservable apply(Object opening) { - return NbpObservable.create(new NbpOnSubscribe() { - @Override - public void accept(NbpSubscriber NbpObserver) { - NbpObserver.onSubscribe(EmptyDisposable.INSTANCE); - push(NbpObserver, new Object(), 100); - complete(NbpObserver, 101); - } - }); - } - }; + Function> closer = opening -> NbpObservable.create(s -> { + s.onSubscribe(EmptyDisposable.INSTANCE); + push(s, new Object(), 100); + complete(s, 101); + }); NbpObservable> buffered = source.buffer(openings, closer); buffered.subscribe(NbpObserver); InOrder inOrder = Mockito.inOrder(NbpObserver); scheduler.advanceTimeTo(500, TimeUnit.MILLISECONDS); - inOrder.verify(NbpObserver, Mockito.times(1)).onNext(list("two", "three")); - inOrder.verify(NbpObserver, Mockito.times(1)).onNext(list("five")); + inOrder.verify(NbpObserver, Mockito.times(1)).onNext(Arrays.asList("two", "three")); + inOrder.verify(NbpObserver, Mockito.times(1)).onNext(Arrays.asList("five")); inOrder.verify(NbpObserver, Mockito.never()).onNext(Mockito.anyListOf(String.class)); inOrder.verify(NbpObserver, Mockito.never()).onError(Mockito.any(Throwable.class)); inOrder.verify(NbpObserver, Mockito.times(1)).onComplete(); @@ -232,43 +221,32 @@ public void accept(NbpSubscriber NbpObserver) { @Test public void testObservableBasedCloser() { - NbpObservable source = NbpObservable.create(new NbpOnSubscribe() { - @Override - public void accept(NbpSubscriber NbpObserver) { - NbpObserver.onSubscribe(EmptyDisposable.INSTANCE); - push(NbpObserver, "one", 10); - push(NbpObserver, "two", 60); - push(NbpObserver, "three", 110); - push(NbpObserver, "four", 160); - push(NbpObserver, "five", 210); - complete(NbpObserver, 250); - } + NbpObservable source = NbpObservable.create(s -> { + s.onSubscribe(EmptyDisposable.INSTANCE); + push(s, "one", 10); + push(s, "two", 60); + push(s, "three", 110); + push(s, "four", 160); + push(s, "five", 210); + complete(s, 250); }); - Supplier> closer = new Supplier>() { - @Override - public NbpObservable get() { - return NbpObservable.create(new NbpOnSubscribe() { - @Override - public void accept(NbpSubscriber NbpObserver) { - NbpObserver.onSubscribe(EmptyDisposable.INSTANCE); - push(NbpObserver, new Object(), 100); - push(NbpObserver, new Object(), 200); - push(NbpObserver, new Object(), 300); - complete(NbpObserver, 301); - } - }); - } - }; + Supplier> closer = () -> NbpObservable.create(s -> { + s.onSubscribe(EmptyDisposable.INSTANCE); + push(s, new Object(), 100); + push(s, new Object(), 200); + push(s, new Object(), 300); + complete(s, 301); + }); NbpObservable> buffered = source.buffer(closer); buffered.subscribe(NbpObserver); InOrder inOrder = Mockito.inOrder(NbpObserver); scheduler.advanceTimeTo(500, TimeUnit.MILLISECONDS); - inOrder.verify(NbpObserver, Mockito.times(1)).onNext(list("one", "two")); - inOrder.verify(NbpObserver, Mockito.times(1)).onNext(list("three", "four")); - inOrder.verify(NbpObserver, Mockito.times(1)).onNext(list("five")); + inOrder.verify(NbpObserver, Mockito.times(1)).onNext(Arrays.asList("one", "two")); + inOrder.verify(NbpObserver, Mockito.times(1)).onNext(Arrays.asList("three", "four")); + inOrder.verify(NbpObserver, Mockito.times(1)).onNext(Arrays.asList("five")); inOrder.verify(NbpObserver, Mockito.never()).onNext(Mockito.anyListOf(String.class)); inOrder.verify(NbpObserver, Mockito.never()).onError(Mockito.any(Throwable.class)); inOrder.verify(NbpObserver, Mockito.times(1)).onComplete(); @@ -308,30 +286,12 @@ public void accept(List t1) { } } - private List list(String... args) { - List list = new ArrayList(); - for (String arg : args) { - list.add(arg); - } - return list; - } - private void push(final NbpSubscriber NbpObserver, final T value, int delay) { - innerScheduler.schedule(new Runnable() { - @Override - public void run() { - NbpObserver.onNext(value); - } - }, delay, TimeUnit.MILLISECONDS); + innerScheduler.schedule(() -> NbpObserver.onNext(value), delay, TimeUnit.MILLISECONDS); } private void complete(final NbpSubscriber NbpObserver, int delay) { - innerScheduler.schedule(new Runnable() { - @Override - public void run() { - NbpObserver.onComplete(); - } - }, delay, TimeUnit.MILLISECONDS); + innerScheduler.schedule(NbpObserver::onComplete, delay, TimeUnit.MILLISECONDS); } @Test @@ -339,15 +299,10 @@ public void testBufferStopsWhenUnsubscribed1() { NbpObservable source = NbpObservable.never(); NbpSubscriber> o = TestHelper.mockNbpSubscriber(); - NbpTestSubscriber> ts = new NbpTestSubscriber>(o); + NbpTestSubscriber> ts = new NbpTestSubscriber<>(o); source.buffer(100, 200, TimeUnit.MILLISECONDS, scheduler) - .doOnNext(new Consumer>() { - @Override - public void accept(List pv) { - System.out.println(pv); - } - }) + .doOnNext(System.out::println) .subscribe(ts); InOrder inOrder = Mockito.inOrder(o); @@ -575,12 +530,7 @@ public void bufferWithBoundaryTake2() { @Test(timeout = 2000) public void bufferWithStartEndBoundaryTake2() { NbpObservable start = NbpObservable.interval(61, 61, TimeUnit.MILLISECONDS, scheduler); - Function> end = new Function>() { - @Override - public NbpObservable apply(Long t1) { - return NbpObservable.interval(100, 100, TimeUnit.MILLISECONDS, scheduler); - } - }; + Function> end = t1 -> NbpObservable.interval(100, 100, TimeUnit.MILLISECONDS, scheduler); NbpObservable source = NbpObservable.interval(40, 40, TimeUnit.MILLISECONDS, scheduler); @@ -590,12 +540,7 @@ public NbpObservable apply(Long t1) { InOrder inOrder = inOrder(o); result - .doOnNext(new Consumer>() { - @Override - public void accept(List pv) { - System.out.println(pv); - } - }) + .doOnNext(System.out::println) .subscribe(o); scheduler.advanceTimeBy(5, TimeUnit.SECONDS); @@ -678,12 +623,7 @@ public void bufferWithTimeAndSize() { public void bufferWithStartEndStartThrows() { NbpPublishSubject start = NbpPublishSubject.create(); - Function> end = new Function>() { - @Override - public NbpObservable apply(Integer t1) { - return NbpObservable.never(); - } - }; + Function> end = t1 -> NbpObservable.never(); NbpPublishSubject source = NbpPublishSubject.create(); @@ -706,11 +646,8 @@ public NbpObservable apply(Integer t1) { public void bufferWithStartEndEndFunctionThrows() { NbpPublishSubject start = NbpPublishSubject.create(); - Function> end = new Function>() { - @Override - public NbpObservable apply(Integer t1) { - throw new TestException(); - } + Function> end = t1 -> { + throw new TestException(); }; NbpPublishSubject source = NbpPublishSubject.create(); @@ -733,12 +670,7 @@ public NbpObservable apply(Integer t1) { public void bufferWithStartEndEndThrows() { NbpPublishSubject start = NbpPublishSubject.create(); - Function> end = new Function>() { - @Override - public NbpObservable apply(Integer t1) { - return NbpObservable.error(new TestException()); - } - }; + Function> end = t1 -> NbpObservable.error(new TestException()); NbpPublishSubject source = NbpPublishSubject.create(); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorCastTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorCastTest.java similarity index 100% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorCastTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorCastTest.java diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorConcatTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorConcatTest.java similarity index 80% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorConcatTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorConcatTest.java index 8581fe9dd2..fd099e0b6a 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorConcatTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorConcatTest.java @@ -60,7 +60,7 @@ public void testConcatWithList() { final NbpObservable odds = NbpObservable.fromArray(o); final NbpObservable even = NbpObservable.fromArray(e); - final List> list = new ArrayList>(); + final List> list = new ArrayList<>(); list.add(odds); list.add(even); NbpObservable concat = NbpObservable.concat(NbpObservable.fromIterable(list)); @@ -105,8 +105,8 @@ public void accept(NbpSubscriber> NbpObserver) { public void testSimpleAsyncConcat() { NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); - TestObservable o1 = new TestObservable("one", "two", "three"); - TestObservable o2 = new TestObservable("four", "five", "six"); + TestObservable o1 = new TestObservable<>("one", "two", "three"); + TestObservable o2 = new TestObservable<>("four", "five", "six"); NbpObservable.concat(NbpObservable.create(o1), NbpObservable.create(o2)).subscribe(NbpObserver); @@ -145,12 +145,12 @@ public void testNestedAsyncConcatLoop() throws Throwable { public void testNestedAsyncConcat() throws InterruptedException { NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); - final TestObservable o1 = new TestObservable("one", "two", "three"); - final TestObservable o2 = new TestObservable("four", "five", "six"); - final TestObservable o3 = new TestObservable("seven", "eight", "nine"); + final TestObservable o1 = new TestObservable<>("one", "two", "three"); + final TestObservable o2 = new TestObservable<>("four", "five", "six"); + final TestObservable o3 = new TestObservable<>("seven", "eight", "nine"); final CountDownLatch allowThird = new CountDownLatch(1); - final AtomicReference parent = new AtomicReference(); + final AtomicReference parent = new AtomicReference<>(); final CountDownLatch parentHasStarted = new CountDownLatch(1); final CountDownLatch parentHasFinished = new CountDownLatch(1); @@ -161,40 +161,36 @@ public void testNestedAsyncConcat() throws InterruptedException { public void accept(final NbpSubscriber> NbpObserver) { final BooleanDisposable s = new BooleanDisposable(); NbpObserver.onSubscribe(s); - parent.set(new Thread(new Runnable() { + parent.set(new Thread(() -> { + try { + // emit first + if (!s.isDisposed()) { + System.out.println("Emit o1"); + NbpObserver.onNext(NbpObservable.create(o1)); + } + // emit second + if (!s.isDisposed()) { + System.out.println("Emit o2"); + NbpObserver.onNext(NbpObservable.create(o2)); + } - @Override - public void run() { + // wait until sometime later and emit third try { - // emit first - if (!s.isDisposed()) { - System.out.println("Emit o1"); - NbpObserver.onNext(NbpObservable.create(o1)); - } - // emit second - if (!s.isDisposed()) { - System.out.println("Emit o2"); - NbpObserver.onNext(NbpObservable.create(o2)); - } - - // wait until sometime later and emit third - try { - allowThird.await(); - } catch (InterruptedException e) { - NbpObserver.onError(e); - } - if (!s.isDisposed()) { - System.out.println("Emit o3"); - NbpObserver.onNext(NbpObservable.create(o3)); - } - - } catch (Throwable e) { + allowThird.await(); + } catch (InterruptedException e) { NbpObserver.onError(e); - } finally { - System.out.println("Done parent NbpObservable"); - NbpObserver.onComplete(); - parentHasFinished.countDown(); } + if (!s.isDisposed()) { + System.out.println("Emit o3"); + NbpObserver.onNext(NbpObservable.create(o3)); + } + + } catch (Throwable e) { + NbpObserver.onError(e); + } finally { + System.out.println("Done parent NbpObservable"); + NbpObserver.onComplete(); + parentHasFinished.countDown(); } })); parent.get().start(); @@ -270,7 +266,7 @@ public void testBlockedObservableOfObservables() { final CountDownLatch callOnce = new CountDownLatch(1); final CountDownLatch okToContinue = new CountDownLatch(1); @SuppressWarnings("unchecked") - TestObservable> observableOfObservables = new TestObservable>(callOnce, okToContinue, odds, even); + TestObservable> observableOfObservables = new TestObservable<>(callOnce, okToContinue, odds, even); NbpObservable concatF = NbpObservable.concat(NbpObservable.create(observableOfObservables)); concatF.subscribe(NbpObserver); try { @@ -302,14 +298,14 @@ public void testBlockedObservableOfObservables() { @Test public void testConcatConcurrentWithInfinity() { - final TestObservable w1 = new TestObservable("one", "two", "three"); + final TestObservable w1 = new TestObservable<>("one", "two", "three"); //This NbpObservable will send "hello" MAX_VALUE time. - final TestObservable w2 = new TestObservable("hello", Integer.MAX_VALUE); + final TestObservable w2 = new TestObservable<>("hello", Integer.MAX_VALUE); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); @SuppressWarnings("unchecked") - TestObservable> observableOfObservables = new TestObservable>(NbpObservable.create(w1), NbpObservable.create(w2)); + TestObservable> observableOfObservables = new TestObservable<>(NbpObservable.create(w1), NbpObservable.create(w2)); NbpObservable concatF = NbpObservable.concat(NbpObservable.create(observableOfObservables)); concatF.take(50).subscribe(NbpObserver); @@ -337,8 +333,8 @@ public void testConcatNonBlockingObservables() { final CountDownLatch okToContinueW1 = new CountDownLatch(1); final CountDownLatch okToContinueW2 = new CountDownLatch(1); - final TestObservable w1 = new TestObservable(null, okToContinueW1, "one", "two", "three"); - final TestObservable w2 = new TestObservable(null, okToContinueW2, "four", "five", "six"); + final TestObservable w1 = new TestObservable<>(null, okToContinueW1, "one", "two", "three"); + final TestObservable w2 = new TestObservable<>(null, okToContinueW2, "four", "five", "six"); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); @@ -388,11 +384,11 @@ public void accept(NbpSubscriber> NbpObserver) { public void testConcatUnsubscribe() { final CountDownLatch callOnce = new CountDownLatch(1); final CountDownLatch okToContinue = new CountDownLatch(1); - final TestObservable w1 = new TestObservable("one", "two", "three"); - final TestObservable w2 = new TestObservable(callOnce, okToContinue, "four", "five", "six"); + final TestObservable w1 = new TestObservable<>("one", "two", "three"); + final TestObservable w2 = new TestObservable<>(callOnce, okToContinue, "four", "five", "six"); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); - NbpTestSubscriber ts = new NbpTestSubscriber(NbpObserver); + NbpTestSubscriber ts = new NbpTestSubscriber<>(NbpObserver); final NbpObservable concat = NbpObservable.concat(NbpObservable.create(w1), NbpObservable.create(w2)); @@ -430,14 +426,14 @@ public void testConcatUnsubscribe() { public void testConcatUnsubscribeConcurrent() { final CountDownLatch callOnce = new CountDownLatch(1); final CountDownLatch okToContinue = new CountDownLatch(1); - final TestObservable w1 = new TestObservable("one", "two", "three"); - final TestObservable w2 = new TestObservable(callOnce, okToContinue, "four", "five", "six"); + final TestObservable w1 = new TestObservable<>("one", "two", "three"); + final TestObservable w2 = new TestObservable<>(callOnce, okToContinue, "four", "five", "six"); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); - NbpTestSubscriber ts = new NbpTestSubscriber(NbpObserver); + NbpTestSubscriber ts = new NbpTestSubscriber<>(NbpObserver); @SuppressWarnings("unchecked") - TestObservable> observableOfObservables = new TestObservable>(NbpObservable.create(w1), NbpObservable.create(w2)); + TestObservable> observableOfObservables = new TestObservable<>(NbpObservable.create(w1), NbpObservable.create(w2)); NbpObservable concatF = NbpObservable.concat(NbpObservable.create(observableOfObservables)); concatF.subscribe(ts); @@ -509,32 +505,27 @@ public TestObservable(T seed, int size) { @Override public void accept(final NbpSubscriber NbpObserver) { NbpObserver.onSubscribe(s); - t = new Thread(new Runnable() { - - @Override - public void run() { - try { - while (count < size && subscribed) { - if (null != values) - NbpObserver.onNext(values.get(count)); - else - NbpObserver.onNext(seed); - count++; - //Unblock the main thread to call unsubscribe. - if (null != once) - once.countDown(); - //Block until the main thread has called unsubscribe. - if (null != okToContinue) - okToContinue.await(5, TimeUnit.SECONDS); - } - if (subscribed) - NbpObserver.onComplete(); - } catch (InterruptedException e) { - e.printStackTrace(); - fail(e.getMessage()); + t = new Thread(() -> { + try { + while (count < size && subscribed) { + if (null != values) + NbpObserver.onNext(values.get(count)); + else + NbpObserver.onNext(seed); + count++; + //Unblock the main thread to call unsubscribe. + if (null != once) + once.countDown(); + //Block until the main thread has called unsubscribe. + if (null != okToContinue) + okToContinue.await(5, TimeUnit.SECONDS); } + if (subscribed) + NbpObserver.onComplete(); + } catch (InterruptedException e) { + e.printStackTrace(); + fail(e.getMessage()); } - }); t.start(); threadHasStarted.countDown(); @@ -592,12 +583,7 @@ public void testMultipleObservers() { @Test public void concatVeryLongObservableOfObservables() { final int n = 10000; - NbpObservable> source = NbpObservable.range(0, n).map(new Function>() { - @Override - public NbpObservable apply(Integer v) { - return NbpObservable.just(v); - } - }); + NbpObservable> source = NbpObservable.range(0, n).map(NbpObservable::just); NbpObservable> result = NbpObservable.concat(source).toList(); @@ -606,7 +592,7 @@ public NbpObservable apply(Integer v) { result.subscribe(o); - List list = new ArrayList(n); + List list = new ArrayList<>(n); for (int i = 0; i < n; i++) { list.add(i); } @@ -617,12 +603,7 @@ public NbpObservable apply(Integer v) { @Test public void concatVeryLongObservableOfObservablesTakeHalf() { final int n = 10000; - NbpObservable> source = NbpObservable.range(0, n).map(new Function>() { - @Override - public NbpObservable apply(Integer v) { - return NbpObservable.just(v); - } - }); + NbpObservable> source = NbpObservable.range(0, n).map(NbpObservable::just); NbpObservable> result = NbpObservable.concat(source).take(n / 2).toList(); @@ -631,7 +612,7 @@ public NbpObservable apply(Integer v) { result.subscribe(o); - List list = new ArrayList(n); + List list = new ArrayList<>(n); for (int i = 0; i < n / 2; i++) { list.add(i); } @@ -664,7 +645,7 @@ public void accept(NbpSubscriber s) { }); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpObservable.concat(o, o).subscribe(ts); ts.awaitTerminalEvent(500, TimeUnit.MILLISECONDS); ts.assertTerminated(); @@ -677,16 +658,13 @@ public void testIssue2890NoStackoverflow() throws InterruptedException { final ExecutorService executor = Executors.newFixedThreadPool(2); final Scheduler sch = Schedulers.from(executor); - Function> func = new Function>() { - @Override - public NbpObservable apply(Integer t) { - NbpObservable o = NbpObservable.just(t) - .subscribeOn(sch) - ; - NbpSubject subject = NbpUnicastSubject.create(); - o.subscribe(subject); - return subject; - } + Function> func = t -> { + NbpObservable o = NbpObservable.just(t) + .subscribeOn(sch) + ; + NbpSubject subject = NbpUnicastSubject.create(); + o.subscribe(subject); + return subject; }; int n = 5000; @@ -734,14 +712,9 @@ public void concatMapRangeAsyncLoopIssue2876() { if (i % 1000 == 0) { System.out.println("concatMapRangeAsyncLoop > " + i); } - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpObservable.range(0, 1000) - .concatMap(new Function>() { - @Override - public NbpObservable apply(Integer t) { - return NbpObservable.fromIterable(Arrays.asList(t)); - } - }) + .concatMap(t -> NbpObservable.fromIterable(Arrays.asList(t))) .observeOn(Schedulers.computation()).subscribe(ts); ts.awaitTerminalEvent(2500, TimeUnit.MILLISECONDS); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDebounceTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDebounceTest.java similarity index 87% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDebounceTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDebounceTest.java index e0abb8a422..b110239f89 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDebounceTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDebounceTest.java @@ -126,43 +126,22 @@ public void accept(NbpSubscriber NbpObserver) { } private void publishCompleted(final NbpSubscriber NbpObserver, long delay) { - innerScheduler.schedule(new Runnable() { - @Override - public void run() { - NbpObserver.onComplete(); - } - }, delay, TimeUnit.MILLISECONDS); + innerScheduler.schedule(NbpObserver::onComplete, delay, TimeUnit.MILLISECONDS); } private void publishError(final NbpSubscriber NbpObserver, long delay, final Exception error) { - innerScheduler.schedule(new Runnable() { - @Override - public void run() { - NbpObserver.onError(error); - } - }, delay, TimeUnit.MILLISECONDS); + innerScheduler.schedule(() -> NbpObserver.onError(error), delay, TimeUnit.MILLISECONDS); } private void publishNext(final NbpSubscriber NbpObserver, final long delay, final T value) { - innerScheduler.schedule(new Runnable() { - @Override - public void run() { - NbpObserver.onNext(value); - } - }, delay, TimeUnit.MILLISECONDS); + innerScheduler.schedule(() -> NbpObserver.onNext(value), delay, TimeUnit.MILLISECONDS); } @Test public void debounceSelectorNormal1() { NbpPublishSubject source = NbpPublishSubject.create(); final NbpPublishSubject debouncer = NbpPublishSubject.create(); - Function> debounceSel = new Function>() { - - @Override - public NbpObservable apply(Integer t1) { - return debouncer; - } - }; + Function> debounceSel = t1 -> debouncer; NbpSubscriber o = TestHelper.mockNbpSubscriber(); InOrder inOrder = inOrder(o); @@ -192,12 +171,8 @@ public NbpObservable apply(Integer t1) { @Test public void debounceSelectorFuncThrows() { NbpPublishSubject source = NbpPublishSubject.create(); - Function> debounceSel = new Function>() { - - @Override - public NbpObservable apply(Integer t1) { - throw new TestException(); - } + Function> debounceSel = t1 -> { + throw new TestException(); }; NbpSubscriber o = TestHelper.mockNbpSubscriber(); @@ -214,13 +189,7 @@ public NbpObservable apply(Integer t1) { @Test public void debounceSelectorObservableThrows() { NbpPublishSubject source = NbpPublishSubject.create(); - Function> debounceSel = new Function>() { - - @Override - public NbpObservable apply(Integer t1) { - return NbpObservable.error(new TestException()); - } - }; + Function> debounceSel = t1 -> NbpObservable.error(new TestException()); NbpSubscriber o = TestHelper.mockNbpSubscriber(); @@ -254,13 +223,7 @@ public void debounceSelectorLastIsNotLost() { NbpPublishSubject source = NbpPublishSubject.create(); final NbpPublishSubject debouncer = NbpPublishSubject.create(); - Function> debounceSel = new Function>() { - - @Override - public NbpObservable apply(Integer t1) { - return debouncer; - } - }; + Function> debounceSel = t1 -> debouncer; NbpSubscriber o = TestHelper.mockNbpSubscriber(); @@ -279,7 +242,7 @@ public NbpObservable apply(Integer t1) { @Test public void debounceWithTimeBackpressure() throws InterruptedException { TestScheduler scheduler = new TestScheduler(); - NbpTestSubscriber NbpSubscriber = new NbpTestSubscriber(); + NbpTestSubscriber NbpSubscriber = new NbpTestSubscriber<>(); NbpObservable.merge( NbpObservable.just(1), NbpObservable.just(2).delay(10, TimeUnit.MILLISECONDS, scheduler) diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDefaultIfEmptyTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDefaultIfEmptyTest.java similarity index 100% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDefaultIfEmptyTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDefaultIfEmptyTest.java diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDelayTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDelayTest.java similarity index 78% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDelayTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDelayTest.java index 4527b0264b..ac35c321c9 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDelayTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDelayTest.java @@ -119,14 +119,11 @@ public void testLongDelay() { @Test public void testDelayWithError() { NbpObservable source = NbpObservable.interval(1L, TimeUnit.SECONDS, scheduler) - .map(new Function() { - @Override - public Long apply(Long value) { - if (value == 1L) { - throw new RuntimeException("error!"); - } - return value; + .map(value -> { + if (value == 1L) { + throw new RuntimeException("error!"); } + return value; }); NbpObservable delayed = source.delay(1L, TimeUnit.SECONDS, scheduler); delayed.subscribe(NbpObserver); @@ -217,7 +214,7 @@ public void testDelaySubscriptionCancelBeforeTime() { NbpObservable result = NbpObservable.just(1, 2, 3).delaySubscription(100, TimeUnit.MILLISECONDS, scheduler); NbpSubscriber o = TestHelper.mockNbpSubscriber(); - NbpTestSubscriber ts = new NbpTestSubscriber(o); + NbpTestSubscriber ts = new NbpTestSubscriber<>(o); result.subscribe(ts); ts.dispose(); @@ -231,19 +228,14 @@ public void testDelaySubscriptionCancelBeforeTime() { @Test public void testDelayWithObservableNormal1() { NbpPublishSubject source = NbpPublishSubject.create(); - final List> delays = new ArrayList>(); + final List> delays = new ArrayList<>(); final int n = 10; for (int i = 0; i < n; i++) { NbpPublishSubject delay = NbpPublishSubject.create(); delays.add(delay); } - Function> delayFunc = new Function>() { - @Override - public NbpObservable apply(Integer t1) { - return delays.get(t1); - } - }; + Function> delayFunc = delays::get; NbpSubscriber o = TestHelper.mockNbpSubscriber(); InOrder inOrder = inOrder(o); @@ -268,13 +260,7 @@ public void testDelayWithObservableSingleSend1() { NbpPublishSubject source = NbpPublishSubject.create(); final NbpPublishSubject delay = NbpPublishSubject.create(); - Function> delayFunc = new Function>() { - - @Override - public NbpObservable apply(Integer t1) { - return delay; - } - }; + Function> delayFunc = t1 -> delay; NbpSubscriber o = TestHelper.mockNbpSubscriber(); InOrder inOrder = inOrder(o); @@ -294,13 +280,7 @@ public void testDelayWithObservableSourceThrows() { NbpPublishSubject source = NbpPublishSubject.create(); final NbpPublishSubject delay = NbpPublishSubject.create(); - Function> delayFunc = new Function>() { - - @Override - public NbpObservable apply(Integer t1) { - return delay; - } - }; + Function> delayFunc = t1 -> delay; NbpSubscriber o = TestHelper.mockNbpSubscriber(); InOrder inOrder = inOrder(o); @@ -319,12 +299,8 @@ public NbpObservable apply(Integer t1) { public void testDelayWithObservableDelayFunctionThrows() { NbpPublishSubject source = NbpPublishSubject.create(); - Function> delayFunc = new Function>() { - - @Override - public NbpObservable apply(Integer t1) { - throw new TestException(); - } + Function> delayFunc = t1 -> { + throw new TestException(); }; NbpSubscriber o = TestHelper.mockNbpSubscriber(); InOrder inOrder = inOrder(o); @@ -343,13 +319,7 @@ public void testDelayWithObservableDelayThrows() { NbpPublishSubject source = NbpPublishSubject.create(); final NbpPublishSubject delay = NbpPublishSubject.create(); - Function> delayFunc = new Function>() { - - @Override - public NbpObservable apply(Integer t1) { - return delay; - } - }; + Function> delayFunc = t1 -> delay; NbpSubscriber o = TestHelper.mockNbpSubscriber(); InOrder inOrder = inOrder(o); @@ -367,19 +337,8 @@ public NbpObservable apply(Integer t1) { public void testDelayWithObservableSubscriptionNormal() { NbpPublishSubject source = NbpPublishSubject.create(); final NbpPublishSubject delay = NbpPublishSubject.create(); - Supplier> subFunc = new Supplier>() { - @Override - public NbpObservable get() { - return delay; - } - }; - Function> delayFunc = new Function>() { - - @Override - public NbpObservable apply(Integer t1) { - return delay; - } - }; + Supplier> subFunc = () -> delay; + Function> delayFunc = t1 -> delay; NbpSubscriber o = TestHelper.mockNbpSubscriber(); InOrder inOrder = inOrder(o); @@ -402,19 +361,10 @@ public NbpObservable apply(Integer t1) { public void testDelayWithObservableSubscriptionFunctionThrows() { NbpPublishSubject source = NbpPublishSubject.create(); final NbpPublishSubject delay = NbpPublishSubject.create(); - Supplier> subFunc = new Supplier>() { - @Override - public NbpObservable get() { - throw new TestException(); - } - }; - Function> delayFunc = new Function>() { - - @Override - public NbpObservable apply(Integer t1) { - return delay; - } + Supplier> subFunc = () -> { + throw new TestException(); }; + Function> delayFunc = t1 -> delay; NbpSubscriber o = TestHelper.mockNbpSubscriber(); InOrder inOrder = inOrder(o); @@ -436,19 +386,8 @@ public NbpObservable apply(Integer t1) { public void testDelayWithObservableSubscriptionThrows() { NbpPublishSubject source = NbpPublishSubject.create(); final NbpPublishSubject delay = NbpPublishSubject.create(); - Supplier> subFunc = new Supplier>() { - @Override - public NbpObservable get() { - return delay; - } - }; - Function> delayFunc = new Function>() { - - @Override - public NbpObservable apply(Integer t1) { - return delay; - } - }; + Supplier> subFunc = () -> delay; + Function> delayFunc = t1 -> delay; NbpSubscriber o = TestHelper.mockNbpSubscriber(); InOrder inOrder = inOrder(o); @@ -470,13 +409,7 @@ public NbpObservable apply(Integer t1) { public void testDelayWithObservableEmptyDelayer() { NbpPublishSubject source = NbpPublishSubject.create(); - Function> delayFunc = new Function>() { - - @Override - public NbpObservable apply(Integer t1) { - return NbpObservable.empty(); - } - }; + Function> delayFunc = t1 -> NbpObservable.empty(); NbpSubscriber o = TestHelper.mockNbpSubscriber(); InOrder inOrder = inOrder(o); @@ -496,19 +429,8 @@ public void testDelayWithObservableSubscriptionRunCompletion() { NbpPublishSubject source = NbpPublishSubject.create(); final NbpPublishSubject sdelay = NbpPublishSubject.create(); final NbpPublishSubject delay = NbpPublishSubject.create(); - Supplier> subFunc = new Supplier>() { - @Override - public NbpObservable get() { - return sdelay; - } - }; - Function> delayFunc = new Function>() { - - @Override - public NbpObservable apply(Integer t1) { - return delay; - } - }; + Supplier> subFunc = () -> sdelay; + Function> delayFunc = t1 -> delay; NbpSubscriber o = TestHelper.mockNbpSubscriber(); InOrder inOrder = inOrder(o); @@ -533,12 +455,7 @@ public void testDelayWithObservableAsTimed() { final NbpObservable delayer = NbpObservable.timer(500L, TimeUnit.MILLISECONDS, scheduler); - Function> delayFunc = new Function>() { - @Override - public NbpObservable apply(Long t1) { - return delayer; - } - }; + Function> delayFunc = t1 -> delayer; NbpObservable delayed = source.delay(delayFunc); delayed.subscribe(NbpObserver); @@ -582,18 +499,12 @@ public void testDelayWithObservableReorder() { int n = 3; NbpPublishSubject source = NbpPublishSubject.create(); - final List> subjects = new ArrayList>(); + final List> subjects = new ArrayList<>(); for (int i = 0; i < n; i++) { subjects.add(NbpPublishSubject. create()); } - NbpObservable result = source.delay(new Function>() { - - @Override - public NbpObservable apply(Integer t1) { - return subjects.get(t1); - } - }); + NbpObservable result = source.delay(t1 -> subjects.get(t1)); NbpSubscriber o = TestHelper.mockNbpSubscriber(); InOrder inOrder = inOrder(o); @@ -622,15 +533,8 @@ public NbpObservable apply(Integer t1) { public void testDelayEmitsEverything() { NbpObservable source = NbpObservable.range(1, 5); NbpObservable delayed = source.delay(500L, TimeUnit.MILLISECONDS, scheduler); - delayed = delayed.doOnEach(new Consumer>>() { - - @Override - public void accept(Try> t1) { - System.out.println(t1); - } - - }); - NbpTestSubscriber NbpObserver = new NbpTestSubscriber(); + delayed = delayed.doOnEach(System.out::println); + NbpTestSubscriber NbpObserver = new NbpTestSubscriber<>(); delayed.subscribe(NbpObserver); // all will be delivered after 500ms since range does not delay between them scheduler.advanceTimeBy(500L, TimeUnit.MILLISECONDS); @@ -639,7 +543,7 @@ public void accept(Try> t1) { @Test public void testBackpressureWithTimedDelay() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpObservable.range(1, Observable.bufferSize() * 2) .delay(100, TimeUnit.MILLISECONDS) .observeOn(Schedulers.computation()) @@ -667,7 +571,7 @@ public Integer apply(Integer t) { @Test public void testBackpressureWithSubscriptionTimedDelay() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpObservable.range(1, Observable.bufferSize() * 2) .delaySubscription(100, TimeUnit.MILLISECONDS) .delay(100, TimeUnit.MILLISECONDS) @@ -696,16 +600,9 @@ public Integer apply(Integer t) { @Test public void testBackpressureWithSelectorDelay() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpObservable.range(1, Observable.bufferSize() * 2) - .delay(new Function>() { - - @Override - public NbpObservable apply(Integer i) { - return NbpObservable.timer(100, TimeUnit.MILLISECONDS); - } - - }) + .delay(i -> NbpObservable.timer(100, TimeUnit.MILLISECONDS)) .observeOn(Schedulers.computation()) .map(new Function() { @@ -731,22 +628,9 @@ public Integer apply(Integer t) { @Test public void testBackpressureWithSelectorDelayAndSubscriptionDelay() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpObservable.range(1, Observable.bufferSize() * 2) - .delay(new Supplier>() { - - @Override - public NbpObservable get() { - return NbpObservable.timer(500, TimeUnit.MILLISECONDS); - } - }, new Function>() { - - @Override - public NbpObservable apply(Integer i) { - return NbpObservable.timer(100, TimeUnit.MILLISECONDS); - } - - }) + .delay(() -> NbpObservable.timer(500, TimeUnit.MILLISECONDS), i -> NbpObservable.timer(100, TimeUnit.MILLISECONDS)) .observeOn(Schedulers.computation()) .map(new Function() { @@ -776,7 +660,7 @@ public void testErrorRunsBeforeOnNext() { NbpPublishSubject ps = NbpPublishSubject.create(); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); ps.delay(1, TimeUnit.SECONDS, test).subscribe(ts); @@ -798,14 +682,9 @@ public void testDelaySupplierSimple() { NbpObservable source = NbpObservable.range(1, 5); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); - source.delaySubscription(new Supplier>() { - @Override - public NbpObservable get() { - return ps; - } - }).subscribe(ts); + source.delaySubscription(() -> ps).subscribe(ts); ts.assertNoValues(); ts.assertNoErrors(); @@ -824,14 +703,9 @@ public void testDelaySupplierCompletes() { NbpObservable source = NbpObservable.range(1, 5); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); - source.delaySubscription(new Supplier>() { - @Override - public NbpObservable get() { - return ps; - } - }).subscribe(ts); + source.delaySubscription(() -> ps).subscribe(ts); ts.assertNoValues(); ts.assertNoErrors(); @@ -851,14 +725,9 @@ public void testDelaySupplierErrors() { NbpObservable source = NbpObservable.range(1, 5); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); - source.delaySubscription(new Supplier>() { - @Override - public NbpObservable get() { - return ps; - } - }).subscribe(ts); + source.delaySubscription(() -> ps).subscribe(ts); ts.assertNoValues(); ts.assertNoErrors(); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDematerializeTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDematerializeTest.java similarity index 98% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDematerializeTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDematerializeTest.java index db62043d16..672493e489 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDematerializeTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDematerializeTest.java @@ -92,7 +92,7 @@ public void testCompletePassThru() { NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); - NbpTestSubscriber ts = new NbpTestSubscriber(NbpObserver); + NbpTestSubscriber ts = new NbpTestSubscriber<>(NbpObserver); dematerialize.subscribe(ts); System.out.println(ts.errors()); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDistinctTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDistinctTest.java similarity index 94% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDistinctTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDistinctTest.java index e68a0f6ea9..e40ad2bf2e 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDistinctTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDistinctTest.java @@ -28,14 +28,11 @@ public class NbpOperatorDistinctTest { NbpSubscriber w; // nulls lead to exceptions - final Function TO_UPPER_WITH_EXCEPTION = new Function() { - @Override - public String apply(String s) { - if (s.equals("x")) { - return "XX"; - } - return s.toUpperCase(); + final Function TO_UPPER_WITH_EXCEPTION = s -> { + if (s.equals("x")) { + return "XX"; } + return s.toUpperCase(); }; @Before diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDistinctUntilChangedTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDistinctUntilChangedTest.java similarity index 94% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDistinctUntilChangedTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDistinctUntilChangedTest.java index 162f486769..334246098b 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDistinctUntilChangedTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDistinctUntilChangedTest.java @@ -29,14 +29,11 @@ public class NbpOperatorDistinctUntilChangedTest { NbpSubscriber w2; // nulls lead to exceptions - final Function TO_UPPER_WITH_EXCEPTION = new Function() { - @Override - public String apply(String s) { - if (s.equals("x")) { - return "xx"; - } - return s.toUpperCase(); + final Function TO_UPPER_WITH_EXCEPTION = s -> { + if (s.equals("x")) { + return "xx"; } + return s.toUpperCase(); }; @Before diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDoOnEachTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDoOnEachTest.java similarity index 79% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDoOnEachTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDoOnEachTest.java index 150859106d..f521b25920 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDoOnEachTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDoOnEachTest.java @@ -62,14 +62,11 @@ public void testDoOnEach() { @Test public void testDoOnEachWithError() { NbpObservable base = NbpObservable.just("one", "fail", "two", "three", "fail"); - NbpObservable errs = base.map(new Function() { - @Override - public String apply(String s) { - if ("fail".equals(s)) { - throw new RuntimeException("Forced Failure"); - } - return s; + NbpObservable errs = base.map(s -> { + if ("fail".equals(s)) { + throw new RuntimeException("Forced Failure"); } + return s; }); NbpObservable doOnEach = errs.doOnEach(sideEffectObserver); @@ -91,12 +88,9 @@ public String apply(String s) { @Test public void testDoOnEachWithErrorInCallback() { NbpObservable base = NbpObservable.just("one", "two", "fail", "three"); - NbpObservable doOnEach = base.doOnNext(new Consumer() { - @Override - public void accept(String s) { - if ("fail".equals(s)) { - throw new RuntimeException("Forced Failure"); - } + NbpObservable doOnEach = base.doOnNext(s -> { + if ("fail".equals(s)) { + throw new RuntimeException("Forced Failure"); } }); @@ -117,19 +111,9 @@ public void testIssue1451Case1() { for (int i=0; i < expectedCount; i++) { NbpObservable .just(Boolean.TRUE, Boolean.FALSE) - .takeWhile(new Predicate() { - @Override - public boolean test(Boolean value) { - return value; - } - }) + .takeWhile(value -> value) .toList() - .doOnNext(new Consumer>() { - @Override - public void accept(List booleans) { - count.incrementAndGet(); - } - }) + .doOnNext(booleans -> count.incrementAndGet()) .subscribe(); } assertEquals(expectedCount, count.get()); @@ -143,19 +127,9 @@ public void testIssue1451Case2() { for (int i=0; i < expectedCount; i++) { NbpObservable .just(Boolean.TRUE, Boolean.FALSE, Boolean.FALSE) - .takeWhile(new Predicate() { - @Override - public boolean test(Boolean value) { - return value; - } - }) + .takeWhile(value -> value) .toList() - .doOnNext(new Consumer>() { - @Override - public void accept(List booleans) { - count.incrementAndGet(); - } - }) + .doOnNext(booleans -> count.incrementAndGet()) .subscribe(); } assertEquals(expectedCount, count.get()); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDoOnSubscribeTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDoOnSubscribeTest.java similarity index 70% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDoOnSubscribeTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDoOnSubscribeTest.java index 12432c66a9..b1c9510b9a 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDoOnSubscribeTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDoOnSubscribeTest.java @@ -30,12 +30,7 @@ public class NbpOperatorDoOnSubscribeTest { @Test public void testDoOnSubscribe() throws Exception { final AtomicInteger count = new AtomicInteger(); - NbpObservable o = NbpObservable.just(1).doOnSubscribe(new Consumer() { - @Override - public void accept(Disposable s) { - count.incrementAndGet(); - } - }); + NbpObservable o = NbpObservable.just(1).doOnSubscribe(s -> count.incrementAndGet()); o.subscribe(); o.subscribe(); @@ -46,17 +41,10 @@ public void accept(Disposable s) { @Test public void testDoOnSubscribe2() throws Exception { final AtomicInteger count = new AtomicInteger(); - NbpObservable o = NbpObservable.just(1).doOnSubscribe(new Consumer() { - @Override - public void accept(Disposable s) { - count.incrementAndGet(); - } - }).take(1).doOnSubscribe(new Consumer() { - @Override - public void accept(Disposable s) { - count.incrementAndGet(); - } - }); + NbpObservable o = NbpObservable.just(1) + .doOnSubscribe(s -> count.incrementAndGet()) + .take(1) + .doOnSubscribe(s -> count.incrementAndGet()); o.subscribe(); assertEquals(2, count.get()); @@ -67,7 +55,7 @@ public void testDoOnUnSubscribeWorksWithRefCount() throws Exception { final AtomicInteger onSubscribed = new AtomicInteger(); final AtomicInteger countBefore = new AtomicInteger(); final AtomicInteger countAfter = new AtomicInteger(); - final AtomicReference> sref = new AtomicReference>(); + final AtomicReference> sref = new AtomicReference<>(); NbpObservable o = NbpObservable.create(new NbpOnSubscribe() { @Override @@ -77,18 +65,10 @@ public void accept(NbpSubscriber s) { sref.set(s); } - }).doOnSubscribe(new Consumer() { - @Override - public void accept(Disposable s) { - countBefore.incrementAndGet(); - } - }).publish().refCount() - .doOnSubscribe(new Consumer() { - @Override - public void accept(Disposable s) { - countAfter.incrementAndGet(); - } - }); + }).doOnSubscribe(s -> countBefore.incrementAndGet()) + .publish() + .refCount() + .doOnSubscribe(s -> countAfter.incrementAndGet()); o.subscribe(); o.subscribe(); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDoOnUnsubscribeTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDoOnUnsubscribeTest.java similarity index 66% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDoOnUnsubscribeTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDoOnUnsubscribeTest.java index 20385b5b41..52e48391e9 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDoOnUnsubscribeTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorDoOnUnsubscribeTest.java @@ -41,36 +41,27 @@ public void testDoOnUnsubscribe() throws Exception { // The stream needs to be infinite to ensure the stream does not terminate // before it is unsubscribed .interval(50, TimeUnit.MILLISECONDS) - .doOnCancel(new Runnable() { - @Override - public void run() { - // Test that upper stream will be notified for un-subscription - // from a child NbpSubscriber - upperLatch.countDown(); - upperCount.incrementAndGet(); - } + .doOnCancel(() -> { + // Test that upper stream will be notified for un-subscription + // from a child NbpSubscriber + upperLatch.countDown(); + upperCount.incrementAndGet(); }) - .doOnNext(new Consumer() { - @Override - public void accept(Long aLong) { - // Ensure there is at least some onNext events before un-subscription happens - onNextLatch.countDown(); - } + .doOnNext(aLong -> { + // Ensure there is at least some onNext events before un-subscription happens + onNextLatch.countDown(); }) - .doOnCancel(new Runnable() { - @Override - public void run() { - // Test that lower stream will be notified for a direct un-subscription - lowerLatch.countDown(); - lowerCount.incrementAndGet(); - } + .doOnCancel(() -> { + // Test that lower stream will be notified for a direct un-subscription + lowerLatch.countDown(); + lowerCount.incrementAndGet(); }); - List subscriptions = new ArrayList(); - List> subscribers = new ArrayList>(); + List subscriptions = new ArrayList<>(); + List> subscribers = new ArrayList<>(); for (int i = 0; i < subCount; ++i) { - NbpTestSubscriber NbpSubscriber = new NbpTestSubscriber(); + NbpTestSubscriber NbpSubscriber = new NbpTestSubscriber<>(); subscriptions.add(NbpSubscriber); longs.subscribe(NbpSubscriber); subscribers.add(NbpSubscriber); @@ -103,37 +94,28 @@ public void testDoOnUnSubscribeWorksWithRefCount() throws Exception { // The stream needs to be infinite to ensure the stream does not terminate // before it is unsubscribed .interval(50, TimeUnit.MILLISECONDS) - .doOnCancel(new Runnable() { - @Override - public void run() { - // Test that upper stream will be notified for un-subscription - upperLatch.countDown(); - upperCount.incrementAndGet(); - } + .doOnCancel(() -> { + // Test that upper stream will be notified for un-subscription + upperLatch.countDown(); + upperCount.incrementAndGet(); }) - .doOnNext(new Consumer() { - @Override - public void accept(Long aLong) { - // Ensure there is at least some onNext events before un-subscription happens - onNextLatch.countDown(); - } + .doOnNext(aLong -> { + // Ensure there is at least some onNext events before un-subscription happens + onNextLatch.countDown(); }) - .doOnCancel(new Runnable() { - @Override - public void run() { - // Test that lower stream will be notified for un-subscription - lowerLatch.countDown(); - lowerCount.incrementAndGet(); - } + .doOnCancel(() -> { + // Test that lower stream will be notified for un-subscription + lowerLatch.countDown(); + lowerCount.incrementAndGet(); }) .publish() .refCount(); - List subscriptions = new ArrayList(); - List> subscribers = new ArrayList>(); + List subscriptions = new ArrayList<>(); + List> subscribers = new ArrayList<>(); for (int i = 0; i < subCount; ++i) { - NbpTestSubscriber NbpSubscriber = new NbpTestSubscriber(); + NbpTestSubscriber NbpSubscriber = new NbpTestSubscriber<>(); longs.subscribe(NbpSubscriber); subscriptions.add(NbpSubscriber); subscribers.add(NbpSubscriber); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorElementAtTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorElementAtTest.java similarity index 100% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorElementAtTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorElementAtTest.java diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorFilterTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorFilterTest.java similarity index 91% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorFilterTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorFilterTest.java index d3e931fa6b..791ccaf975 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorFilterTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorFilterTest.java @@ -28,13 +28,7 @@ public class NbpOperatorFilterTest { @Test public void testFilter() { NbpObservable w = NbpObservable.just("one", "two", "three"); - NbpObservable NbpObservable = w.filter(new Predicate() { - - @Override - public boolean test(String t1) { - return t1.equals("two"); - } - }); + NbpObservable NbpObservable = w.filter(t1 -> t1.equals("two")); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorFinallyTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorFinallyTest.java similarity index 100% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorFinallyTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorFinallyTest.java diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorFirstTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorFirstTest.java similarity index 84% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorFirstTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorFirstTest.java index 1df49e7b32..3fef666f30 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorFirstTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorFirstTest.java @@ -29,12 +29,7 @@ public class NbpOperatorFirstTest { NbpSubscriber w; - private static final Predicate IS_D = new Predicate() { - @Override - public boolean test(String value) { - return "d".equals(value); - } - }; + private static final Predicate IS_D = "d"::equals; @Before public void before() { @@ -127,12 +122,7 @@ public void testFirstWithEmpty() { @Test public void testFirstWithPredicate() { NbpObservable o = NbpObservable.just(1, 2, 3, 4, 5, 6) - .filter(new Predicate() { - @Override - public boolean test(Integer t1) { - return t1 % 2 == 0; - } - }) + .filter(t1 -> t1 % 2 == 0) .first(); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); @@ -147,12 +137,7 @@ public boolean test(Integer t1) { @Test public void testFirstWithPredicateAndOneElement() { NbpObservable o = NbpObservable.just(1, 2) - .filter(new Predicate() { - @Override - public boolean test(Integer t1) { - return t1 % 2 == 0; - } - }) + .filter(t1 -> t1 % 2 == 0) .first(); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); @@ -167,12 +152,7 @@ public boolean test(Integer t1) { @Test public void testFirstWithPredicateAndEmpty() { NbpObservable o = NbpObservable.just(1) - .filter(new Predicate() { - @Override - public boolean test(Integer t1) { - return t1 % 2 == 0; - } - }) + .filter(t1 -> t1 % 2 == 0) .first(); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); @@ -228,12 +208,7 @@ public void testFirstOrDefaultWithEmpty() { @Test public void testFirstOrDefaultWithPredicate() { NbpObservable o = NbpObservable.just(1, 2, 3, 4, 5, 6) - .filter(new Predicate() { - @Override - public boolean test(Integer t1) { - return t1 % 2 == 0; - } - }) + .filter(t1 -> t1 % 2 == 0) .first(8); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); @@ -248,12 +223,7 @@ public boolean test(Integer t1) { @Test public void testFirstOrDefaultWithPredicateAndOneElement() { NbpObservable o = NbpObservable.just(1, 2) - .filter(new Predicate() { - @Override - public boolean test(Integer t1) { - return t1 % 2 == 0; - } - }) + .filter(t1 -> t1 % 2 == 0) .first(4); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); @@ -268,12 +238,7 @@ public boolean test(Integer t1) { @Test public void testFirstOrDefaultWithPredicateAndEmpty() { NbpObservable o = NbpObservable.just(1) - .filter(new Predicate() { - @Override - public boolean test(Integer t1) { - return t1 % 2 == 0; - } - }) + .filter(t1 -> t1 % 2 == 0) .first(2); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorFlatMapTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorFlatMapTest.java similarity index 72% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorFlatMapTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorFlatMapTest.java index bc00b25f4a..6e97fd3f5d 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorFlatMapTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorFlatMapTest.java @@ -38,19 +38,8 @@ public void testNormal() { final List list = Arrays.asList(1, 2, 3); - Function> func = new Function>() { - @Override - public List apply(Integer t1) { - return list; - } - }; - BiFunction resFunc = new BiFunction() { - - @Override - public Integer apply(Integer t1, Integer t2) { - return t1 | t2; - } - }; + final Function> func = t1 -> list; + final BiFunction resFunc = (t1, t2) -> t1 | t2; List source = Arrays.asList(16, 32, 64); @@ -69,19 +58,10 @@ public Integer apply(Integer t1, Integer t2) { public void testCollectionFunctionThrows() { NbpSubscriber o = TestHelper.mockNbpSubscriber(); - Function> func = new Function>() { - @Override - public List apply(Integer t1) { - throw new TestException(); - } - }; - BiFunction resFunc = new BiFunction() { - - @Override - public Integer apply(Integer t1, Integer t2) { - return t1 | t2; - } + Function> func = t1 -> { + throw new TestException(); }; + BiFunction resFunc = (t1, t2) -> t1 | t2; List source = Arrays.asList(16, 32, 64); @@ -98,18 +78,9 @@ public void testResultFunctionThrows() { final List list = Arrays.asList(1, 2, 3); - Function> func = new Function>() { - @Override - public List apply(Integer t1) { - return list; - } - }; - BiFunction resFunc = new BiFunction() { - - @Override - public Integer apply(Integer t1, Integer t2) { - throw new TestException(); - } + Function> func = t1 -> list; + BiFunction resFunc = (t1, t2) -> { + throw new TestException(); }; List source = Arrays.asList(16, 32, 64); @@ -125,19 +96,8 @@ public Integer apply(Integer t1, Integer t2) { public void testMergeError() { NbpSubscriber o = TestHelper.mockNbpSubscriber(); - Function> func = new Function>() { - @Override - public NbpObservable apply(Integer t1) { - return NbpObservable.error(new TestException()); - } - }; - BiFunction resFunc = new BiFunction() { - - @Override - public Integer apply(Integer t1, Integer t2) { - return t1 | t2; - } - }; + Function> func = t1 -> NbpObservable.error(new TestException()); + BiFunction resFunc = (t1, t2) -> t1 | t2; List source = Arrays.asList(16, 32, 64); @@ -149,23 +109,11 @@ public Integer apply(Integer t1, Integer t2) { } Function just(final R value) { - return new Function() { - - @Override - public R apply(T t1) { - return value; - } - }; + return t1 -> value; } Supplier just0(final R value) { - return new Supplier() { - - @Override - public R get() { - return value; - } - }; + return () -> value; } @Test @@ -197,9 +145,9 @@ public void testFlatMapTransformsException() { NbpObservable onError = NbpObservable.fromIterable(Arrays.asList(5)); NbpObservable source = NbpObservable.concat( - NbpObservable.fromIterable(Arrays.asList(10, 20, 30)), - NbpObservable. error(new RuntimeException("Forced failure!")) - ); + NbpObservable.fromIterable(Arrays.asList(10, 20, 30)), + NbpObservable.error(new RuntimeException("Forced failure!")) + ); NbpSubscriber o = TestHelper.mockNbpSubscriber(); @@ -217,20 +165,14 @@ NbpObservable. error(new RuntimeException("Forced failure!")) } Supplier funcThrow0(R r) { - return new Supplier() { - @Override - public R get() { - throw new TestException(); - } + return () -> { + throw new TestException(); }; } Function funcThrow(T t, R r) { - return new Function() { - @Override - public R apply(T t) { - throw new TestException(); - } + return t1 -> { + throw new TestException(); }; } @@ -273,7 +215,7 @@ public void testFlatMapTransformsOnCompletedFuncThrows() { NbpObservable onCompleted = NbpObservable.fromIterable(Arrays.asList(4)); NbpObservable onError = NbpObservable.fromIterable(Arrays.asList(5)); - NbpObservable source = NbpObservable.fromIterable(Arrays. asList()); + NbpObservable source = NbpObservable.fromIterable(Arrays.asList()); NbpSubscriber o = TestHelper.mockNbpSubscriber(); @@ -302,22 +244,16 @@ public void testFlatMapTransformsMergeException() { } private static NbpObservable composer(NbpObservable source, final AtomicInteger subscriptionCount, final int m) { - return source.doOnSubscribe(new Consumer() { - @Override - public void accept(Disposable s) { - int n = subscriptionCount.getAndIncrement(); - if (n >= m) { - Assert.fail("Too many subscriptions! " + (n + 1)); - } - } - }).doOnComplete(new Runnable() { - @Override - public void run() { - int n = subscriptionCount.decrementAndGet(); - if (n < 0) { - Assert.fail("Too many unsubscriptions! " + (n - 1)); - } - } + return source.doOnSubscribe(s -> { + int n = subscriptionCount.getAndIncrement(); + if (n >= m) { + Assert.fail("Too many subscriptions! " + (n + 1)); + } + }).doOnComplete(() -> { + int n = subscriptionCount.decrementAndGet(); + if (n < 0) { + Assert.fail("Too many unsubscriptions! " + (n - 1)); + } }); } @@ -326,22 +262,19 @@ public void testFlatMapMaxConcurrent() { final int m = 4; final AtomicInteger subscriptionCount = new AtomicInteger(); NbpObservable source = NbpObservable.range(1, 10) - .flatMap(new Function>() { - @Override - public NbpObservable apply(Integer t1) { - return composer(NbpObservable.range(t1 * 10, 2), subscriptionCount, m) - .subscribeOn(Schedulers.computation()); - } + .flatMap(t1 -> { + return composer(NbpObservable.range(t1 * 10, 2), subscriptionCount, m) + .subscribeOn(Schedulers.computation()); }, m); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); source.subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); - Set expected = new HashSet(Arrays.asList( - 10, 11, 20, 21, 30, 31, 40, 41, 50, 51, 60, 61, 70, 71, 80, 81, 90, 91, 100, 101 + Set expected = new HashSet<>(Arrays.asList( + 10, 11, 20, 21, 30, 31, 40, 41, 50, 51, 60, 61, 70, 71, 80, 81, 90, 91, 100, 101 )); Assert.assertEquals(expected.size(), ts.valueCount()); Assert.assertTrue(expected.containsAll(ts.values())); @@ -351,28 +284,20 @@ public void testFlatMapSelectorMaxConcurrent() { final int m = 4; final AtomicInteger subscriptionCount = new AtomicInteger(); NbpObservable source = NbpObservable.range(1, 10) - .flatMap(new Function>() { - @Override - public NbpObservable apply(Integer t1) { + .flatMap(t1 -> { return composer(NbpObservable.range(t1 * 10, 2), subscriptionCount, m) .subscribeOn(Schedulers.computation()); - } - }, new BiFunction() { - @Override - public Integer apply(Integer t1, Integer t2) { - return t1 * 1000 + t2; - } - }, m); + }, (t1, t2) -> t1 * 1000 + t2, m); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); source.subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); - Set expected = new HashSet(Arrays.asList( - 1010, 1011, 2020, 2021, 3030, 3031, 4040, 4041, 5050, 5051, - 6060, 6061, 7070, 7071, 8080, 8081, 9090, 9091, 10100, 10101 + Set expected = new HashSet<>(Arrays.asList( + 1010, 1011, 2020, 2021, 3030, 3031, 4040, 4041, 5050, 5051, + 6060, 6061, 7070, 7071, 8080, 8081, 9090, 9091, 10100, 10101 )); Assert.assertEquals(expected.size(), ts.valueCount()); System.out.println("--> testFlatMapSelectorMaxConcurrent: " + ts.values()); @@ -410,7 +335,7 @@ public void testFlatMapTransformsMaxConcurrentNormal() { NbpObservable source = NbpObservable.fromIterable(Arrays.asList(10, 20, 30)); NbpSubscriber o = TestHelper.mockNbpSubscriber(); - NbpTestSubscriber ts = new NbpTestSubscriber(o); + NbpTestSubscriber ts = new NbpTestSubscriber<>(o); Function> just = just(onError); source.flatMap(just(onNext), just, just0(onCompleted), m).subscribe(ts); @@ -436,14 +361,9 @@ public void flatMapRangeAsyncLoop() { if (i % 10 == 0) { System.out.println("flatMapRangeAsyncLoop > " + i); } - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpObservable.range(0, 1000) - .flatMap(new Function>() { - @Override - public NbpObservable apply(Integer t) { - return NbpObservable.just(t); - } - }) + .flatMap(NbpObservable::just) .observeOn(Schedulers.computation()) .subscribe(ts); @@ -473,7 +393,7 @@ public void flatMapRangeMixedAsyncLoop() { if (i % 10 == 0) { System.out.println("flatMapRangeAsyncLoop > " + i); } - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpObservable.range(0, 1000) .flatMap(new Function>() { final Random rnd = new Random(); @@ -497,7 +417,7 @@ public NbpObservable apply(Integer t) { ts.assertNoErrors(); List list = ts.values(); if (list.size() < 1000) { - Set set = new HashSet(list); + Set set = new HashSet<>(list); for (int j = 0; j < 1000; j++) { if (!set.contains(j)) { System.out.println(j + " missing"); @@ -511,14 +431,9 @@ public NbpObservable apply(Integer t) { @Test public void flatMapIntPassthruAsync() { for (int i = 0;i < 1000; i++) { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); - NbpObservable.range(1, 1000).flatMap(new Function>() { - @Override - public NbpObservable apply(Integer t) { - return NbpObservable.just(1).subscribeOn(Schedulers.computation()); - } - }).subscribe(ts); + NbpObservable.range(1, 1000).flatMap(t -> NbpObservable.just(1).subscribeOn(Schedulers.computation())).subscribe(ts); ts.awaitTerminalEvent(5, TimeUnit.SECONDS); ts.assertNoErrors(); @@ -529,14 +444,9 @@ public NbpObservable apply(Integer t) { @Test public void flatMapTwoNestedSync() { for (final int n : new int[] { 1, 1000, 1000000 }) { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); - NbpObservable.just(1, 2).flatMap(new Function>() { - @Override - public NbpObservable apply(Integer t) { - return NbpObservable.range(1, n); - } - }).subscribe(ts); + NbpObservable.just(1, 2).flatMap(t -> NbpObservable.range(1, n)).subscribe(ts); System.out.println("flatMapTwoNestedSync >> @ " + n); ts.assertNoErrors(); diff --git a/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorGroupByTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorGroupByTest.java new file mode 100644 index 0000000000..81fb4d9ae8 --- /dev/null +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorGroupByTest.java @@ -0,0 +1,925 @@ +/** + * Copyright 2016 Netflix, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in + * compliance with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is + * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See + * the License for the specific language governing permissions and limitations under the License. + */ + +package io.reactivex.internal.operators.nbp; + +import static org.junit.Assert.*; +import static org.mockito.Matchers.*; +import static org.mockito.Mockito.*; + +import java.util.*; +import java.util.concurrent.*; +import java.util.concurrent.atomic.*; + +import org.junit.Test; +import org.mockito.Matchers; + +import io.reactivex.*; +import io.reactivex.NbpObservable.*; +import io.reactivex.disposables.*; +import io.reactivex.exceptions.TestException; +import io.reactivex.functions.*; +import io.reactivex.internal.disposables.EmptyDisposable; +import io.reactivex.observables.nbp.NbpGroupedObservable; +import io.reactivex.schedulers.Schedulers; +import io.reactivex.subscribers.nbp.NbpTestSubscriber; +import io.reactivex.Optional; + +public class NbpOperatorGroupByTest { + + final Function length = String::length; + + @Test + public void testGroupBy() { + NbpObservable source = NbpObservable.just("one", "two", "three", "four", "five", "six"); + NbpObservable> grouped = source.groupBy(length); + + Map> map = toMap(grouped); + + assertEquals(3, map.size()); + assertArrayEquals(Arrays.asList("one", "two", "six").toArray(), map.get(3).toArray()); + assertArrayEquals(Arrays.asList("four", "five").toArray(), map.get(4).toArray()); + assertArrayEquals(Arrays.asList("three").toArray(), map.get(5).toArray()); + } + + @Test + public void testGroupByWithElementSelector() { + NbpObservable source = NbpObservable.just("one", "two", "three", "four", "five", "six"); + NbpObservable> grouped = source.groupBy(length, length); + + Map> map = toMap(grouped); + + assertEquals(3, map.size()); + assertArrayEquals(Arrays.asList(3, 3, 3).toArray(), map.get(3).toArray()); + assertArrayEquals(Arrays.asList(4, 4).toArray(), map.get(4).toArray()); + assertArrayEquals(Arrays.asList(5).toArray(), map.get(5).toArray()); + } + + @Test + public void testGroupByWithElementSelector2() { + NbpObservable source = NbpObservable.just("one", "two", "three", "four", "five", "six"); + NbpObservable> grouped = source.groupBy(length, length); + + Map> map = toMap(grouped); + + assertEquals(3, map.size()); + assertArrayEquals(Arrays.asList(3, 3, 3).toArray(), map.get(3).toArray()); + assertArrayEquals(Arrays.asList(4, 4).toArray(), map.get(4).toArray()); + assertArrayEquals(Arrays.asList(5).toArray(), map.get(5).toArray()); + } + + @Test + public void testEmpty() { + NbpObservable source = NbpObservable.empty(); + NbpObservable> grouped = source.groupBy(length); + + Map> map = toMap(grouped); + + assertTrue(map.isEmpty()); + } + + @Test + public void testError() { + NbpObservable sourceStrings = NbpObservable.just("one", "two", "three", "four", "five", "six"); + NbpObservable errorSource = NbpObservable.error(new RuntimeException("forced failure")); + NbpObservable source = NbpObservable.concat(sourceStrings, errorSource); + + NbpObservable> grouped = source.groupBy(length); + + final AtomicInteger groupCounter = new AtomicInteger(); + final AtomicInteger eventCounter = new AtomicInteger(); + final AtomicReference error = new AtomicReference<>(); + + grouped.flatMap(o -> { + groupCounter.incrementAndGet(); + return o.map(v -> "Event => key: " + o.getKey() + " value: " + v); + }).subscribe(new NbpObserver() { + + @Override + public void onComplete() { + + } + + @Override + public void onError(Throwable e) { + e.printStackTrace(); + error.set(e); + } + + @Override + public void onNext(String v) { + eventCounter.incrementAndGet(); + System.out.println(v); + + } + }); + + assertEquals(3, groupCounter.get()); + assertEquals(6, eventCounter.get()); + assertNotNull(error.get()); + } + + private static Map> toMap(NbpObservable> NbpObservable) { + + final ConcurrentHashMap> result = new ConcurrentHashMap<>(); + + NbpObservable.toBlocking().forEach(o -> { + result.put(o.getKey(), new ConcurrentLinkedQueue<>()); + o.subscribe(v -> { + result.get(o.getKey()).add(v); + }); + }); + + return result; + } + + /** + * Assert that only a single subscription to a stream occurs and that all events are received. + * + * @throws Throwable + */ + @Test + public void testGroupedEventStream() throws Throwable { + + final AtomicInteger eventCounter = new AtomicInteger(); + final AtomicInteger subscribeCounter = new AtomicInteger(); + final AtomicInteger groupCounter = new AtomicInteger(); + final CountDownLatch latch = new CountDownLatch(1); + final int count = 100; + final int groupCount = 2; + + NbpObservable es = NbpObservable.create(s -> { + s.onSubscribe(EmptyDisposable.INSTANCE); + System.out.println("*** Subscribing to EventStream ***"); + subscribeCounter.incrementAndGet(); + new Thread(() -> { + for (int i = 0; i < count; i++) { + Event e = new Event(); + e.source = i % groupCount; + e.message = "Event-" + i; + s.onNext(e); + } + s.onComplete(); + }).start(); + }); + + es.groupBy(e -> e.source).flatMap(eventGroupedObservable -> { + System.out.println("NbpGroupedObservable Key: " + eventGroupedObservable.getKey()); + groupCounter.incrementAndGet(); + + return eventGroupedObservable.map(event -> "Source: " + event.source + " Message: " + event.message); + + }).subscribe(new NbpObserver() { + + @Override + public void onComplete() { + latch.countDown(); + } + + @Override + public void onError(Throwable e) { + e.printStackTrace(); + latch.countDown(); + } + + @Override + public void onNext(String outputMessage) { + System.out.println(outputMessage); + eventCounter.incrementAndGet(); + } + }); + + latch.await(5000, TimeUnit.MILLISECONDS); + assertEquals(1, subscribeCounter.get()); + assertEquals(groupCount, groupCounter.get()); + assertEquals(count, eventCounter.get()); + + } + + /* + * We will only take 1 group with 20 events from it and then unsubscribe. + */ + @Test + public void testUnsubscribeOnNestedTakeAndSyncInfiniteStream() throws InterruptedException { + final AtomicInteger subscribeCounter = new AtomicInteger(); + final AtomicInteger sentEventCounter = new AtomicInteger(); + doTestUnsubscribeOnNestedTakeAndAsyncInfiniteStream(SYNC_INFINITE_OBSERVABLE_OF_EVENT(2, subscribeCounter, sentEventCounter), subscribeCounter); + Thread.sleep(500); + assertEquals(39, sentEventCounter.get()); + } + + /* + * We will only take 1 group with 20 events from it and then unsubscribe. + */ + @Test + public void testUnsubscribeOnNestedTakeAndAsyncInfiniteStream() throws InterruptedException { + final AtomicInteger subscribeCounter = new AtomicInteger(); + final AtomicInteger sentEventCounter = new AtomicInteger(); + doTestUnsubscribeOnNestedTakeAndAsyncInfiniteStream(ASYNC_INFINITE_OBSERVABLE_OF_EVENT(2, subscribeCounter, sentEventCounter), subscribeCounter); + Thread.sleep(500); + assertEquals(39, sentEventCounter.get()); + } + + private void doTestUnsubscribeOnNestedTakeAndAsyncInfiniteStream(NbpObservable es, AtomicInteger subscribeCounter) throws InterruptedException { + final AtomicInteger eventCounter = new AtomicInteger(); + final AtomicInteger groupCounter = new AtomicInteger(); + final CountDownLatch latch = new CountDownLatch(1); + + es.groupBy(e -> e.source) + .take(1) // we want only the first group + .flatMap(eventGroupedObservable -> { + System.out.println("testUnsubscribe => NbpGroupedObservable Key: " + eventGroupedObservable.getKey()); + groupCounter.incrementAndGet(); + + return eventGroupedObservable + .take(20) // limit to only 20 events on this group + .map(event -> "testUnsubscribe => Source: " + event.source + " Message: " + event.message); + + }).subscribe(new NbpObserver() { + + @Override + public void onComplete() { + latch.countDown(); + } + + @Override + public void onError(Throwable e) { + e.printStackTrace(); + latch.countDown(); + } + + @Override + public void onNext(String outputMessage) { + System.out.println(outputMessage); + eventCounter.incrementAndGet(); + } + }); + + if (!latch.await(2000, TimeUnit.MILLISECONDS)) { + fail("timed out so likely did not unsubscribe correctly"); + } + assertEquals(1, subscribeCounter.get()); + assertEquals(1, groupCounter.get()); + assertEquals(20, eventCounter.get()); + // sentEvents will go until 'eventCounter' hits 20 and then unsubscribes + // which means it will also send (but ignore) the 19/20 events for the other group + // It will not however send all 100 events. + } + + @Test + public void testUnsubscribeViaTakeOnGroupThenMergeAndTake() { + final AtomicInteger subscribeCounter = new AtomicInteger(); + final AtomicInteger sentEventCounter = new AtomicInteger(); + final AtomicInteger eventCounter = new AtomicInteger(); + + SYNC_INFINITE_OBSERVABLE_OF_EVENT(4, subscribeCounter, sentEventCounter) + .groupBy(e -> e.source) + // take 2 of the 4 groups + .take(2) + .flatMap(eventGroupedObservable -> eventGroupedObservable + .map(event -> "testUnsubscribe => Source: " + event.source + " Message: " + event.message)) + .take(30).subscribe(s -> { + eventCounter.incrementAndGet(); + System.out.println("=> " + s); + }); + + assertEquals(30, eventCounter.get()); + // we should send 28 additional events that are filtered out as they are in the groups we skip + assertEquals(58, sentEventCounter.get()); + } + + @Test + public void testUnsubscribeViaTakeOnGroupThenTakeOnInner() { + final AtomicInteger subscribeCounter = new AtomicInteger(); + final AtomicInteger sentEventCounter = new AtomicInteger(); + final AtomicInteger eventCounter = new AtomicInteger(); + + SYNC_INFINITE_OBSERVABLE_OF_EVENT(4, subscribeCounter, sentEventCounter) + .groupBy(e -> e.source) + // take 2 of the 4 groups + .take(2) + .flatMap(eventGroupedObservable -> { + int numToTake = 0; + if (eventGroupedObservable.getKey() == 1) { + numToTake = 10; + } else if (eventGroupedObservable.getKey() == 2) { + numToTake = 5; + } + return eventGroupedObservable + .take(numToTake) + .map(event -> "testUnsubscribe => Source: " + event.source + " Message: " + event.message); + + }) + .subscribe(s -> { + eventCounter.incrementAndGet(); + System.out.println("=> " + s); + }); + + assertEquals(15, eventCounter.get()); + // we should send 22 additional events that are filtered out as they are skipped while taking the 15 we want + assertEquals(37, sentEventCounter.get()); + } + + @Test + public void testStaggeredCompletion() throws InterruptedException { + final AtomicInteger eventCounter = new AtomicInteger(); + final CountDownLatch latch = new CountDownLatch(1); + NbpObservable.range(0, 100) + .groupBy(i -> i % 2) + .flatMap(group -> { + if (group.getKey() == 0) { + return group.delay(100, TimeUnit.MILLISECONDS).map(t -> t * 10); + } else { + return group; + } + }) + .subscribe(new NbpObserver() { + + @Override + public void onComplete() { + System.out.println("=> onCompleted"); + latch.countDown(); + } + + @Override + public void onError(Throwable e) { + e.printStackTrace(); + latch.countDown(); + } + + @Override + public void onNext(Integer s) { + eventCounter.incrementAndGet(); + System.out.println("=> " + s); + } + }); + + if (!latch.await(3000, TimeUnit.MILLISECONDS)) { + fail("timed out"); + } + + assertEquals(100, eventCounter.get()); + } + + @Test(timeout = 1000) + public void testCompletionIfInnerNotSubscribed() throws InterruptedException { + final CountDownLatch latch = new CountDownLatch(1); + final AtomicInteger eventCounter = new AtomicInteger(); + NbpObservable.range(0, 100) + .groupBy(i -> i % 2) + .subscribe(new NbpObserver>() { + + @Override + public void onComplete() { + latch.countDown(); + } + + @Override + public void onError(Throwable e) { + e.printStackTrace(); + latch.countDown(); + } + + @Override + public void onNext(NbpGroupedObservable s) { + eventCounter.incrementAndGet(); + System.out.println("=> " + s); + } + }); + if (!latch.await(500, TimeUnit.MILLISECONDS)) { + fail("timed out - never got completion"); + } + assertEquals(2, eventCounter.get()); + } + + @Test + public void testIgnoringGroups() { + final AtomicInteger subscribeCounter = new AtomicInteger(); + final AtomicInteger sentEventCounter = new AtomicInteger(); + final AtomicInteger eventCounter = new AtomicInteger(); + + SYNC_INFINITE_OBSERVABLE_OF_EVENT(4, subscribeCounter, sentEventCounter) + .groupBy(e -> e.source) + .flatMap(eventGroupedObservable -> { + NbpObservable eventStream = eventGroupedObservable; + if (eventGroupedObservable.getKey() >= 2) { + // filter these + eventStream = eventGroupedObservable.filter(t1 -> false); + } + + return eventStream + .map(event -> "testUnsubscribe => Source: " + event.source + " Message: " + event.message); + + }) + .take(30).subscribe(s -> { + eventCounter.incrementAndGet(); + System.out.println("=> " + s); + }); + + assertEquals(30, eventCounter.get()); + // we should send 30 additional events that are filtered out as they are in the groups we skip + assertEquals(60, sentEventCounter.get()); + } + + @Test + public void testFirstGroupsCompleteAndParentSlowToThenEmitFinalGroupsAndThenComplete() throws InterruptedException { + final CountDownLatch first = new CountDownLatch(2); // there are two groups to first complete + final ArrayList results = new ArrayList<>(); + NbpObservable.create(sub -> { + sub.onSubscribe(EmptyDisposable.INSTANCE); + sub.onNext(1); + sub.onNext(2); + sub.onNext(1); + sub.onNext(2); + try { + first.await(); + } catch (InterruptedException e) { + sub.onError(e); + return; + } + sub.onNext(3); + sub.onNext(3); + sub.onComplete(); + }).groupBy(t -> t).flatMap(group -> { + if (group.getKey() < 3) { + return group.map(t1 -> "first groups: " + t1) + // must take(2) so an onCompleted + unsubscribe happens on these first 2 groups + .take(2).doOnComplete(first::countDown); + } else { + return group.map(t1 -> "last group: " + t1); + } + }).toBlocking().forEach(results::add); + + System.out.println("Results: " + results); + assertEquals(6, results.size()); + } + + @Test + public void testFirstGroupsCompleteAndParentSlowToThenEmitFinalGroupsWhichThenSubscribesOnAndDelaysAndThenCompletes() throws InterruptedException { + System.err.println("----------------------------------------------------------------------------------------------"); + final CountDownLatch first = new CountDownLatch(2); // there are two groups to first complete + final ArrayList results = new ArrayList<>(); + NbpObservable.create(sub -> { + sub.onSubscribe(EmptyDisposable.INSTANCE); + sub.onNext(1); + sub.onNext(2); + sub.onNext(1); + sub.onNext(2); + try { + first.await(); + } catch (InterruptedException e) { + sub.onError(e); + return; + } + sub.onNext(3); + sub.onNext(3); + sub.onComplete(); + }).groupBy(t -> t).flatMap(group -> { + if (group.getKey() < 3) { + return group.map(t1 -> "first groups: " + t1) + // must take(2) so an onCompleted + unsubscribe happens on these first 2 groups + .take(2).doOnComplete(first::countDown); + } else { + return group.subscribeOn(Schedulers.newThread()) + .delay(400, TimeUnit.MILLISECONDS) + .map(t1 -> "last group: " + t1) + .doOnEach(t1 -> System.err.println("subscribeOn notification => " + t1)); + } + }).doOnEach(t1 -> { + System.err.println("outer notification => " + t1); + }).toBlocking().forEach(results::add); + + System.out.println("Results: " + results); + assertEquals(6, results.size()); + } + + @Test + public void testFirstGroupsCompleteAndParentSlowToThenEmitFinalGroupsWhichThenObservesOnAndDelaysAndThenCompletes() throws InterruptedException { + final CountDownLatch first = new CountDownLatch(2); // there are two groups to first complete + final ArrayList results = new ArrayList<>(); + NbpObservable.create(sub -> { + sub.onSubscribe(EmptyDisposable.INSTANCE); + sub.onNext(1); + sub.onNext(2); + sub.onNext(1); + sub.onNext(2); + try { + first.await(); + } catch (InterruptedException e) { + sub.onError(e); + return; + } + sub.onNext(3); + sub.onNext(3); + sub.onComplete(); + }).groupBy(t -> t).flatMap(group -> { + if (group.getKey() < 3) { + return group.map(t1 -> "first groups: " + t1) + // must take(2) so an onCompleted + unsubscribe happens on these first 2 groups + .take(2).doOnComplete(first::countDown); + } else { + return group.observeOn(Schedulers.newThread()).delay(400, TimeUnit.MILLISECONDS).map(t1 -> "last group: " + t1); + } + }).toBlocking().forEach(results::add); + + System.out.println("Results: " + results); + assertEquals(6, results.size()); + } + + @Test + public void testGroupsWithNestedSubscribeOn() throws InterruptedException { + final ArrayList results = new ArrayList<>(); + NbpObservable.create(sub -> { + sub.onSubscribe(EmptyDisposable.INSTANCE); + sub.onNext(1); + sub.onNext(2); + sub.onNext(1); + sub.onNext(2); + sub.onComplete(); + }).groupBy(t -> t).flatMap(group -> group.subscribeOn(Schedulers.newThread()).map(t1 -> { + System.out.println("Received: " + t1 + " on group : " + group.getKey()); + return "first groups: " + t1; + })).doOnEach(t1 -> { + System.out.println("notification => " + t1); + }).toBlocking().forEach(results::add); + + System.out.println("Results: " + results); + assertEquals(4, results.size()); + } + + @Test + public void testGroupsWithNestedObserveOn() throws InterruptedException { + final ArrayList results = new ArrayList<>(); + NbpObservable.create(sub -> { + sub.onSubscribe(EmptyDisposable.INSTANCE); + sub.onNext(1); + sub.onNext(2); + sub.onNext(1); + sub.onNext(2); + sub.onComplete(); + }).groupBy(t -> t).flatMap(group -> group.observeOn(Schedulers.newThread()) + .delay(400, TimeUnit.MILLISECONDS).map(t1 -> "first groups: " + t1)) + .toBlocking().forEach(results::add); + + System.out.println("Results: " + results); + assertEquals(4, results.size()); + } + + private static class Event { + int source; + String message; + + @Override + public String toString() { + return "Event => source: " + source + " message: " + message; + } + } + + NbpObservable ASYNC_INFINITE_OBSERVABLE_OF_EVENT(final int numGroups, final AtomicInteger subscribeCounter, final AtomicInteger sentEventCounter) { + return SYNC_INFINITE_OBSERVABLE_OF_EVENT(numGroups, subscribeCounter, sentEventCounter).subscribeOn(Schedulers.newThread()); + }; + + NbpObservable SYNC_INFINITE_OBSERVABLE_OF_EVENT(final int numGroups, final AtomicInteger subscribeCounter, final AtomicInteger sentEventCounter) { + return NbpObservable.create(op -> { + BooleanDisposable bs = new BooleanDisposable(); + op.onSubscribe(bs); + subscribeCounter.incrementAndGet(); + int i = 0; + while (!bs.isDisposed()) { + i++; + Event e = new Event(); + e.source = i % numGroups; + e.message = "Event-" + i; + op.onNext(e); + sentEventCounter.incrementAndGet(); + } + op.onComplete(); + }); + }; + + @Test + public void testGroupByOnAsynchronousSourceAcceptsMultipleSubscriptions() throws InterruptedException { + + // choose an asynchronous source + NbpObservable source = NbpObservable.interval(10, TimeUnit.MILLISECONDS).take(1); + + // apply groupBy to the source + NbpObservable> stream = source.groupBy(IS_EVEN); + + // create two observers + @SuppressWarnings("unchecked") + NbpObserver> o1 = mock(NbpObserver.class); + @SuppressWarnings("unchecked") + NbpObserver> o2 = mock(NbpObserver.class); + + // subscribe with the observers + stream.subscribe(o1); + stream.subscribe(o2); + + // check that subscriptions were successful + verify(o1, never()).onError(Matchers. any()); + verify(o2, never()).onError(Matchers. any()); + } + + private static Function IS_EVEN = n -> n % 2 == 0; + + private static Function IS_EVEN2 = n -> n % 2 == 0; + + @Test + public void testGroupByBackpressure() throws InterruptedException { + + NbpTestSubscriber ts = new NbpTestSubscriber<>(); + + NbpObservable.range(1, 4000) + .groupBy(IS_EVEN2) + .flatMap(g -> g.observeOn(Schedulers.computation()).map(l -> { + if (g.getKey()) { + try { + Thread.sleep(1); + } catch (InterruptedException e) { + } + return l + " is even."; + } else { + return l + " is odd."; + } + })).subscribe(ts); + ts.awaitTerminalEvent(); + ts.assertNoErrors(); + } + + Function just(final R value) { + return t1 -> value; + } + + Function fail(T dummy) { + return t1 -> { + throw new RuntimeException("Forced failure"); + }; + } + + Function fail2(R dummy2) { + return t1 -> { + throw new RuntimeException("Forced failure"); + }; + } + + Function dbl = t1 -> t1 * 2; + Function identity = v -> v; + + @Test + public void normalBehavior() { + NbpObservable source = NbpObservable.fromIterable(Arrays.asList( + " foo", + " FoO ", + "baR ", + "foO ", + " Baz ", + " qux ", + " bar", + " BAR ", + "FOO ", + "baz ", + " bAZ ", + " fOo " + )); + + /** + * foo FoO foO FOO fOo + * baR bar BAR + * Baz baz bAZ + * qux + * + */ + Function keysel = t1 -> t1.trim().toLowerCase(); + Function valuesel = t1 -> t1 + t1; + + NbpObservable m = source.groupBy(keysel, valuesel) + .flatMap(g -> { + System.out.println("-----------> NEXT: " + g.getKey()); + return g.take(2).map(new Function() { + + int count = 0; + + @Override + public String apply(String v) { + System.out.println(v); + return g.getKey() + "-" + count++; + } + + }); + }); + + NbpTestSubscriber ts = new NbpTestSubscriber<>(); + m.subscribe(ts); + ts.awaitTerminalEvent(); + System.out.println("ts .get " + ts.values()); + ts.assertNoErrors(); + assertEquals(ts.values(), + Arrays.asList("foo-0", "foo-1", "bar-0", "foo-0", "baz-0", "qux-0", "bar-1", "bar-0", "foo-1", "baz-1", "baz-0", "foo-0")); + + } + + @Test + public void keySelectorThrows() { + NbpObservable source = NbpObservable.just(0, 1, 2, 3, 4, 5, 6); + + NbpObservable m = source.groupBy(fail(0), dbl).flatMap(FLATTEN_INTEGER); + + NbpTestSubscriber ts = new NbpTestSubscriber<>(); + m.subscribe(ts); + ts.awaitTerminalEvent(); + assertEquals(1, ts.errorCount()); + ts.assertNoValues(); + } + + @Test + public void valueSelectorThrows() { + NbpObservable source = NbpObservable.just(0, 1, 2, 3, 4, 5, 6); + + NbpObservable m = source.groupBy(identity, fail(0)).flatMap(FLATTEN_INTEGER); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); + m.subscribe(ts); + ts.awaitTerminalEvent(); + assertEquals(1, ts.errorCount()); + ts.assertNoValues(); + + } + + @Test + public void innerEscapeCompleted() { + NbpObservable source = NbpObservable.just(0); + + NbpObservable m = source.groupBy(identity, dbl).flatMap(FLATTEN_INTEGER); + + NbpTestSubscriber ts = new NbpTestSubscriber<>(); + m.subscribe(ts); + ts.awaitTerminalEvent(); + ts.assertNoErrors(); + System.out.println(ts.values()); + } + + /** + * Assert we get an IllegalStateException if trying to subscribe to an inner NbpGroupedObservable more than once + */ + @Test + public void testExceptionIfSubscribeToChildMoreThanOnce() { + NbpObservable source = NbpObservable.just(0); + + final AtomicReference> inner = new AtomicReference<>(); + + NbpObservable> m = source.groupBy(identity, dbl); + + m.subscribe(inner::set); + + inner.get().subscribe(); + + @SuppressWarnings("unchecked") + NbpObserver o2 = mock(NbpObserver.class); + + inner.get().subscribe(o2); + + verify(o2, never()).onComplete(); + verify(o2, never()).onNext(anyInt()); + verify(o2).onError(any(IllegalStateException.class)); + } + + @Test + public void testError2() { + NbpObservable source = NbpObservable.concat(NbpObservable.just(0), + NbpObservable. error(new TestException("Forced failure"))); + + NbpObservable m = source.groupBy(identity, dbl).flatMap(FLATTEN_INTEGER); + + NbpTestSubscriber ts = new NbpTestSubscriber<>(); + m.subscribe(ts); + ts.awaitTerminalEvent(); + assertEquals(1, ts.errorCount()); + ts.assertValueCount(1); + } + + @Test + public void testgroupByBackpressure() throws InterruptedException { + NbpTestSubscriber ts = new NbpTestSubscriber<>(); + + NbpObservable.range(1, 4000).groupBy(IS_EVEN2).flatMap(g -> g.doOnComplete(() -> + System.out.println("//////////////////// COMPLETED-A") + ).observeOn(Schedulers.computation()).map(new Function() { + + int c = 0; + + @Override + public String apply(Integer l) { + if (g.getKey()) { + if (c++ < 400) { + try { + Thread.sleep(1); + } catch (InterruptedException e) { + } + } + return l + " is even."; + } else { + return l + " is odd."; + } + } + + }).doOnComplete(() -> System.out.println("//////////////////// COMPLETED-B"))).doOnEach(t1 -> { + System.out.println("NEXT: " + t1); + }).subscribe(ts); + ts.awaitTerminalEvent(); + ts.assertNoErrors(); + } + + @Test + public void testgroupByBackpressure2() throws InterruptedException { + + NbpTestSubscriber ts = new NbpTestSubscriber<>(); + + NbpObservable.range(1, 4000).groupBy(IS_EVEN2).flatMap(g -> g.take(2).observeOn(Schedulers.computation()).map(l -> { + if (g.getKey()) { + try { + Thread.sleep(1); + } catch (InterruptedException e) { + } + return l + " is even."; + } else { + return l + " is odd."; + } + })).subscribe(ts); + ts.awaitTerminalEvent(); + ts.assertNoErrors(); + } + + static Function, NbpObservable> FLATTEN_INTEGER = t -> t; + + @Test + public void testGroupByWithNullKey() { + final String[] key = new String[]{"uninitialized"}; + final List values = new ArrayList<>(); + NbpObservable.just("a", "b", "c").groupBy(value -> null).subscribe(s -> { + key[0] = s.getKey(); + s.subscribe(values::add); + }); + assertEquals(null, key[0]); + assertEquals(Arrays.asList("a", "b", "c"), values); + } + + @Test + public void testGroupByUnsubscribe() { + final Disposable d = mock(Disposable.class); + NbpObservable o = NbpObservable.create(s -> s.onSubscribe(d)); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); + + o.groupBy(integer -> null).subscribe(ts); + + ts.dispose(); + + verify(d).dispose(); + } + + @Test + public void testGroupByShouldPropagateError() { + final Throwable e = new RuntimeException("Oops"); + final NbpTestSubscriber inner1 = new NbpTestSubscriber<>(); + final NbpTestSubscriber inner2 = new NbpTestSubscriber<>(); + + final NbpTestSubscriber> outer + = new NbpTestSubscriber<>(new NbpObserver>() { + + @Override + public void onComplete() { + } + + @Override + public void onError(Throwable e) { + } + + @Override + public void onNext(NbpGroupedObservable o) { + if (o.getKey() == 0) { + o.subscribe(inner1); + } else { + o.subscribe(inner2); + } + } + }); + NbpObservable.create(s -> { + s.onSubscribe(EmptyDisposable.INSTANCE); + s.onNext(0); + s.onNext(1); + s.onError(e); + }).groupBy(i -> i % 2).subscribe(outer); + assertEquals(Arrays.asList(e), outer.errors()); + assertEquals(Arrays.asList(e), inner1.errors()); + assertEquals(Arrays.asList(e), inner2.errors()); + } +} \ No newline at end of file diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorIgnoreElementsTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorIgnoreElementsTest.java similarity index 82% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorIgnoreElementsTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorIgnoreElementsTest.java index 0677eeaeec..45fd22f525 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorIgnoreElementsTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorIgnoreElementsTest.java @@ -41,12 +41,7 @@ public void testUpstreamIsProcessedButIgnored() { final int num = 10; final AtomicInteger upstreamCount = new AtomicInteger(); long count = NbpObservable.range(1, num) - .doOnNext(new Consumer() { - @Override - public void accept(Integer t) { - upstreamCount.incrementAndGet(); - } - }) + .doOnNext(t -> upstreamCount.incrementAndGet()) .ignoreElements() .count().toBlocking().single(); assertEquals(num, upstreamCount.get()); @@ -55,7 +50,7 @@ public void accept(Integer t) { @Test public void testCompletedOk() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpObservable.range(1, 10).ignoreElements().subscribe(ts); ts.assertNoErrors(); ts.assertNoValues(); @@ -66,7 +61,7 @@ public void testCompletedOk() { @Test public void testErrorReceived() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); TestException ex = new TestException("boo"); NbpObservable.error(ex).ignoreElements().subscribe(ts); ts.assertNoValues(); @@ -80,11 +75,7 @@ public void testErrorReceived() { @Test public void testUnsubscribesFromUpstream() { final AtomicBoolean unsub = new AtomicBoolean(); - NbpObservable.range(1, 10).doOnCancel(new Runnable() { - @Override - public void run() { - unsub.set(true); - }}) + NbpObservable.range(1, 10).doOnCancel(() -> unsub.set(true)) .subscribe(); assertTrue(unsub.get()); } diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorLastTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorLastTest.java similarity index 84% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorLastTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorLastTest.java index c8d199e342..6e67a1f57b 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorLastTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorLastTest.java @@ -94,13 +94,7 @@ public void testLastWithEmpty() { @Test public void testLastWithPredicate() { NbpObservable o = NbpObservable.just(1, 2, 3, 4, 5, 6) - .filter(new Predicate() { - - @Override - public boolean test(Integer t1) { - return t1 % 2 == 0; - } - }) + .filter(t1 -> t1 % 2 == 0) .last(); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); @@ -115,14 +109,7 @@ public boolean test(Integer t1) { @Test public void testLastWithPredicateAndOneElement() { NbpObservable o = NbpObservable.just(1, 2) - .filter( - new Predicate() { - - @Override - public boolean test(Integer t1) { - return t1 % 2 == 0; - } - }) + .filter(t1 -> t1 % 2 == 0) .last(); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); @@ -137,14 +124,7 @@ public boolean test(Integer t1) { @Test public void testLastWithPredicateAndEmpty() { NbpObservable o = NbpObservable.just(1) - .filter( - new Predicate() { - - @Override - public boolean test(Integer t1) { - return t1 % 2 == 0; - } - }).last(); + .filter(t1 -> t1 % 2 == 0).last(); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); o.subscribe(NbpObserver); @@ -199,13 +179,7 @@ public void testLastOrDefaultWithEmpty() { @Test public void testLastOrDefaultWithPredicate() { NbpObservable o = NbpObservable.just(1, 2, 3, 4, 5, 6) - .filter(new Predicate() { - - @Override - public boolean test(Integer t1) { - return t1 % 2 == 0; - } - }) + .filter(t1 -> t1 % 2 == 0) .last(8); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); @@ -220,13 +194,7 @@ public boolean test(Integer t1) { @Test public void testLastOrDefaultWithPredicateAndOneElement() { NbpObservable o = NbpObservable.just(1, 2) - .filter(new Predicate() { - - @Override - public boolean test(Integer t1) { - return t1 % 2 == 0; - } - }) + .filter(t1 -> t1 % 2 == 0) .last(4); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); @@ -241,14 +209,7 @@ public boolean test(Integer t1) { @Test public void testLastOrDefaultWithPredicateAndEmpty() { NbpObservable o = NbpObservable.just(1) - .filter( - new Predicate() { - - @Override - public boolean test(Integer t1) { - return t1 % 2 == 0; - } - }) + .filter(t1 -> t1 % 2 == 0) .last(2); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorMapNotificationTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorMapNotificationTest.java similarity index 52% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorMapNotificationTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorMapNotificationTest.java index 85a4a0e519..a23fd68e43 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorMapNotificationTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorMapNotificationTest.java @@ -22,28 +22,10 @@ public class NbpOperatorMapNotificationTest { @Test public void testJust() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpObservable.just(1) - .flatMap( - new Function>() { - @Override - public NbpObservable apply(Integer item) { - return NbpObservable.just((Object)(item + 1)); - } - }, - new Function>() { - @Override - public NbpObservable apply(Throwable e) { - return NbpObservable.error(e); - } - }, - new Supplier>() { - @Override - public NbpObservable get() { - return NbpObservable.never(); - } - } - ).subscribe(ts); + .flatMap(item -> NbpObservable.just(item + 1), NbpObservable::error, NbpObservable::never) + .subscribe(ts); ts.assertNoErrors(); ts.assertNotComplete(); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorMapTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorMapTest.java similarity index 68% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorMapTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorMapTest.java index d7f0b0ad6b..861954af61 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorMapTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorMapTest.java @@ -30,12 +30,7 @@ public class NbpOperatorMapTest { NbpSubscriber stringObserver; NbpSubscriber stringObserver2; - final static BiFunction APPEND_INDEX = new BiFunction() { - @Override - public String apply(String value, Integer index) { - return value + index; - } - }; + final static BiFunction APPEND_INDEX = (value, index) -> value + index; @Before public void before() { @@ -49,12 +44,7 @@ public void testMap() { Map m2 = getMap("Two"); NbpObservable> o = NbpObservable.just(m1, m2); - NbpObservable m = o.map(new Function, String>() { - @Override - public String apply(Map map) { - return map.get("firstName"); - } - }); + NbpObservable m = o.map(map -> map.get("firstName")); m.subscribe(stringObserver); @@ -70,31 +60,21 @@ public void testMapMany() { NbpObservable ids = NbpObservable.just(1, 2); /* now simulate the behavior to take those IDs and perform nested async calls based on them */ - NbpObservable m = ids.flatMap(new Function>() { - - @Override - public NbpObservable apply(Integer id) { - /* simulate making a nested async call which creates another NbpObservable */ - NbpObservable> subObservable = null; - if (id == 1) { - Map m1 = getMap("One"); - Map m2 = getMap("Two"); - subObservable = NbpObservable.just(m1, m2); - } else { - Map m3 = getMap("Three"); - Map m4 = getMap("Four"); - subObservable = NbpObservable.just(m3, m4); - } - - /* simulate kicking off the async call and performing a select on it to transform the data */ - return subObservable.map(new Function, String>() { - @Override - public String apply(Map map) { - return map.get("firstName"); - } - }); + NbpObservable m = ids.flatMap(id -> { + /* simulate making a nested async call which creates another NbpObservable */ + NbpObservable> subObservable = null; + if (id == 1) { + Map m1 = getMap("One"); + Map m2 = getMap("Two"); + subObservable = NbpObservable.just(m1, m2); + } else { + Map m3 = getMap("Three"); + Map m4 = getMap("Four"); + subObservable = NbpObservable.just(m3, m4); } + /* simulate kicking off the async call and performing a select on it to transform the data */ + return subObservable.map(map -> map.get("firstName")); }); m.subscribe(stringObserver); @@ -118,20 +98,7 @@ public void testMapMany2() { NbpObservable>> o = NbpObservable.just(observable1, observable2); - NbpObservable m = o.flatMap(new Function>, NbpObservable>() { - - @Override - public NbpObservable apply(NbpObservable> o) { - return o.map(new Function, String>() { - - @Override - public String apply(Map map) { - return map.get("firstName"); - } - }); - } - - }); + NbpObservable m = o.flatMap(o1 -> o1.map(map -> map.get("firstName"))); m.subscribe(stringObserver); verify(stringObserver, never()).onError(any(Throwable.class)); @@ -146,22 +113,12 @@ public String apply(Map map) { @Test public void testMapWithError() { NbpObservable w = NbpObservable.just("one", "fail", "two", "three", "fail"); - NbpObservable m = w.map(new Function() { - @Override - public String apply(String s) { - if ("fail".equals(s)) { - throw new RuntimeException("Forced Failure"); - } - return s; - } - }).doOnError(new Consumer() { - - @Override - public void accept(Throwable t1) { - t1.printStackTrace(); + NbpObservable m = w.map(s -> { + if ("fail".equals(s)) { + throw new RuntimeException("Forced Failure"); } - - }); + return s; + }).doOnError(Throwable::printStackTrace); m.subscribe(stringObserver); verify(stringObserver, times(1)).onNext("one"); @@ -174,11 +131,8 @@ public void accept(Throwable t1) { @Test(expected = IllegalArgumentException.class) public void testMapWithIssue417() { NbpObservable.just(1).observeOn(Schedulers.computation()) - .map(new Function() { - @Override - public Integer apply(Integer arg0) { - throw new IllegalArgumentException("any error"); - } + .map(arg0 -> { + throw new IllegalArgumentException("any error"); }).toBlocking().single(); } @@ -189,11 +143,8 @@ public void testMapWithErrorInFuncAndThreadPoolScheduler() throws InterruptedExc // so map needs to handle the error by itself. NbpObservable m = NbpObservable.just("one") .observeOn(Schedulers.computation()) - .map(new Function() { - @Override - public String apply(String arg0) { - throw new IllegalArgumentException("any error"); - } + .map(arg0 -> { + throw new IllegalArgumentException("any error"); }); // block for response, expecting exception thrown @@ -205,14 +156,7 @@ public String apply(String arg0) { */ @Test(expected = NoSuchElementException.class) public void testErrorPassesThruMap() { - NbpObservable.range(1, 0).last().map(new Function() { - - @Override - public Integer apply(Integer i) { - return i; - } - - }).toBlocking().single(); + NbpObservable.range(1, 0).last().map(i -> i).toBlocking().single(); } /** @@ -220,14 +164,7 @@ public Integer apply(Integer i) { */ @Test(expected = IllegalStateException.class) public void testErrorPassesThruMap2() { - NbpObservable.error(new IllegalStateException()).map(new Function() { - - @Override - public Object apply(Object i) { - return i; - } - - }).toBlocking().single(); + NbpObservable.error(new IllegalStateException()).map(i -> i).toBlocking().single(); } /** @@ -236,14 +173,7 @@ public Object apply(Object i) { */ @Test(expected = ArithmeticException.class) public void testMapWithErrorInFunc() { - NbpObservable.range(1, 1).last().map(new Function() { - - @Override - public Integer apply(Integer i) { - return i / 0; - } - - }).toBlocking().single(); + NbpObservable.range(1, 1).last().map(i -> i / 0).toBlocking().single(); } // FIXME RS subscribers can't throw @@ -300,7 +230,7 @@ public Integer apply(Integer i) { // } private static Map getMap(String prefix) { - Map m = new HashMap(); + Map m = new HashMap<>(); m.put("firstName", prefix + "First"); m.put("lastName", prefix + "Last"); return m; diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorMaterializeTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorMaterializeTest.java similarity index 83% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorMaterializeTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorMaterializeTest.java index 22fc568875..a94020cb36 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorMaterializeTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorMaterializeTest.java @@ -95,13 +95,10 @@ public void testMultipleSubscribes() throws InterruptedException, ExecutionExcep @Test public void testWithCompletionCausingError() { - NbpTestSubscriber>> ts = new NbpTestSubscriber>>(); + NbpTestSubscriber>> ts = new NbpTestSubscriber<>(); final RuntimeException ex = new RuntimeException("boo"); - NbpObservable.empty().materialize().doOnNext(new Consumer() { - @Override - public void accept(Object t) { - throw ex; - } + NbpObservable.empty().materialize().doOnNext(t -> { + throw ex; }).subscribe(ts); ts.assertError(ex); ts.assertNoValues(); @@ -112,7 +109,7 @@ private static class TestObserver extends NbpObserver>> { boolean onCompleted = false; boolean onError = false; - List>> notifications = new Vector>>(); + List>> notifications = new Vector<>(); @Override public void onComplete() { @@ -144,28 +141,23 @@ private static class TestAsyncErrorObservable implements NbpOnSubscribe @Override public void accept(final NbpSubscriber NbpObserver) { NbpObserver.onSubscribe(EmptyDisposable.INSTANCE); - t = new Thread(new Runnable() { - - @Override - public void run() { - for (String s : valuesToReturn) { - if (s == null) { - System.out.println("throwing exception"); - try { - Thread.sleep(100); - } catch (Throwable e) { - - } - NbpObserver.onError(new NullPointerException()); - return; - } else { - NbpObserver.onNext(s); + t = new Thread(() -> { + for (String s : valuesToReturn) { + if (s == null) { + System.out.println("throwing exception"); + try { + Thread.sleep(100); + } catch (Throwable e) { + } + NbpObserver.onError(new NullPointerException()); + return; + } else { + NbpObserver.onNext(s); } - System.out.println("subscription complete"); - NbpObserver.onComplete(); } - + System.out.println("subscription complete"); + NbpObserver.onComplete(); }); t.start(); } diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorMergeDelayErrorTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorMergeDelayErrorTest.java similarity index 93% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorMergeDelayErrorTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorMergeDelayErrorTest.java index 1b9cc17d22..ecf99c2ad8 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorMergeDelayErrorTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorMergeDelayErrorTest.java @@ -251,7 +251,7 @@ public void testMergeArray() { public void testMergeList() { final NbpObservable o1 = NbpObservable.create(new TestSynchronousObservable()); final NbpObservable o2 = NbpObservable.create(new TestSynchronousObservable()); - List> listOfObservables = new ArrayList>(); + List> listOfObservables = new ArrayList<>(); listOfObservables.add(o1); listOfObservables.add(o2); @@ -328,14 +328,9 @@ private static class TestASynchronousObservable implements NbpOnSubscribe NbpObserver) { NbpObserver.onSubscribe(EmptyDisposable.INSTANCE); - t = new Thread(new Runnable() { - - @Override - public void run() { - NbpObserver.onNext("hello"); - NbpObserver.onComplete(); - } - + t = new Thread(() -> { + NbpObserver.onNext("hello"); + NbpObserver.onComplete(); }); t.start(); } @@ -383,28 +378,23 @@ private static class TestAsyncErrorObservable implements NbpOnSubscribe @Override public void accept(final NbpSubscriber NbpObserver) { NbpObserver.onSubscribe(EmptyDisposable.INSTANCE); - t = new Thread(new Runnable() { + t = new Thread(() -> { + for (String s : valuesToReturn) { + if (s == null) { + System.out.println("throwing exception"); + try { + Thread.sleep(100); + } catch (Throwable e) { - @Override - public void run() { - for (String s : valuesToReturn) { - if (s == null) { - System.out.println("throwing exception"); - try { - Thread.sleep(100); - } catch (Throwable e) { - - } - NbpObserver.onError(new NullPointerException()); - return; - } else { - NbpObserver.onNext(s); } + NbpObserver.onError(new NullPointerException()); + return; + } else { + NbpObserver.onNext(s); } - System.out.println("subscription complete"); - NbpObserver.onComplete(); } - + System.out.println("subscription complete"); + NbpObserver.onComplete(); }); t.start(); } @@ -487,7 +477,7 @@ public void onComplete() { @Test public void testErrorInParentObservable() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpObservable.mergeDelayError( NbpObservable.just(NbpObservable.just(1), NbpObservable.just(2)) .startWith(NbpObservable. error(new RuntimeException())) @@ -516,7 +506,7 @@ public void accept(NbpSubscriber> op) { NbpSubscriber stringObserver = TestHelper.mockNbpSubscriber(); - NbpTestSubscriber ts = new NbpTestSubscriber(stringObserver); + NbpTestSubscriber ts = new NbpTestSubscriber<>(stringObserver); NbpObservable m = NbpObservable.mergeDelayError(parentObservable); m.subscribe(ts); System.out.println("testErrorInParentObservableDelayed | " + i); @@ -535,19 +525,14 @@ private static class TestASynchronous1sDelayedObservable implements NbpOnSubscri @Override public void accept(final NbpSubscriber NbpObserver) { NbpObserver.onSubscribe(EmptyDisposable.INSTANCE); - t = new Thread(new Runnable() { - - @Override - public void run() { - try { - Thread.sleep(100); - } catch (InterruptedException e) { - NbpObserver.onError(e); - } - NbpObserver.onNext("hello"); - NbpObserver.onComplete(); + t = new Thread(() -> { + try { + Thread.sleep(100); + } catch (InterruptedException e) { + NbpObserver.onError(e); } - + NbpObserver.onNext("hello"); + NbpObserver.onComplete(); }); t.start(); } diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorMergeMaxConcurrentTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorMergeMaxConcurrentTest.java similarity index 83% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorMergeMaxConcurrentTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorMergeMaxConcurrentTest.java index e8da9ca6cf..56dfe9a2c0 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorMergeMaxConcurrentTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorMergeMaxConcurrentTest.java @@ -40,14 +40,14 @@ public void before() { @Test public void testWhenMaxConcurrentIsOne() { for (int i = 0; i < 100; i++) { - List> os = new ArrayList>(); + List> os = new ArrayList<>(); os.add(NbpObservable.just("one", "two", "three", "four", "five").subscribeOn(Schedulers.newThread())); os.add(NbpObservable.just("one", "two", "three", "four", "five").subscribeOn(Schedulers.newThread())); os.add(NbpObservable.just("one", "two", "three", "four", "five").subscribeOn(Schedulers.newThread())); List expected = Arrays.asList("one", "two", "three", "four", "five", "one", "two", "three", "four", "five", "one", "two", "three", "four", "five"); Iterator iter = NbpObservable.merge(os, 1).toBlocking().iterator(); - List actual = new ArrayList(); + List actual = new ArrayList<>(); while (iter.hasNext()) { actual.add(iter.next()); } @@ -63,8 +63,8 @@ public void testMaxConcurrent() { int maxConcurrent = 2 + (times % 10); AtomicInteger subscriptionCount = new AtomicInteger(0); - List> os = new ArrayList>(); - List scos = new ArrayList(); + List> os = new ArrayList<>(); + List scos = new ArrayList<>(); for (int i = 0; i < observableCount; i++) { SubscriptionCheckObservable sco = new SubscriptionCheckObservable(subscriptionCount, maxConcurrent); scos.add(sco); @@ -72,7 +72,7 @@ public void testMaxConcurrent() { } Iterator iter = NbpObservable.merge(os, maxConcurrent).toBlocking().iterator(); - List actual = new ArrayList(); + List actual = new ArrayList<>(); while (iter.hasNext()) { actual.add(iter.next()); } @@ -98,24 +98,19 @@ private static class SubscriptionCheckObservable implements NbpOnSubscribe t1) { t1.onSubscribe(EmptyDisposable.INSTANCE); - new Thread(new Runnable() { - - @Override - public void run() { - if (subscriptionCount.incrementAndGet() > maxConcurrent) { - failed = true; - } - t1.onNext("one"); - t1.onNext("two"); - t1.onNext("three"); - t1.onNext("four"); - t1.onNext("five"); - // We could not decrement subscriptionCount in the unsubscribe method - // as "unsubscribe" is not guaranteed to be called before the next "subscribe". - subscriptionCount.decrementAndGet(); - t1.onComplete(); + new Thread(() -> { + if (subscriptionCount.incrementAndGet() > maxConcurrent) { + failed = true; } - + t1.onNext("one"); + t1.onNext("two"); + t1.onNext("three"); + t1.onNext("four"); + t1.onNext("five"); + // We could not decrement subscriptionCount in the unsubscribe method + // as "unsubscribe" is not guaranteed to be called before the next "subscribe". + subscriptionCount.decrementAndGet(); + t1.onComplete(); }).start(); } @@ -124,7 +119,7 @@ public void run() { @Test public void testMergeALotOfSourcesOneByOneSynchronously() { int n = 10000; - List> sourceList = new ArrayList>(n); + List> sourceList = new ArrayList<>(n); for (int i = 0; i < n; i++) { sourceList.add(NbpObservable.just(i)); } @@ -139,7 +134,7 @@ public void testMergeALotOfSourcesOneByOneSynchronously() { @Test public void testMergeALotOfSourcesOneByOneSynchronouslyTakeHalf() { int n = 10000; - List> sourceList = new ArrayList>(n); + List> sourceList = new ArrayList<>(n); for (int i = 0; i < n; i++) { sourceList.add(NbpObservable.just(i)); } @@ -155,9 +150,9 @@ public void testMergeALotOfSourcesOneByOneSynchronouslyTakeHalf() { @Test public void testSimple() { for (int i = 1; i < 100; i++) { - NbpTestSubscriber ts = new NbpTestSubscriber(); - List> sourceList = new ArrayList>(i); - List result = new ArrayList(i); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); + List> sourceList = new ArrayList<>(i); + List result = new ArrayList<>(i); for (int j = 1; j <= i; j++) { sourceList.add(NbpObservable.just(j)); result.add(j); @@ -173,9 +168,9 @@ public void testSimple() { @Test public void testSimpleOneLess() { for (int i = 2; i < 100; i++) { - NbpTestSubscriber ts = new NbpTestSubscriber(); - List> sourceList = new ArrayList>(i); - List result = new ArrayList(i); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); + List> sourceList = new ArrayList<>(i); + List result = new ArrayList<>(i); for (int j = 1; j <= i; j++) { sourceList.add(NbpObservable.just(j)); result.add(j); @@ -203,9 +198,9 @@ public void testSimpleAsyncLoop() { @Test(timeout = 10000) public void testSimpleAsync() { for (int i = 1; i < 50; i++) { - NbpTestSubscriber ts = new NbpTestSubscriber(); - List> sourceList = new ArrayList>(i); - Set expected = new HashSet(i); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); + List> sourceList = new ArrayList<>(i); + Set expected = new HashSet<>(i); for (int j = 1; j <= i; j++) { sourceList.add(NbpObservable.just(j).subscribeOn(Schedulers.io())); expected.add(j); @@ -215,7 +210,7 @@ public void testSimpleAsync() { ts.awaitTerminalEvent(1, TimeUnit.SECONDS); ts.assertNoErrors(); - Set actual = new HashSet(ts.values()); + Set actual = new HashSet<>(ts.values()); assertEquals(expected, actual); } @@ -233,9 +228,9 @@ public void testSimpleOneLessAsync() { if (System.currentTimeMillis() - t > TimeUnit.SECONDS.toMillis(9)) { break; } - NbpTestSubscriber ts = new NbpTestSubscriber(); - List> sourceList = new ArrayList>(i); - Set expected = new HashSet(i); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); + List> sourceList = new ArrayList<>(i); + Set expected = new HashSet<>(i); for (int j = 1; j <= i; j++) { sourceList.add(NbpObservable.just(j).subscribeOn(Schedulers.io())); expected.add(j); @@ -245,7 +240,7 @@ public void testSimpleOneLessAsync() { ts.awaitTerminalEvent(1, TimeUnit.SECONDS); ts.assertNoErrors(); - Set actual = new HashSet(ts.values()); + Set actual = new HashSet<>(ts.values()); assertEquals(expected, actual); } @@ -253,13 +248,13 @@ public void testSimpleOneLessAsync() { @Test(timeout = 5000) public void testTake() throws Exception { - List> sourceList = new ArrayList>(3); + List> sourceList = new ArrayList<>(3); sourceList.add(NbpObservable.range(0, 100000).subscribeOn(Schedulers.io())); sourceList.add(NbpObservable.range(0, 100000).subscribeOn(Schedulers.io())); sourceList.add(NbpObservable.range(0, 100000).subscribeOn(Schedulers.io())); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpObservable.merge(sourceList, 2).take(5).subscribe(ts); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorMergeTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorMergeTest.java similarity index 83% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorMergeTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorMergeTest.java index a30b0f4492..43990ad60a 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorMergeTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorMergeTest.java @@ -110,7 +110,7 @@ public void testMergeArray() { public void testMergeList() { final NbpObservable o1 = NbpObservable.create(new TestSynchronousObservable()); final NbpObservable o2 = NbpObservable.create(new TestSynchronousObservable()); - List> listOfObservables = new ArrayList>(); + List> listOfObservables = new ArrayList<>(); listOfObservables.add(o1); listOfObservables.add(o2); @@ -133,46 +133,35 @@ public void testUnSubscribeObservableOfObservables() throws InterruptedException @Override public void accept(final NbpSubscriber> NbpObserver) { // verbose on purpose so I can track the inside of it - final Disposable s = new Disposable() { - @Override - public void dispose() { - System.out.println("*** unsubscribed"); - unsubscribed.set(true); - } + final Disposable s = () -> { + System.out.println("*** unsubscribed"); + unsubscribed.set(true); }; NbpObserver.onSubscribe(s); - new Thread(new Runnable() { + new Thread(() -> { - @Override - public void run() { - - while (!unsubscribed.get()) { - NbpObserver.onNext(NbpObservable.just(1L, 2L)); - } - System.out.println("Done looping after unsubscribe: " + unsubscribed.get()); - NbpObserver.onComplete(); - - // mark that the thread is finished - latch.countDown(); + while (!unsubscribed.get()) { + NbpObserver.onNext(NbpObservable.just(1L, 2L)); } + System.out.println("Done looping after unsubscribe: " + unsubscribed.get()); + NbpObserver.onComplete(); + + // mark that the thread is finished + latch.countDown(); }).start(); } }); final AtomicInteger count = new AtomicInteger(); - NbpObservable.merge(source).take(6).toBlocking().forEach(new Consumer() { - - @Override - public void accept(Long v) { - System.out.println("Value: " + v); - int c = count.incrementAndGet(); - if (c > 6) { - fail("Should be only 6"); - } - + NbpObservable.merge(source).take(6).toBlocking().forEach(v -> { + System.out.println("Value: " + v); + int c = count.incrementAndGet(); + if (c > 6) { + fail("Should be only 6"); } + }); latch.await(1000, TimeUnit.MILLISECONDS); @@ -189,7 +178,7 @@ public void testMergeArrayWithThreading() { final TestASynchronousObservable o2 = new TestASynchronousObservable(); NbpObservable m = NbpObservable.merge(NbpObservable.create(o1), NbpObservable.create(o2)); - NbpTestSubscriber ts = new NbpTestSubscriber(stringObserver); + NbpTestSubscriber ts = new NbpTestSubscriber<>(stringObserver); m.subscribe(ts); ts.awaitTerminalEvent(); @@ -335,14 +324,9 @@ public void testError2() { @Test @Ignore("Subscribe should not throw") public void testThrownErrorHandling() { - NbpTestSubscriber ts = new NbpTestSubscriber(); - NbpObservable o1 = NbpObservable.create(new NbpOnSubscribe() { - - @Override - public void accept(NbpSubscriber s) { - throw new RuntimeException("fail"); - } - + NbpTestSubscriber ts = new NbpTestSubscriber<>(); + NbpObservable o1 = NbpObservable.create(s -> { + throw new RuntimeException("fail"); }); NbpObservable.merge(o1, o1).subscribe(ts); @@ -368,21 +352,16 @@ private static class TestASynchronousObservable implements NbpOnSubscribe NbpObserver) { NbpObserver.onSubscribe(EmptyDisposable.INSTANCE); - t = new Thread(new Runnable() { - - @Override - public void run() { - onNextBeingSent.countDown(); - try { - NbpObserver.onNext("hello"); - // I can't use a countDownLatch to prove we are actually sending 'onNext' - // since it will block if synchronized and I'll deadlock - NbpObserver.onComplete(); - } catch (Exception e) { - NbpObserver.onError(e); - } + t = new Thread(() -> { + onNextBeingSent.countDown(); + try { + NbpObserver.onNext("hello"); + // I can't use a countDownLatch to prove we are actually sending 'onNext' + // since it will block if synchronized and I'll deadlock + NbpObserver.onComplete(); + } catch (Exception e) { + NbpObserver.onError(e); } - }, "TestASynchronousObservable"); t.start(); } @@ -421,7 +400,7 @@ public void testUnsubscribeAsObservablesComplete() { AtomicBoolean os2 = new AtomicBoolean(false); NbpObservable o2 = createObservableOf5IntervalsOf1SecondIncrementsWithSubscriptionHook(scheduler2, os2); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpObservable.merge(o1, o2).subscribe(ts); // we haven't incremented time so nothing should be received yet @@ -463,7 +442,7 @@ public void testEarlyUnsubscribe() { AtomicBoolean os2 = new AtomicBoolean(false); NbpObservable o2 = createObservableOf5IntervalsOf1SecondIncrementsWithSubscriptionHook(scheduler2, os2); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpObservable.merge(o1, o2).subscribe(ts); // we haven't incremented time so nothing should be received yet @@ -499,12 +478,9 @@ public void accept(final NbpSubscriber child) { .subscribe(new NbpSubscriber() { @Override public void onSubscribe(final Disposable s) { - child.onSubscribe(new Disposable() { - @Override - public void dispose() { - unsubscribed.set(true); - s.dispose(); - } + child.onSubscribe(() -> { + unsubscribed.set(true); + s.dispose(); }); } @@ -536,7 +512,7 @@ public void testConcurrency() { for (int i = 0; i < 10; i++) { NbpObservable merge = NbpObservable.merge(o, o, o); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); merge.subscribe(ts); ts.awaitTerminalEvent(3, TimeUnit.SECONDS); @@ -563,33 +539,28 @@ public void accept(final NbpSubscriber s) { s.onSubscribe(as); - inner.schedule(new Runnable() { - - @Override - public void run() { - try { - for (int i = 0; i < 100; i++) { - s.onNext(1); - try { - Thread.sleep(1); - } catch (InterruptedException e) { - e.printStackTrace(); - } + inner.schedule(() -> { + try { + for (int i = 0; i < 100; i++) { + s.onNext(1); + try { + Thread.sleep(1); + } catch (InterruptedException e) { + e.printStackTrace(); } - } catch (Exception e) { - s.onError(e); } - as.dispose(); - s.onComplete(); + } catch (Exception e) { + s.onError(e); } - + as.dispose(); + s.onComplete(); }); } }); for (int i = 0; i < 10; i++) { NbpObservable merge = NbpObservable.merge(o, o, o); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); merge.subscribe(ts); ts.awaitTerminalEvent(); @@ -613,30 +584,25 @@ public void accept(final NbpSubscriber s) { s.onSubscribe(as); - inner.schedule(new Runnable() { - - @Override - public void run() { - try { - for (int i = 0; i < 10000; i++) { - s.onNext(i); - } - } catch (Exception e) { - s.onError(e); + inner.schedule(() -> { + try { + for (int i = 0; i < 10000; i++) { + s.onNext(i); } - as.dispose(); - s.onComplete(); - s.onComplete(); - s.onComplete(); + } catch (Exception e) { + s.onError(e); } - + as.dispose(); + s.onComplete(); + s.onComplete(); + s.onComplete(); }); } }); for (int i = 0; i < 10; i++) { NbpObservable merge = NbpObservable.merge(o, o, o); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); merge.subscribe(ts); ts.awaitTerminalEvent(); @@ -774,14 +740,7 @@ public void onNext(Integer t) { @Test(timeout = 5000) public void testBackpressureBothUpstreamAndDownstreamWithRegularObservables() throws InterruptedException { final AtomicInteger generated1 = new AtomicInteger(); - NbpObservable> o1 = createInfiniteObservable(generated1).map(new Function>() { - - @Override - public NbpObservable apply(Integer t1) { - return NbpObservable.just(1, 2, 3); - } - - }); + NbpObservable> o1 = createInfiniteObservable(generated1).map(t1 -> NbpObservable.just(1, 2, 3)); NbpTestSubscriber NbpTestSubscriber = new NbpTestSubscriber() { int i = 0; @@ -819,7 +778,7 @@ public void onNext(Integer t) { @Ignore("Null values not permitted") public void mergeWithNullValues() { System.out.println("mergeWithNullValues"); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpObservable.merge(NbpObservable.just(null, "one"), NbpObservable.just("two", null)).subscribe(ts); ts.assertTerminated(); ts.assertNoErrors(); @@ -830,7 +789,7 @@ public void mergeWithNullValues() { @Ignore("Null values are no longer permitted") public void mergeWithTerminalEventAfterUnsubscribe() { System.out.println("mergeWithTerminalEventAfterUnsubscribe"); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpObservable bad = NbpObservable.create(new NbpOnSubscribe() { @Override @@ -850,7 +809,7 @@ public void accept(NbpSubscriber s) { @Test @Ignore("Null values are not permitted") public void mergingNullObservable() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpObservable.merge(NbpObservable.just("one"), null).subscribe(ts); ts.assertNoErrors(); ts.assertValue("one"); @@ -858,7 +817,7 @@ public void mergingNullObservable() { @Test public void merge1AsyncStreamOf1() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); mergeNAsyncStreamsOfN(1, 1).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); @@ -867,7 +826,7 @@ public void merge1AsyncStreamOf1() { @Test public void merge1AsyncStreamOf1000() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); mergeNAsyncStreamsOfN(1, 1000).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); @@ -876,7 +835,7 @@ public void merge1AsyncStreamOf1000() { @Test public void merge10AsyncStreamOf1000() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); mergeNAsyncStreamsOfN(10, 1000).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); @@ -885,7 +844,7 @@ public void merge10AsyncStreamOf1000() { @Test public void merge1000AsyncStreamOf1000() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); mergeNAsyncStreamsOfN(1000, 1000).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); @@ -894,7 +853,7 @@ public void merge1000AsyncStreamOf1000() { @Test public void merge2000AsyncStreamOf100() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); mergeNAsyncStreamsOfN(2000, 100).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); @@ -903,7 +862,7 @@ public void merge2000AsyncStreamOf100() { @Test public void merge100AsyncStreamOf1() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); mergeNAsyncStreamsOfN(100, 1).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); @@ -912,20 +871,13 @@ public void merge100AsyncStreamOf1() { private NbpObservable mergeNAsyncStreamsOfN(final int outerSize, final int innerSize) { NbpObservable> os = NbpObservable.range(1, outerSize) - .map(new Function>() { - - @Override - public NbpObservable apply(Integer i) { - return NbpObservable.range(1, innerSize).subscribeOn(Schedulers.computation()); - } - - }); + .map(i -> NbpObservable.range(1, innerSize).subscribeOn(Schedulers.computation())); return NbpObservable.merge(os); } @Test public void merge1SyncStreamOf1() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); mergeNSyncStreamsOfN(1, 1).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); @@ -934,7 +886,7 @@ public void merge1SyncStreamOf1() { @Test public void merge1SyncStreamOf1000000() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); mergeNSyncStreamsOfN(1, 1000000).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); @@ -943,7 +895,7 @@ public void merge1SyncStreamOf1000000() { @Test public void merge1000SyncStreamOf1000() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); mergeNSyncStreamsOfN(1000, 1000).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); @@ -952,7 +904,7 @@ public void merge1000SyncStreamOf1000() { @Test public void merge10000SyncStreamOf10() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); mergeNSyncStreamsOfN(10000, 10).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); @@ -961,7 +913,7 @@ public void merge10000SyncStreamOf10() { @Test public void merge1000000SyncStreamOf1() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); mergeNSyncStreamsOfN(1000000, 1).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); @@ -970,37 +922,25 @@ public void merge1000000SyncStreamOf1() { private NbpObservable mergeNSyncStreamsOfN(final int outerSize, final int innerSize) { NbpObservable> os = NbpObservable.range(1, outerSize) - .map(new Function>() { - - @Override - public NbpObservable apply(Integer i) { - return NbpObservable.range(1, innerSize); - } - - }); + .map(i -> NbpObservable.range(1, innerSize)); return NbpObservable.merge(os); } private NbpObservable createInfiniteObservable(final AtomicInteger generated) { - NbpObservable o = NbpObservable.fromIterable(new Iterable() { - @Override - public Iterator iterator() { - return new Iterator() { + NbpObservable o = NbpObservable.fromIterable(() -> new Iterator() { - @Override - public void remove() { - } + @Override + public void remove() { + } - @Override - public Integer next() { - return generated.getAndIncrement(); - } + @Override + public Integer next() { + return generated.getAndIncrement(); + } - @Override - public boolean hasNext() { - return true; - } - }; + @Override + public boolean hasNext() { + return true; } }); return o; @@ -1008,55 +948,38 @@ public boolean hasNext() { @Test public void mergeManyAsyncSingle() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpObservable> os = NbpObservable.range(1, 10000) - .map(new Function>() { + .map(i -> NbpObservable.create(new NbpOnSubscribe() { @Override - public NbpObservable apply(final Integer i) { - return NbpObservable.create(new NbpOnSubscribe() { - - @Override - public void accept(NbpSubscriber s) { - s.onSubscribe(EmptyDisposable.INSTANCE); - if (i < 500) { - try { - Thread.sleep(1); - } catch (InterruptedException e) { - e.printStackTrace(); - } - } - s.onNext(i); - s.onComplete(); + public void accept(NbpSubscriber s) { + s.onSubscribe(EmptyDisposable.INSTANCE); + if (i < 500) { + try { + Thread.sleep(1); + } catch (InterruptedException e) { + e.printStackTrace(); } - - }).subscribeOn(Schedulers.computation()).cache(); + } + s.onNext(i); + s.onComplete(); } - }); + }).subscribeOn(Schedulers.computation()).cache()); NbpObservable.merge(os).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); assertEquals(10000, ts.values().size()); } - Function> toScalar = new Function>() { - @Override - public NbpObservable apply(Integer v) { - return NbpObservable.just(v); - } - }; + Function> toScalar = NbpObservable::just; - Function> toHiddenScalar = new Function>() { - @Override - public NbpObservable apply(Integer t) { - return NbpObservable.just(t).asObservable(); - } - }; + Function> toHiddenScalar = t -> NbpObservable.just(t).asObservable(); ; void runMerge(Function> func, NbpTestSubscriber ts) { - List list = new ArrayList(); + List list = new ArrayList<>(); for (int i = 0; i < 1000; i++) { list.add(i); } @@ -1074,11 +997,11 @@ void runMerge(Function> func, NbpTestSubscriber< @Test public void testFastMergeFullScalar() { - runMerge(toScalar, new NbpTestSubscriber()); + runMerge(toScalar, new NbpTestSubscriber<>()); } @Test public void testFastMergeHiddenScalar() { - runMerge(toHiddenScalar, new NbpTestSubscriber()); + runMerge(toHiddenScalar, new NbpTestSubscriber<>()); } @Test public void testSlowMergeFullScalar() { diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorMulticastTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorMulticastTest.java similarity index 100% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorMulticastTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorMulticastTest.java diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorObserveOnTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorObserveOnTest.java similarity index 75% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorObserveOnTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorObserveOnTest.java index ce71c8df07..03614a4580 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorObserveOnTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorObserveOnTest.java @@ -58,7 +58,7 @@ public void testOrdering() throws InterruptedException { NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); InOrder inOrder = inOrder(NbpObserver); - NbpTestSubscriber ts = new NbpTestSubscriber(NbpObserver); + NbpTestSubscriber ts = new NbpTestSubscriber<>(NbpObserver); obs.observeOn(Schedulers.computation()).subscribe(ts); @@ -92,36 +92,19 @@ public void testThreadName() throws InterruptedException { final CountDownLatch completedLatch = new CountDownLatch(1); // assert subscribe is on main thread - obs = obs.doOnNext(new Consumer() { - - @Override - public void accept(String s) { - String threadName = Thread.currentThread().getName(); - System.out.println("Source ThreadName: " + threadName + " Expected => " + parentThreadName); - assertEquals(parentThreadName, threadName); - } - + obs = obs.doOnNext(s -> { + String threadName = Thread.currentThread().getName(); + System.out.println("Source ThreadName: " + threadName + " Expected => " + parentThreadName); + assertEquals(parentThreadName, threadName); }); // assert observe is on new thread - obs.observeOn(Schedulers.newThread()).doOnNext(new Consumer() { - - @Override - public void accept(String t1) { - String threadName = Thread.currentThread().getName(); - boolean correctThreadName = threadName.startsWith("RxNewThreadScheduler"); - System.out.println("ObserveOn ThreadName: " + threadName + " Correct => " + correctThreadName); - assertTrue(correctThreadName); - } - - }).finallyDo(new Runnable() { - - @Override - public void run() { - completedLatch.countDown(); - - } - }).subscribe(NbpObserver); + obs.observeOn(Schedulers.newThread()).doOnNext(t1 -> { + String threadName = Thread.currentThread().getName(); + boolean correctThreadName = threadName.startsWith("RxNewThreadScheduler"); + System.out.println("ObserveOn ThreadName: " + threadName + " Correct => " + correctThreadName); + assertTrue(correctThreadName); + }).finallyDo(() -> completedLatch.countDown()).subscribe(NbpObserver); if (!completedLatch.await(1000, TimeUnit.MILLISECONDS)) { fail("timed out waiting"); @@ -211,24 +194,12 @@ public void testObserveOnWithNewThreadScheduler() { final AtomicInteger count = new AtomicInteger(); final int _multiple = 99; - NbpObservable.range(1, 100000).map(new Function() { - - @Override - public Integer apply(Integer t1) { - return t1 * _multiple; - } - - }).observeOn(Schedulers.newThread()) - .toBlocking().forEach(new Consumer() { - - @Override - public void accept(Integer t1) { - assertEquals(count.incrementAndGet() * _multiple, t1.intValue()); - // FIXME toBlocking methods run on the current thread - String name = Thread.currentThread().getName(); - assertFalse("Wrong thread name: " + name, name.startsWith("Rx")); - } - + NbpObservable.range(1, 100000).map(t1 -> t1 * _multiple).observeOn(Schedulers.newThread()) + .toBlocking().forEach(t1 -> { + Assert.assertEquals(count.incrementAndGet() * _multiple, t1.intValue()); + // FIXME toBlocking methods run on the current thread + String name = Thread.currentThread().getName(); + assertFalse("Wrong thread name: " + name, name.startsWith("Rx")); }); } @@ -241,24 +212,12 @@ public void testObserveOnWithThreadPoolScheduler() { final AtomicInteger count = new AtomicInteger(); final int _multiple = 99; - NbpObservable.range(1, 100000).map(new Function() { - - @Override - public Integer apply(Integer t1) { - return t1 * _multiple; - } - - }).observeOn(Schedulers.computation()) - .toBlocking().forEach(new Consumer() { - - @Override - public void accept(Integer t1) { - assertEquals(count.incrementAndGet() * _multiple, t1.intValue()); - // FIXME toBlocking methods run on the caller's thread - String name = Thread.currentThread().getName(); - assertFalse("Wrong thread name: " + name, name.startsWith("Rx")); - } - + NbpObservable.range(1, 100000).map(t1 -> t1 * _multiple).observeOn(Schedulers.computation()) + .toBlocking().forEach(t1 -> { + Assert.assertEquals(count.incrementAndGet() * _multiple, t1.intValue()); + // FIXME toBlocking methods run on the caller's thread + String name = Thread.currentThread().getName(); + assertFalse("Wrong thread name: " + name, name.startsWith("Rx")); }); } @@ -276,32 +235,22 @@ public void testObserveOnOrderingConcurrency() { final AtomicInteger count = new AtomicInteger(); final int _multiple = 99; - NbpObservable.range(1, 10000).map(new Function() { - - @Override - public Integer apply(Integer t1) { - if (randomIntFrom0to100() > 98) { - try { - Thread.sleep(2); - } catch (InterruptedException e) { - e.printStackTrace(); - } + NbpObservable.range(1, 10000).map(t1 -> { + if (randomIntFrom0to100() > 98) { + try { + Thread.sleep(2); + } catch (InterruptedException e) { + e.printStackTrace(); } - return t1 * _multiple; } - + return t1 * _multiple; }).observeOn(Schedulers.computation()) - .toBlocking().forEach(new Consumer() { - - @Override - public void accept(Integer t1) { - assertEquals(count.incrementAndGet() * _multiple, t1.intValue()); + .toBlocking().forEach(t1 -> { + Assert.assertEquals(count.incrementAndGet() * _multiple, t1.intValue()); // assertTrue(name.startsWith("RxComputationThreadPool")); - // FIXME toBlocking now runs its methods on the caller thread - String name = Thread.currentThread().getName(); - assertFalse("Wrong thread name: " + name, name.startsWith("Rx")); - } - + // FIXME toBlocking now runs its methods on the caller thread + String name = Thread.currentThread().getName(); + assertFalse("Wrong thread name: " + name, name.startsWith("Rx")); }); } @@ -384,7 +333,7 @@ public void testAfterUnsubscribeCalledThenObserverOnNextNeverCalled() { final TestScheduler testScheduler = new TestScheduler(); final NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); - NbpTestSubscriber ts = new NbpTestSubscriber(NbpObserver); + NbpTestSubscriber ts = new NbpTestSubscriber<>(NbpObserver); NbpObservable.just(1, 2, 3) .observeOn(testScheduler) @@ -403,29 +352,24 @@ public void testAfterUnsubscribeCalledThenObserverOnNextNeverCalled() { @Test public void testBackpressureWithTakeBefore() { final AtomicInteger generated = new AtomicInteger(); - NbpObservable o = NbpObservable.fromIterable(new Iterable() { - @Override - public Iterator iterator() { - return new Iterator() { + NbpObservable o = NbpObservable.fromIterable(() -> new Iterator() { - @Override - public void remove() { - } + @Override + public void remove() { + } - @Override - public Integer next() { - return generated.getAndIncrement(); - } + @Override + public Integer next() { + return generated.getAndIncrement(); + } - @Override - public boolean hasNext() { - return true; - } - }; + @Override + public boolean hasNext() { + return true; } }); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); o .take(7) .observeOn(Schedulers.newThread()) @@ -438,7 +382,7 @@ public boolean hasNext() { @Test public void testAsyncChild() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpObservable.range(0, 100000).observeOn(Schedulers.newThread()).observeOn(Schedulers.newThread()).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorOnErrorResumeNextViaFunctionTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorOnErrorResumeNextViaFunctionTest.java similarity index 71% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorOnErrorResumeNextViaFunctionTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorOnErrorResumeNextViaFunctionTest.java index 5003b4f988..70ed2d3d10 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorOnErrorResumeNextViaFunctionTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorOnErrorResumeNextViaFunctionTest.java @@ -35,7 +35,7 @@ public class NbpOperatorOnErrorResumeNextViaFunctionTest { @Test public void testResumeNextWithSynchronousExecution() { - final AtomicReference receivedException = new AtomicReference(); + final AtomicReference receivedException = new AtomicReference<>(); NbpObservable w = NbpObservable.create(new NbpOnSubscribe() { @Override @@ -48,14 +48,9 @@ public void accept(NbpSubscriber NbpObserver) { } }); - Function> resume = new Function>() { - - @Override - public NbpObservable apply(Throwable t1) { - receivedException.set(t1); - return NbpObservable.just("twoResume", "threeResume"); - } - + Function> resume = t1 -> { + receivedException.set(t1); + return NbpObservable.just("twoResume", "threeResume"); }; NbpObservable NbpObservable = w.onErrorResumeNext(resume); @@ -75,17 +70,12 @@ public NbpObservable apply(Throwable t1) { @Test public void testResumeNextWithAsyncExecution() { - final AtomicReference receivedException = new AtomicReference(); + final AtomicReference receivedException = new AtomicReference<>(); Subscription s = mock(Subscription.class); TestObservable w = new TestObservable(s, "one"); - Function> resume = new Function>() { - - @Override - public NbpObservable apply(Throwable t1) { - receivedException.set(t1); - return NbpObservable.just("twoResume", "threeResume"); - } - + Function> resume = t1 -> { + receivedException.set(t1); + return NbpObservable.just("twoResume", "threeResume"); }; NbpObservable o = NbpObservable.create(w).onErrorResumeNext(resume); @@ -116,13 +106,8 @@ public NbpObservable apply(Throwable t1) { public void testFunctionThrowsError() { Subscription s = mock(Subscription.class); TestObservable w = new TestObservable(s, "one"); - Function> resume = new Function>() { - - @Override - public NbpObservable apply(Throwable t1) { - throw new RuntimeException("exception from function"); - } - + Function> resume = t1 -> { + throw new RuntimeException("exception from function"); }; NbpObservable o = NbpObservable.create(w).onErrorResumeNext(resume); @@ -151,25 +136,15 @@ public NbpObservable apply(Throwable t1) { @Test @Ignore("Failed operator may leave the child NbpSubscriber in an inconsistent state which prevents further error delivery.") public void testOnErrorResumeReceivesErrorFromPreviousNonProtectedOperator() { - NbpTestSubscriber ts = new NbpTestSubscriber(); - NbpObservable.just(1).lift(new NbpOperator() { - - @Override - public NbpSubscriber apply(NbpSubscriber t1) { - throw new RuntimeException("failed"); - } - - }).onErrorResumeNext(new Function>() { - - @Override - public NbpObservable apply(Throwable t1) { - if (t1.getMessage().equals("failed")) { - return NbpObservable.just("success"); - } else { - return NbpObservable.error(t1); - } + NbpTestSubscriber ts = new NbpTestSubscriber<>(); + NbpObservable.just(1).lift(t1 -> { + throw new RuntimeException("failed"); + }).onErrorResumeNext(t1 -> { + if (t1.getMessage().equals("failed")) { + return NbpObservable.just("success"); + } else { + return NbpObservable.error(t1); } - }).subscribe(ts); ts.assertTerminated(); @@ -184,7 +159,7 @@ public NbpObservable apply(Throwable t1) { @Test @Ignore("A crashing operator may leave the downstream in an inconsistent state and not suitable for event delivery") public void testOnErrorResumeReceivesErrorFromPreviousNonProtectedOperatorOnNext() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpObservable.just(1).lift(new NbpOperator() { @Override @@ -214,17 +189,12 @@ public void onNext(Integer t) { }; } - }).onErrorResumeNext(new Function>() { - - @Override - public NbpObservable apply(Throwable t1) { - if (t1.getMessage().equals("failed")) { - return NbpObservable.just("success"); - } else { - return NbpObservable.error(t1); - } + }).onErrorResumeNext(t1 -> { + if (t1.getMessage().equals("failed")) { + return NbpObservable.just("success"); + } else { + return NbpObservable.error(t1); } - }).subscribe(ts); ts.assertTerminated(); @@ -239,29 +209,21 @@ public void testMapResumeAsyncNext() { // Introduce map function that fails intermittently (Map does not prevent this when the NbpObserver is a // rx.operator incl onErrorResumeNextViaObservable) - w = w.map(new Function() { - @Override - public String apply(String s) { - if ("fail".equals(s)) - throw new RuntimeException("Forced Failure"); - System.out.println("BadMapper:" + s); - return s; - } + w = w.map(s -> { + if ("fail".equals(s)) + throw new RuntimeException("Forced Failure"); + System.out.println("BadMapper:" + s); + return s; }); - NbpObservable o = w.onErrorResumeNext(new Function>() { - - @Override - public NbpObservable apply(Throwable t1) { - return NbpObservable.just("twoResume", "threeResume").subscribeOn(Schedulers.computation()); - } - + NbpObservable o = w.onErrorResumeNext(t1 -> { + return NbpObservable.just("twoResume", "threeResume").subscribeOn(Schedulers.computation()); }); @SuppressWarnings("unchecked") NbpObserver NbpObserver = mock(NbpObserver.class); - NbpTestSubscriber ts = new NbpTestSubscriber(NbpObserver); + NbpTestSubscriber ts = new NbpTestSubscriber<>(NbpObserver); o.subscribe(ts); ts.awaitTerminalEvent(); @@ -287,22 +249,17 @@ public TestObservable(Subscription s, String... values) { public void accept(final NbpSubscriber NbpObserver) { System.out.println("TestObservable subscribed to ..."); NbpObserver.onSubscribe(EmptyDisposable.INSTANCE); - t = new Thread(new Runnable() { - - @Override - public void run() { - try { - System.out.println("running TestObservable thread"); - for (String s : values) { - System.out.println("TestObservable onNext: " + s); - NbpObserver.onNext(s); - } - throw new RuntimeException("Forced Failure"); - } catch (Throwable e) { - NbpObserver.onError(e); + t = new Thread(() -> { + try { + System.out.println("running TestObservable thread"); + for (String s : values) { + System.out.println("TestObservable onNext: " + s); + NbpObserver.onNext(s); } + throw new RuntimeException("Forced Failure"); + } catch (Throwable e) { + NbpObserver.onError(e); } - }); System.out.println("starting TestObservable thread"); t.start(); @@ -313,15 +270,10 @@ public void run() { @Test public void testBackpressure() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpObservable.range(0, 100000) - .onErrorResumeNext(new Function>() { - - @Override - public NbpObservable apply(Throwable t1) { - return NbpObservable.just(1); - } - + .onErrorResumeNext(t1 -> { + return NbpObservable.just(1); }) .observeOn(Schedulers.computation()) .map(new Function() { diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorOnErrorResumeNextViaObservableTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorOnErrorResumeNextViaObservableTest.java similarity index 79% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorOnErrorResumeNextViaObservableTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorOnErrorResumeNextViaObservableTest.java index c68b728f34..025fd3d75a 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorOnErrorResumeNextViaObservableTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorOnErrorResumeNextViaObservableTest.java @@ -67,14 +67,11 @@ public void testMapResumeAsyncNext() { // Introduce map function that fails intermittently (Map does not prevent this when the NbpObserver is a // rx.operator incl onErrorResumeNextViaObservable) - w = w.map(new Function() { - @Override - public String apply(String s) { - if ("fail".equals(s)) - throw new RuntimeException("Forced Failure"); - System.out.println("BadMapper:" + s); - return s; - } + w = w.map(s -> { + if ("fail".equals(s)) + throw new RuntimeException("Forced Failure"); + System.out.println("BadMapper:" + s); + return s; }); NbpObservable NbpObservable = w.onErrorResumeNext(resume); @@ -101,13 +98,8 @@ public String apply(String s) { @Test @Ignore("Publishers should not throw") public void testResumeNextWithFailureOnSubscribe() { - NbpObservable testObservable = NbpObservable.create(new NbpOnSubscribe() { - - @Override - public void accept(NbpSubscriber t1) { - throw new RuntimeException("force failure"); - } - + NbpObservable testObservable = NbpObservable.create(t1 -> { + throw new RuntimeException("force failure"); }); NbpObservable resume = NbpObservable.just("resume"); NbpObservable NbpObservable = testObservable.onErrorResumeNext(resume); @@ -123,20 +115,15 @@ public void accept(NbpSubscriber t1) { @Test @Ignore("Publishers should not throw") public void testResumeNextWithFailureOnSubscribeAsync() { - NbpObservable testObservable = NbpObservable.create(new NbpOnSubscribe() { - - @Override - public void accept(NbpSubscriber t1) { - throw new RuntimeException("force failure"); - } - + NbpObservable testObservable = NbpObservable.create(t1 -> { + throw new RuntimeException("force failure"); }); NbpObservable resume = NbpObservable.just("resume"); NbpObservable NbpObservable = testObservable.subscribeOn(Schedulers.io()).onErrorResumeNext(resume); @SuppressWarnings("unchecked") NbpObserver NbpObserver = mock(NbpObserver.class); - NbpTestSubscriber ts = new NbpTestSubscriber(NbpObserver); + NbpTestSubscriber ts = new NbpTestSubscriber<>(NbpObserver); NbpObservable.subscribe(ts); ts.awaitTerminalEvent(); @@ -161,26 +148,21 @@ public TestObservable(Disposable s, String... values) { public void accept(final NbpSubscriber NbpObserver) { System.out.println("TestObservable subscribed to ..."); NbpObserver.onSubscribe(s); - t = new Thread(new Runnable() { - - @Override - public void run() { - try { - System.out.println("running TestObservable thread"); - for (String s : values) { - if ("fail".equals(s)) - throw new RuntimeException("Forced Failure"); - System.out.println("TestObservable onNext: " + s); - NbpObserver.onNext(s); - } - System.out.println("TestObservable onCompleted"); - NbpObserver.onComplete(); - } catch (Throwable e) { - System.out.println("TestObservable onError: " + e); - NbpObserver.onError(e); + t = new Thread(() -> { + try { + System.out.println("running TestObservable thread"); + for (String s1 : values) { + if ("fail".equals(s1)) + throw new RuntimeException("Forced Failure"); + System.out.println("TestObservable onNext: " + s1); + NbpObserver.onNext(s1); } + System.out.println("TestObservable onCompleted"); + NbpObserver.onComplete(); + } catch (Throwable e) { + System.out.println("TestObservable onError: " + e); + NbpObserver.onError(e); } - }); System.out.println("starting TestObservable thread"); t.start(); @@ -190,7 +172,7 @@ public void run() { @Test public void testBackpressure() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpObservable.range(0, 100000) .onErrorResumeNext(NbpObservable.just(1)) .observeOn(Schedulers.computation()) diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorOnErrorReturnTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorOnErrorReturnTest.java similarity index 72% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorOnErrorReturnTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorOnErrorReturnTest.java index ed2b423f33..fdeeaa7125 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorOnErrorReturnTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorOnErrorReturnTest.java @@ -35,16 +35,11 @@ public class NbpOperatorOnErrorReturnTest { public void testResumeNext() { TestObservable f = new TestObservable("one"); NbpObservable w = NbpObservable.create(f); - final AtomicReference capturedException = new AtomicReference(); - - NbpObservable NbpObservable = w.onErrorReturn(new Function() { - - @Override - public String apply(Throwable e) { - capturedException.set(e); - return "failure"; - } + final AtomicReference capturedException = new AtomicReference<>(); + NbpObservable NbpObservable = w.onErrorReturn(e -> { + capturedException.set(e); + return "failure"; }); @SuppressWarnings("unchecked") @@ -71,16 +66,11 @@ public String apply(Throwable e) { public void testFunctionThrowsError() { TestObservable f = new TestObservable("one"); NbpObservable w = NbpObservable.create(f); - final AtomicReference capturedException = new AtomicReference(); - - NbpObservable NbpObservable = w.onErrorReturn(new Function() { - - @Override - public String apply(Throwable e) { - capturedException.set(e); - throw new RuntimeException("exception from function"); - } + final AtomicReference capturedException = new AtomicReference<>(); + NbpObservable NbpObservable = w.onErrorReturn(e -> { + capturedException.set(e); + throw new RuntimeException("exception from function"); }); @SuppressWarnings("unchecked") @@ -109,28 +99,18 @@ public void testMapResumeAsyncNext() { // Introduce map function that fails intermittently (Map does not prevent this when the NbpObserver is a // rx.operator incl onErrorResumeNextViaObservable) - w = w.map(new Function() { - @Override - public String apply(String s) { - if ("fail".equals(s)) - throw new RuntimeException("Forced Failure"); - System.out.println("BadMapper:" + s); - return s; - } + w = w.map(s -> { + if ("fail".equals(s)) + throw new RuntimeException("Forced Failure"); + System.out.println("BadMapper:" + s); + return s; }); - NbpObservable NbpObservable = w.onErrorReturn(new Function() { - - @Override - public String apply(Throwable t1) { - return "resume"; - } - - }); + NbpObservable NbpObservable = w.onErrorReturn(t1 -> "resume"); @SuppressWarnings("unchecked") NbpObserver NbpObserver = mock(NbpObserver.class); - NbpTestSubscriber ts = new NbpTestSubscriber(NbpObserver); + NbpTestSubscriber ts = new NbpTestSubscriber<>(NbpObserver); NbpObservable.subscribe(ts); ts.awaitTerminalEvent(); @@ -144,16 +124,9 @@ public String apply(Throwable t1) { @Test public void testBackpressure() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpObservable.range(0, 100000) - .onErrorReturn(new Function() { - - @Override - public Integer apply(Throwable t1) { - return 1; - } - - }) + .onErrorReturn(t1 -> 1) .observeOn(Schedulers.computation()) .map(new Function() { int c = 0; @@ -190,22 +163,17 @@ public TestObservable(String... values) { public void accept(final NbpSubscriber NbpSubscriber) { NbpSubscriber.onSubscribe(EmptyDisposable.INSTANCE); System.out.println("TestObservable subscribed to ..."); - t = new Thread(new Runnable() { - - @Override - public void run() { - try { - System.out.println("running TestObservable thread"); - for (String s : values) { - System.out.println("TestObservable onNext: " + s); - NbpSubscriber.onNext(s); - } - throw new RuntimeException("Forced Failure"); - } catch (Throwable e) { - NbpSubscriber.onError(e); + t = new Thread(() -> { + try { + System.out.println("running TestObservable thread"); + for (String s : values) { + System.out.println("TestObservable onNext: " + s); + NbpSubscriber.onNext(s); } + throw new RuntimeException("Forced Failure"); + } catch (Throwable e) { + NbpSubscriber.onError(e); } - }); System.out.println("starting TestObservable thread"); t.start(); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorOnExceptionResumeNextViaObservableTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorOnExceptionResumeNextViaObservableTest.java similarity index 82% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorOnExceptionResumeNextViaObservableTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorOnExceptionResumeNextViaObservableTest.java index 4f95e6ac9b..5dd02ff0ec 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorOnExceptionResumeNextViaObservableTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorOnExceptionResumeNextViaObservableTest.java @@ -47,7 +47,7 @@ public void testResumeNextWithException() { fail(e.getMessage()); } - verify(NbpObserver).onSubscribe((Disposable)any()); + verify(NbpObserver).onSubscribe(any()); verify(NbpObserver, times(1)).onNext("one"); verify(NbpObserver, Mockito.never()).onNext("two"); verify(NbpObserver, Mockito.never()).onNext("three"); @@ -75,7 +75,7 @@ public void testResumeNextWithRuntimeException() { fail(e.getMessage()); } - verify(NbpObserver).onSubscribe((Disposable)any()); + verify(NbpObserver).onSubscribe(any()); verify(NbpObserver, times(1)).onNext("one"); verify(NbpObserver, Mockito.never()).onNext("two"); verify(NbpObserver, Mockito.never()).onNext("three"); @@ -103,7 +103,7 @@ public void testThrowablePassesThru() { fail(e.getMessage()); } - verify(NbpObserver).onSubscribe((Disposable)any()); + verify(NbpObserver).onSubscribe(any()); verify(NbpObserver, times(1)).onNext("one"); verify(NbpObserver, never()).onNext("two"); verify(NbpObserver, never()).onNext("three"); @@ -131,7 +131,7 @@ public void testErrorPassesThru() { fail(e.getMessage()); } - verify(NbpObserver).onSubscribe((Disposable)any()); + verify(NbpObserver).onSubscribe(any()); verify(NbpObserver, times(1)).onNext("one"); verify(NbpObserver, never()).onNext("two"); verify(NbpObserver, never()).onNext("three"); @@ -152,14 +152,11 @@ public void testMapResumeAsyncNext() { // Introduce map function that fails intermittently (Map does not prevent this when the NbpObserver is a // rx.operator incl onErrorResumeNextViaObservable) - w = w.map(new Function() { - @Override - public String apply(String s) { - if ("fail".equals(s)) - throw new RuntimeException("Forced Failure"); - System.out.println("BadMapper:" + s); - return s; - } + w = w.map(s -> { + if ("fail".equals(s)) + throw new RuntimeException("Forced Failure"); + System.out.println("BadMapper:" + s); + return s; }); NbpObservable NbpObservable = w.onExceptionResumeNext(resume); @@ -188,7 +185,7 @@ public String apply(String s) { @Test public void testBackpressure() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpObservable.range(0, 100000) .onExceptionResumeNext(NbpObservable.just(1)) .observeOn(Schedulers.computation()) @@ -228,32 +225,27 @@ public TestObservable(String... values) { public void accept(final NbpSubscriber NbpObserver) { NbpObserver.onSubscribe(EmptyDisposable.INSTANCE); System.out.println("TestObservable subscribed to ..."); - t = new Thread(new Runnable() { - - @Override - public void run() { - try { - System.out.println("running TestObservable thread"); - for (String s : values) { - if ("EXCEPTION".equals(s)) - throw new Exception("Forced Exception"); - else if ("RUNTIMEEXCEPTION".equals(s)) - throw new RuntimeException("Forced RuntimeException"); - else if ("ERROR".equals(s)) - throw new Error("Forced Error"); - else if ("THROWABLE".equals(s)) - throw new Throwable("Forced Throwable"); - System.out.println("TestObservable onNext: " + s); - NbpObserver.onNext(s); - } - System.out.println("TestObservable onCompleted"); - NbpObserver.onComplete(); - } catch (Throwable e) { - System.out.println("TestObservable onError: " + e); - NbpObserver.onError(e); + t = new Thread(() -> { + try { + System.out.println("running TestObservable thread"); + for (String s : values) { + if ("EXCEPTION".equals(s)) + throw new Exception("Forced Exception"); + else if ("RUNTIMEEXCEPTION".equals(s)) + throw new RuntimeException("Forced RuntimeException"); + else if ("ERROR".equals(s)) + throw new Error("Forced Error"); + else if ("THROWABLE".equals(s)) + throw new Throwable("Forced Throwable"); + System.out.println("TestObservable onNext: " + s); + NbpObserver.onNext(s); } + System.out.println("TestObservable onCompleted"); + NbpObserver.onComplete(); + } catch (Throwable e) { + System.out.println("TestObservable onError: " + e); + NbpObserver.onError(e); } - }); System.out.println("starting TestObservable thread"); t.start(); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorPublishTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorPublishTest.java similarity index 73% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorPublishTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorPublishTest.java index f86c7e9472..62f0bd1bd0 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorPublishTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorPublishTest.java @@ -42,14 +42,10 @@ public void testPublish() throws InterruptedException { @Override public void accept(final NbpSubscriber NbpObserver) { NbpObserver.onSubscribe(EmptyDisposable.INSTANCE); - new Thread(new Runnable() { - - @Override - public void run() { - counter.incrementAndGet(); - NbpObserver.onNext("one"); - NbpObserver.onComplete(); - } + new Thread(() -> { + counter.incrementAndGet(); + NbpObserver.onNext("one"); + NbpObserver.onComplete(); }).start(); } }).publish(); @@ -57,23 +53,15 @@ public void run() { final CountDownLatch latch = new CountDownLatch(2); // subscribe once - o.subscribe(new Consumer() { - - @Override - public void accept(String v) { - assertEquals("one", v); - latch.countDown(); - } + o.subscribe(v -> { + assertEquals("one", v); + latch.countDown(); }); // subscribe again - o.subscribe(new Consumer() { - - @Override - public void accept(String v) { - assertEquals("one", v); - latch.countDown(); - } + o.subscribe(v -> { + assertEquals("one", v); + latch.countDown(); }); Disposable s = o.connect(); @@ -91,12 +79,7 @@ public void accept(String v) { public void testBackpressureFastSlow() { NbpConnectableObservable is = NbpObservable.range(1, Observable.bufferSize() * 2).publish(); NbpObservable fast = is.observeOn(Schedulers.computation()) - .doOnComplete(new Runnable() { - @Override - public void run() { - System.out.println("^^^^^^^^^^^^^ completed FAST"); - } - }); + .doOnComplete(() -> System.out.println("^^^^^^^^^^^^^ completed FAST")); NbpObservable slow = is.observeOn(Schedulers.computation()).map(new Function() { int c = 0; @@ -113,16 +96,9 @@ public Integer apply(Integer i) { return i; } - }).doOnComplete(new Runnable() { - - @Override - public void run() { - System.out.println("^^^^^^^^^^^^^ completed SLOW"); - } + }).doOnComplete(() -> System.out.println("^^^^^^^^^^^^^ completed SLOW")); - }); - - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpObservable.merge(fast, slow).subscribe(ts); is.connect(); ts.awaitTerminalEvent(); @@ -134,30 +110,9 @@ public void run() { @Test public void testTakeUntilWithPublishedStreamUsingSelector() { final AtomicInteger emitted = new AtomicInteger(); - NbpObservable xs = NbpObservable.range(0, Observable.bufferSize() * 2).doOnNext(new Consumer() { - - @Override - public void accept(Integer t1) { - emitted.incrementAndGet(); - } - - }); - NbpTestSubscriber ts = new NbpTestSubscriber(); - xs.publish(new Function, NbpObservable>() { - - @Override - public NbpObservable apply(NbpObservable xs) { - return xs.takeUntil(xs.skipWhile(new Predicate() { - - @Override - public boolean test(Integer i) { - return i <= 3; - } - - })); - } - - }).subscribe(ts); + NbpObservable xs = NbpObservable.range(0, Observable.bufferSize() * 2).doOnNext(t1 -> emitted.incrementAndGet()); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); + xs.publish(xs1 -> xs1.takeUntil(xs1.skipWhile(i -> i <= 3))).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); ts.assertValues(0, 1, 2, 3); @@ -169,16 +124,9 @@ public boolean test(Integer i) { @Test public void testTakeUntilWithPublishedStream() { NbpObservable xs = NbpObservable.range(0, Observable.bufferSize() * 2); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpConnectableObservable xsp = xs.publish(); - xsp.takeUntil(xsp.skipWhile(new Predicate() { - - @Override - public boolean test(Integer i) { - return i <= 3; - } - - })).subscribe(ts); + xsp.takeUntil(xsp.skipWhile(i -> i <= 3)).subscribe(ts); xsp.connect(); System.out.println(ts.values()); } @@ -188,46 +136,25 @@ public void testBackpressureTwoConsumers() { final AtomicInteger sourceEmission = new AtomicInteger(); final AtomicBoolean sourceUnsubscribed = new AtomicBoolean(); final NbpObservable source = NbpObservable.range(1, 100) - .doOnNext(new Consumer() { - @Override - public void accept(Integer t1) { - sourceEmission.incrementAndGet(); - } - }) - .doOnCancel(new Runnable() { - @Override - public void run() { - sourceUnsubscribed.set(true); - } - }).share(); - ; + .doOnNext(t1 -> sourceEmission.incrementAndGet()) + .doOnCancel(() -> sourceUnsubscribed.set(true)).share(); final AtomicBoolean child1Unsubscribed = new AtomicBoolean(); final AtomicBoolean child2Unsubscribed = new AtomicBoolean(); - final NbpTestSubscriber ts2 = new NbpTestSubscriber(); + final NbpTestSubscriber ts2 = new NbpTestSubscriber<>(); final NbpTestSubscriber ts1 = new NbpTestSubscriber() { @Override public void onNext(Integer t) { if (valueCount() == 2) { - source.doOnCancel(new Runnable() { - @Override - public void run() { - child2Unsubscribed.set(true); - } - }).take(5).subscribe(ts2); + source.doOnCancel(() -> child2Unsubscribed.set(true)).take(5).subscribe(ts2); } super.onNext(t); } }; - source.doOnCancel(new Runnable() { - @Override - public void run() { - child1Unsubscribed.set(true); - } - }).take(5) + source.doOnCancel(() -> child1Unsubscribed.set(true)).take(5) .subscribe(ts1); ts1.awaitTerminalEvent(); @@ -253,7 +180,7 @@ public void testConnectWithNoSubscriber() { co.connect(); // Emit 0 scheduler.advanceTimeBy(15, TimeUnit.MILLISECONDS); - NbpTestSubscriber NbpSubscriber = new NbpTestSubscriber(); + NbpTestSubscriber NbpSubscriber = new NbpTestSubscriber<>(); co.subscribe(NbpSubscriber); // Emit 1 and 2 scheduler.advanceTimeBy(50, TimeUnit.MILLISECONDS); @@ -266,7 +193,7 @@ public void testConnectWithNoSubscriber() { public void testSubscribeAfterDisconnectThenConnect() { NbpConnectableObservable source = NbpObservable.just(1).publish(); - NbpTestSubscriber ts1 = new NbpTestSubscriber(); + NbpTestSubscriber ts1 = new NbpTestSubscriber<>(); source.subscribe(ts1); @@ -276,7 +203,7 @@ public void testSubscribeAfterDisconnectThenConnect() { ts1.assertNoErrors(); ts1.assertTerminated(); - NbpTestSubscriber ts2 = new NbpTestSubscriber(); + NbpTestSubscriber ts2 = new NbpTestSubscriber<>(); source.subscribe(ts2); @@ -294,7 +221,7 @@ public void testSubscribeAfterDisconnectThenConnect() { public void testNoSubscriberRetentionOnCompleted() { NbpOperatorPublish source = (NbpOperatorPublish)NbpObservable.just(1).publish(); - NbpTestSubscriber ts1 = new NbpTestSubscriber(); + NbpTestSubscriber ts1 = new NbpTestSubscriber<>(); source.unsafeSubscribe(ts1); @@ -375,9 +302,9 @@ public void testObserveOn() { NbpObservable obs = co.observeOn(Schedulers.computation()); for (int i = 0; i < 1000; i++) { for (int j = 1; j < 6; j++) { - List> tss = new ArrayList>(); + List> tss = new ArrayList<>(); for (int k = 1; k < j; k++) { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); tss.add(ts); obs.subscribe(ts); } diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorReduceTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorReduceTest.java similarity index 71% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorReduceTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorReduceTest.java index 057671c140..580d99b8c9 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorReduceTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorReduceTest.java @@ -32,23 +32,13 @@ public void before() { NbpObserver = TestHelper.mockNbpSubscriber(); } - BiFunction sum = new BiFunction() { - @Override - public Integer apply(Integer t1, Integer t2) { - return t1 + t2; - } - }; + BiFunction sum = (t1, t2) -> t1 + t2; @Test public void testAggregateAsIntSum() { NbpObservable result = NbpObservable.just(1, 2, 3, 4, 5).reduce(0, sum) - .map(new Function() { - @Override - public Integer apply(Integer v) { - return v; - } - }); + .map(v -> v); result.subscribe(NbpObserver); @@ -61,12 +51,7 @@ public Integer apply(Integer v) { public void testAggregateAsIntSumSourceThrows() { NbpObservable result = NbpObservable.concat(NbpObservable.just(1, 2, 3, 4, 5), NbpObservable. error(new TestException())) - .reduce(0, sum).map(new Function() { - @Override - public Integer apply(Integer v) { - return v; - } - }); + .reduce(0, sum).map(v -> v); result.subscribe(NbpObserver); @@ -77,20 +62,12 @@ public Integer apply(Integer v) { @Test public void testAggregateAsIntSumAccumulatorThrows() { - BiFunction sumErr = new BiFunction() { - @Override - public Integer apply(Integer t1, Integer t2) { - throw new TestException(); - } + BiFunction sumErr = (t1, t2) -> { + throw new TestException(); }; NbpObservable result = NbpObservable.just(1, 2, 3, 4, 5) - .reduce(0, sumErr).map(new Function() { - @Override - public Integer apply(Integer v) { - return v; - } - }); + .reduce(0, sumErr).map(v -> v); result.subscribe(NbpObserver); @@ -102,12 +79,8 @@ public Integer apply(Integer v) { @Test public void testAggregateAsIntSumResultSelectorThrows() { - Function error = new Function() { - - @Override - public Integer apply(Integer t1) { - throw new TestException(); - } + Function error = t1 -> { + throw new TestException(); }; NbpObservable result = NbpObservable.just(1, 2, 3, 4, 5) diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorRepeatTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorRepeatTest.java similarity index 86% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorRepeatTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorRepeatTest.java index 271c76d19d..2569b0757f 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorRepeatTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorRepeatTest.java @@ -78,18 +78,13 @@ public void accept(NbpSubscriber sub) { } }).subscribeOn(Schedulers.newThread()); - Object[] ys = oi.repeat().subscribeOn(Schedulers.newThread()).map(new Function() { - - @Override - public Integer apply(Integer t1) { - try { - Thread.sleep(50); - } catch (InterruptedException e) { - e.printStackTrace(); - } - return t1; + Object[] ys = oi.repeat().subscribeOn(Schedulers.newThread()).map(t1 -> { + try { + Thread.sleep(50); + } catch (InterruptedException e) { + e.printStackTrace(); } - + return t1; }).take(4).toList().toBlocking().last().toArray(); assertEquals(2, counter.get()); @@ -160,7 +155,7 @@ public void testRepeatAndDistinctUnbounded() { .repeat(3) .distinct(); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); src.subscribe(ts); @@ -172,18 +167,15 @@ public void testRepeatAndDistinctUnbounded() { /** Issue #2844: wrong target of request. */ @Test(timeout = 3000) public void testRepeatRetarget() { - final List concatBase = new ArrayList(); - NbpTestSubscriber ts = new NbpTestSubscriber(); + final List concatBase = new ArrayList<>(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpObservable.just(1, 2) .repeat(5) - .concatMap(new Function>() { - @Override - public NbpObservable apply(Integer x) { - System.out.println("testRepeatRetarget -> " + x); - concatBase.add(x); - return NbpObservable.empty() - .delay(200, TimeUnit.MILLISECONDS); - } + .concatMap(x -> { + System.out.println("testRepeatRetarget -> " + x); + concatBase.add(x); + return NbpObservable.empty() + .delay(200, TimeUnit.MILLISECONDS); }) .subscribe(ts); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorReplayTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorReplayTest.java similarity index 86% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorReplayTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorReplayTest.java index e7412b1e81..aa88e188ed 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorReplayTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorReplayTest.java @@ -181,23 +181,9 @@ public void testWindowedReplay() { @Test public void testReplaySelector() { - final Function dbl = new Function() { + final Function dbl = t1 -> t1 * 2; - @Override - public Integer apply(Integer t1) { - return t1 * 2; - } - - }; - - Function, NbpObservable> selector = new Function, NbpObservable>() { - - @Override - public NbpObservable apply(NbpObservable t1) { - return t1.map(dbl); - } - - }; + Function, NbpObservable> selector = t1 -> t1.map(dbl); NbpPublishSubject source = NbpPublishSubject.create(); @@ -243,23 +229,9 @@ public NbpObservable apply(NbpObservable t1) { @Test public void testBufferedReplaySelector() { - final Function dbl = new Function() { - - @Override - public Integer apply(Integer t1) { - return t1 * 2; - } - - }; - - Function, NbpObservable> selector = new Function, NbpObservable>() { - - @Override - public NbpObservable apply(NbpObservable t1) { - return t1.map(dbl); - } + final Function dbl = t1 -> t1 * 2; - }; + Function, NbpObservable> selector = t1 -> t1.map(dbl); NbpPublishSubject source = NbpPublishSubject.create(); @@ -303,23 +275,9 @@ public NbpObservable apply(NbpObservable t1) { @Test public void testWindowedReplaySelector() { - final Function dbl = new Function() { - - @Override - public Integer apply(Integer t1) { - return t1 * 2; - } - - }; - - Function, NbpObservable> selector = new Function, NbpObservable>() { - - @Override - public NbpObservable apply(NbpObservable t1) { - return t1.map(dbl); - } + final Function dbl = t1 -> t1 * 2; - }; + Function, NbpObservable> selector = t1 -> t1.map(dbl); TestScheduler scheduler = new TestScheduler(); @@ -459,45 +417,17 @@ public void testWindowedReplayError() { public void testSynchronousDisconnect() { final AtomicInteger effectCounter = new AtomicInteger(); NbpObservable source = NbpObservable.just(1, 2, 3, 4) - .doOnNext(new Consumer() { - @Override - public void accept(Integer v) { - effectCounter.incrementAndGet(); - System.out.println("Sideeffect #" + v); - } + .doOnNext(v -> { + effectCounter.incrementAndGet(); + System.out.println("Sideeffect #" + v); }); - NbpObservable result = source.replay( - new Function, NbpObservable>() { - @Override - public NbpObservable apply(NbpObservable o) { - return o.take(2); - } - }); + NbpObservable result = source.replay(o -> o.take(2)); for (int i = 1; i < 3; i++) { effectCounter.set(0); System.out.printf("- %d -%n", i); - result.subscribe(new Consumer() { - - @Override - public void accept(Integer t1) { - System.out.println(t1); - } - - }, new Consumer() { - - @Override - public void accept(Throwable t1) { - t1.printStackTrace(); - } - }, - new Runnable() { - @Override - public void run() { - System.out.println("Done"); - } - }); + result.subscribe(System.out::println, Throwable::printStackTrace, () -> System.out.println("Done")); assertEquals(2, effectCounter.get()); } } @@ -531,8 +461,8 @@ public void testIssue2191_UnsubscribeSource() { replay.subscribe(spiedSubscriberAfterConnect); replay.subscribe(spiedSubscriberAfterConnect); - verify(spiedSubscriberBeforeConnect, times(2)).onSubscribe((Disposable)any()); - verify(spiedSubscriberAfterConnect, times(2)).onSubscribe((Disposable)any()); + verify(spiedSubscriberBeforeConnect, times(2)).onSubscribe(any()); + verify(spiedSubscriberAfterConnect, times(2)).onSubscribe(any()); // verify interactions verify(sourceNext, times(1)).accept(1); @@ -579,8 +509,8 @@ public void testIssue2191_SchedulerUnsubscribe() throws Exception { replay.connect(); replay.subscribe(mockObserverAfterConnect); - verify(mockObserverBeforeConnect).onSubscribe((Disposable)any()); - verify(mockObserverAfterConnect).onSubscribe((Disposable)any()); + verify(mockObserverBeforeConnect).onSubscribe(any()); + verify(mockObserverAfterConnect).onSubscribe(any()); mockScheduler.advanceTimeBy(1, TimeUnit.SECONDS); @@ -637,8 +567,8 @@ public void testIssue2191_SchedulerUnsubscribeOnError() throws Exception { replay.connect(); replay.subscribe(mockObserverAfterConnect); - verify(mockObserverBeforeConnect).onSubscribe((Disposable)any()); - verify(mockObserverAfterConnect).onSubscribe((Disposable)any()); + verify(mockObserverBeforeConnect).onSubscribe(any()); + verify(mockObserverAfterConnect).onSubscribe(any()); mockScheduler.advanceTimeBy(1, TimeUnit.SECONDS); @@ -712,14 +642,14 @@ public void dispose() { @Test public void testBoundedReplayBuffer() { - BoundedReplayBuffer buf = new BoundedReplayBuffer(); + BoundedReplayBuffer buf = new BoundedReplayBuffer<>(); buf.addLast(new Node(1)); buf.addLast(new Node(2)); buf.addLast(new Node(3)); buf.addLast(new Node(4)); buf.addLast(new Node(5)); - List values = new ArrayList(); + List values = new ArrayList<>(); buf.collect(values); Assert.assertEquals(Arrays.asList(1, 2, 3, 4, 5), values); @@ -743,8 +673,8 @@ public void testBoundedReplayBuffer() { @Test public void testTimedAndSizedTruncation() { TestScheduler test = Schedulers.test(); - SizeAndTimeBoundReplayBuffer buf = new SizeAndTimeBoundReplayBuffer(2, 2000, TimeUnit.MILLISECONDS, test); - List values = new ArrayList(); + SizeAndTimeBoundReplayBuffer buf = new SizeAndTimeBoundReplayBuffer<>(2, 2000, TimeUnit.MILLISECONDS, test); + List values = new ArrayList<>(); buf.next(1); test.advanceTimeBy(1, TimeUnit.SECONDS); @@ -781,7 +711,7 @@ public void testTimedAndSizedTruncation() { public void testColdReplayNoBackpressure() { NbpObservable source = NbpObservable.range(0, 1000).replay().autoConnect(); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); source.subscribe(ts); @@ -803,15 +733,11 @@ public void testCache() throws InterruptedException { @Override public void accept(final NbpSubscriber NbpObserver) { NbpObserver.onSubscribe(EmptyDisposable.INSTANCE); - new Thread(new Runnable() { - - @Override - public void run() { - counter.incrementAndGet(); - System.out.println("published NbpObservable being executed"); - NbpObserver.onNext("one"); - NbpObserver.onComplete(); - } + new Thread(() -> { + counter.incrementAndGet(); + System.out.println("published NbpObservable being executed"); + NbpObserver.onNext("one"); + NbpObserver.onComplete(); }).start(); } }).replay().autoConnect(); @@ -820,25 +746,17 @@ public void run() { final CountDownLatch latch = new CountDownLatch(2); // subscribe once - o.subscribe(new Consumer() { - - @Override - public void accept(String v) { - assertEquals("one", v); - System.out.println("v: " + v); - latch.countDown(); - } + o.subscribe(v -> { + assertEquals("one", v); + System.out.println("v: " + v); + latch.countDown(); }); // subscribe again - o.subscribe(new Consumer() { - - @Override - public void accept(String v) { - assertEquals("one", v); - System.out.println("v: " + v); - latch.countDown(); - } + o.subscribe(v -> { + assertEquals("one", v); + System.out.println("v: " + v); + latch.countDown(); }); if (!latch.await(1000, TimeUnit.MILLISECONDS)) { @@ -859,7 +777,7 @@ public void testUnsubscribeSource() { @Test public void testTake() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpObservable cached = NbpObservable.range(1, 100).replay().autoConnect(); cached.take(10).subscribe(ts); @@ -875,7 +793,7 @@ public void testTake() { public void testAsync() { NbpObservable source = NbpObservable.range(1, 10000); for (int i = 0; i < 100; i++) { - NbpTestSubscriber ts1 = new NbpTestSubscriber(); + NbpTestSubscriber ts1 = new NbpTestSubscriber<>(); NbpObservable cached = source.replay().autoConnect(); @@ -886,7 +804,7 @@ public void testAsync() { ts1.assertTerminated(); assertEquals(10000, ts1.values().size()); - NbpTestSubscriber ts2 = new NbpTestSubscriber(); + NbpTestSubscriber ts2 = new NbpTestSubscriber<>(); cached.observeOn(Schedulers.computation()).subscribe(ts2); ts2.awaitTerminalEvent(2, TimeUnit.SECONDS); @@ -904,14 +822,14 @@ public void testAsyncComeAndGo() { NbpObservable output = cached.observeOn(Schedulers.computation()); - List> list = new ArrayList>(100); + List> list = new ArrayList<>(100); for (int i = 0; i < 100; i++) { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); list.add(ts); output.skip(i * 10).take(10).subscribe(ts); } - List expected = new ArrayList(); + List expected = new ArrayList<>(); for (int i = 0; i < 10; i++) { expected.add((long)(i - 10)); } @@ -945,7 +863,7 @@ public void accept(NbpSubscriber t) { } }); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); firehose.replay().autoConnect().observeOn(Schedulers.computation()).takeLast(100).subscribe(ts); ts.awaitTerminalEvent(3, TimeUnit.SECONDS); @@ -962,14 +880,14 @@ public void testValuesAndThenError() { .replay().autoConnect(); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); source.subscribe(ts); ts.assertValues(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); ts.assertNotComplete(); Assert.assertEquals(1, ts.errors().size()); - NbpTestSubscriber ts2 = new NbpTestSubscriber(); + NbpTestSubscriber ts2 = new NbpTestSubscriber<>(); source.subscribe(ts2); ts2.assertValues(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); @@ -982,12 +900,7 @@ public void unsafeChildThrows() { final AtomicInteger count = new AtomicInteger(); NbpObservable source = NbpObservable.range(1, 100) - .doOnNext(new Consumer() { - @Override - public void accept(Integer t) { - count.getAndIncrement(); - } - }) + .doOnNext(t -> count.getAndIncrement()) .replay().autoConnect(); NbpTestSubscriber ts = new NbpTestSubscriber() { diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorRetryTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorRetryTest.java similarity index 71% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorRetryTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorRetryTest.java index 01e9790ed5..ab86442048 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorRetryTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorRetryTest.java @@ -61,32 +61,18 @@ public void accept(NbpSubscriber t1) { } }); - NbpTestSubscriber ts = new NbpTestSubscriber(consumer); - producer.retryWhen(new Function, NbpObservable>() { - - @Override - public NbpObservable apply(NbpObservable attempts) { - // Worker w = Schedulers.computation().createWorker(); - return attempts - .map(new Function() { - @Override - public Tuple apply(Throwable n) { - return new Tuple(new Long(1), n); - }}) - .scan(new BiFunction(){ - @Override - public Tuple apply(Tuple t, Tuple n) { - return new Tuple(t.count + n.count, n.n); - }}) - .flatMap(new Function>() { - @Override - public NbpObservable apply(Tuple t) { - System.out.println("Retry # "+t.count); - return t.count > 20 ? - NbpObservable.error(t.n) : - NbpObservable.timer(t.count *1L, TimeUnit.MILLISECONDS); - }}).cast(Object.class); - } + NbpTestSubscriber ts = new NbpTestSubscriber<>(consumer); + producer.retryWhen(attempts -> { + // Worker w = Schedulers.computation().createWorker(); + return attempts + .map(n -> new Tuple(new Long(1), n)) + .scan((t, n) -> new Tuple(t.count + n.count, n.n)) + .flatMap(t -> { + System.out.println("Retry # "+t.count); + return t.count > 20 ? + NbpObservable.error(t.n) : + NbpObservable.timer(t.count *1L, TimeUnit.MILLISECONDS); + }).cast(Object.class); }).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); @@ -114,7 +100,7 @@ public void testRetryIndefinitely() { NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); int NUM_RETRIES = 20; NbpObservable origin = NbpObservable.create(new FuncWithErrors(NUM_RETRIES)); - origin.retry().unsafeSubscribe(new NbpTestSubscriber(NbpObserver)); + origin.retry().unsafeSubscribe(new NbpTestSubscriber<>(NbpObserver)); InOrder inOrder = inOrder(NbpObserver); // should show 3 attempts @@ -133,27 +119,10 @@ public void testSchedulingNotificationHandler() { NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); int NUM_RETRIES = 2; NbpObservable origin = NbpObservable.create(new FuncWithErrors(NUM_RETRIES)); - NbpTestSubscriber NbpSubscriber = new NbpTestSubscriber(NbpObserver); - origin.retryWhen(new Function, NbpObservable>() { - @Override - public NbpObservable apply(NbpObservable t1) { - return t1 - .observeOn(Schedulers.computation()) - .map(new Function() { - @Override - public Object apply(Throwable t1) { - return 1; - } - }).startWith(1); - } - }) - .doOnError(new Consumer() { - @Override - public void accept(Throwable e) { - e.printStackTrace(); - } - }) - .subscribe(NbpSubscriber); + NbpTestSubscriber NbpSubscriber = new NbpTestSubscriber<>(NbpObserver); + origin.retryWhen(t1 -> t1.observeOn(Schedulers.computation()).map(t11 -> 1).startWith(1)) + .doOnError(Throwable::printStackTrace) + .subscribe(NbpSubscriber); NbpSubscriber.awaitTerminalEvent(); InOrder inOrder = inOrder(NbpObserver); @@ -173,18 +142,7 @@ public void testOnNextFromNotificationHandler() { NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); int NUM_RETRIES = 2; NbpObservable origin = NbpObservable.create(new FuncWithErrors(NUM_RETRIES)); - origin.retryWhen(new Function, NbpObservable>() { - @Override - public NbpObservable apply(NbpObservable t1) { - return t1.map(new Function() { - - @Override - public Integer apply(Throwable t1) { - return 0; - } - }).startWith(0).cast(Object.class); - } - }).subscribe(NbpObserver); + origin.retryWhen(t1 -> t1.map(t11 -> 0).startWith(0).cast(Object.class)).subscribe(NbpObserver); InOrder inOrder = inOrder(NbpObserver); // should show 3 attempts @@ -202,13 +160,8 @@ public Integer apply(Throwable t1) { public void testOnCompletedFromNotificationHandler() { NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); NbpObservable origin = NbpObservable.create(new FuncWithErrors(1)); - NbpTestSubscriber NbpSubscriber = new NbpTestSubscriber(NbpObserver); - origin.retryWhen(new Function, NbpObservable>() { - @Override - public NbpObservable apply(NbpObservable t1) { - return NbpObservable.empty(); - } - }).subscribe(NbpSubscriber); + NbpTestSubscriber NbpSubscriber = new NbpTestSubscriber<>(NbpObserver); + origin.retryWhen(t1 -> NbpObservable.empty()).subscribe(NbpSubscriber); InOrder inOrder = inOrder(NbpObserver); inOrder.verify(NbpObserver).onSubscribe((Disposable)notNull()); @@ -223,12 +176,7 @@ public NbpObservable apply(NbpObservable t1) { public void testOnErrorFromNotificationHandler() { NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); NbpObservable origin = NbpObservable.create(new FuncWithErrors(2)); - origin.retryWhen(new Function, NbpObservable>() { - @Override - public NbpObservable apply(NbpObservable t1) { - return NbpObservable.error(new RuntimeException()); - } - }).subscribe(NbpObserver); + origin.retryWhen(t1 -> NbpObservable.error(new RuntimeException())).subscribe(NbpObserver); InOrder inOrder = inOrder(NbpObserver); inOrder.verify(NbpObserver).onSubscribe((Disposable)notNull()); @@ -242,28 +190,15 @@ public NbpObservable apply(NbpObservable t1) { @Test public void testSingleSubscriptionOnFirst() throws Exception { final AtomicInteger inc = new AtomicInteger(0); - NbpOnSubscribe onSubscribe = new NbpOnSubscribe() { - @Override - public void accept(NbpSubscriber NbpSubscriber) { - NbpSubscriber.onSubscribe(EmptyDisposable.INSTANCE); - final int emit = inc.incrementAndGet(); - NbpSubscriber.onNext(emit); - NbpSubscriber.onComplete(); - } + NbpOnSubscribe onSubscribe = NbpSubscriber -> { + NbpSubscriber.onSubscribe(EmptyDisposable.INSTANCE); + final int emit = inc.incrementAndGet(); + NbpSubscriber.onNext(emit); + NbpSubscriber.onComplete(); }; int first = NbpObservable.create(onSubscribe) - .retryWhen(new Function, NbpObservable>() { - @Override - public NbpObservable apply(NbpObservable attempt) { - return attempt.zipWith(NbpObservable.just(1), new BiFunction() { - @Override - public Void apply(Throwable o, Integer integer) { - return null; - } - }); - } - }) + .retryWhen(attempt -> attempt.zipWith(NbpObservable.just(1), (o, integer) -> null)) .toBlocking() .first(); @@ -411,12 +346,7 @@ public void accept(final NbpSubscriber o) { public void testUnsubscribeFromRetry() { NbpPublishSubject subject = NbpPublishSubject.create(); final AtomicInteger count = new AtomicInteger(0); - Disposable sub = subject.retry().subscribe(new Consumer() { - @Override - public void accept(Integer n) { - count.incrementAndGet(); - } - }); + Disposable sub = subject.retry().subscribe(n -> count.incrementAndGet()); subject.onNext(1); sub.dispose(); subject.onNext(2); @@ -426,18 +356,9 @@ public void accept(Integer n) { @Test public void testRetryAllowsSubscriptionAfterAllSubscriptionsUnsubscribed() throws InterruptedException { final AtomicInteger subsCount = new AtomicInteger(0); - NbpOnSubscribe onSubscribe = new NbpOnSubscribe() { - @Override - public void accept(NbpSubscriber s) { - subsCount.incrementAndGet(); - s.onSubscribe(new Disposable() { - @Override - public void dispose() { - subsCount.decrementAndGet(); - } - }); - - } + NbpOnSubscribe onSubscribe = s -> { + subsCount.incrementAndGet(); + s.onSubscribe(subsCount::decrementAndGet); }; NbpObservable stream = NbpObservable.create(onSubscribe); NbpObservable streamWithRetry = stream.retry(); @@ -453,26 +374,23 @@ public void dispose() { public void testSourceObservableCallsUnsubscribe() throws InterruptedException { final AtomicInteger subsCount = new AtomicInteger(0); - final NbpTestSubscriber ts = new NbpTestSubscriber(); + final NbpTestSubscriber ts = new NbpTestSubscriber<>(); - NbpOnSubscribe onSubscribe = new NbpOnSubscribe() { - @Override - public void accept(NbpSubscriber s) { - BooleanSubscription bs = new BooleanSubscription(); - // if isUnsubscribed is true that means we have a bug such as - // https://github.com/ReactiveX/RxJava/issues/1024 - if (!bs.isCancelled()) { - subsCount.incrementAndGet(); - s.onError(new RuntimeException("failed")); - // it unsubscribes the child directly - // this simulates various error/completion scenarios that could occur - // or just a source that proactively triggers cleanup - // FIXME can't unsubscribe child + NbpOnSubscribe onSubscribe = s -> { + BooleanSubscription bs = new BooleanSubscription(); + // if isUnsubscribed is true that means we have a bug such as + // https://github.com/ReactiveX/RxJava/issues/1024 + if (!bs.isCancelled()) { + subsCount.incrementAndGet(); + s.onError(new RuntimeException("failed")); + // it unsubscribes the child directly + // this simulates various error/completion scenarios that could occur + // or just a source that proactively triggers cleanup + // FIXME can't unsubscribe child // s.unsubscribe(); - bs.cancel(); - } else { - s.onError(new RuntimeException()); - } + bs.cancel(); + } else { + s.onError(new RuntimeException()); } }; @@ -484,15 +402,12 @@ public void accept(NbpSubscriber s) { public void testSourceObservableRetry1() throws InterruptedException { final AtomicInteger subsCount = new AtomicInteger(0); - final NbpTestSubscriber ts = new NbpTestSubscriber(); + final NbpTestSubscriber ts = new NbpTestSubscriber<>(); - NbpOnSubscribe onSubscribe = new NbpOnSubscribe() { - @Override - public void accept(NbpSubscriber s) { - s.onSubscribe(EmptyDisposable.INSTANCE); - subsCount.incrementAndGet(); - s.onError(new RuntimeException("failed")); - } + NbpOnSubscribe onSubscribe = s -> { + s.onSubscribe(EmptyDisposable.INSTANCE); + subsCount.incrementAndGet(); + s.onError(new RuntimeException("failed")); }; NbpObservable.create(onSubscribe).retry(1).subscribe(ts); @@ -503,15 +418,12 @@ public void accept(NbpSubscriber s) { public void testSourceObservableRetry0() throws InterruptedException { final AtomicInteger subsCount = new AtomicInteger(0); - final NbpTestSubscriber ts = new NbpTestSubscriber(); + final NbpTestSubscriber ts = new NbpTestSubscriber<>(); - NbpOnSubscribe onSubscribe = new NbpOnSubscribe() { - @Override - public void accept(NbpSubscriber s) { - s.onSubscribe(EmptyDisposable.INSTANCE); - subsCount.incrementAndGet(); - s.onError(new RuntimeException("failed")); - } + NbpOnSubscribe onSubscribe = s -> { + s.onSubscribe(EmptyDisposable.INSTANCE); + subsCount.incrementAndGet(); + s.onError(new RuntimeException("failed")); }; NbpObservable.create(onSubscribe).retry(0).subscribe(ts); @@ -534,12 +446,9 @@ public SlowObservable(int emitDelay, int countNext) { @Override public void accept(final NbpSubscriber NbpSubscriber) { final AtomicBoolean terminate = new AtomicBoolean(false); - NbpSubscriber.onSubscribe(new Disposable() { - @Override - public void dispose() { - terminate.set(true); - active.decrementAndGet(); - } + NbpSubscriber.onSubscribe(() -> { + terminate.set(true); + active.decrementAndGet(); }); efforts.getAndIncrement(); active.getAndIncrement(); @@ -618,7 +527,7 @@ public void testUnsubscribeAfterError() { SlowObservable so = new SlowObservable(100, 0); NbpObservable o = NbpObservable.create(so).retry(5); - AsyncObserver async = new AsyncObserver(NbpObserver); + AsyncObserver async = new AsyncObserver<>(NbpObserver); o.subscribe(async); @@ -643,7 +552,7 @@ public void testTimeoutWithRetry() { SlowObservable so = new SlowObservable(100, 10); NbpObservable o = NbpObservable.create(so).timeout(80, TimeUnit.MILLISECONDS).retry(5); - AsyncObserver async = new AsyncObserver(NbpObserver); + AsyncObserver async = new AsyncObserver<>(NbpObserver); o.subscribe(async); @@ -665,7 +574,7 @@ public void testRetryWithBackpressure() throws InterruptedException { for (int i = 0; i < 400; i++) { NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); NbpObservable origin = NbpObservable.create(new FuncWithErrors(NUM_RETRIES)); - NbpTestSubscriber ts = new NbpTestSubscriber(NbpObserver); + NbpTestSubscriber ts = new NbpTestSubscriber<>(NbpObserver); origin.retry().observeOn(Schedulers.computation()).unsafeSubscribe(ts); ts.awaitTerminalEvent(5, TimeUnit.SECONDS); @@ -696,38 +605,35 @@ public void testRetryWithBackpressureParallel() throws InterruptedException { } final AtomicInteger timeouts = new AtomicInteger(); - final Map> data = new ConcurrentHashMap>(); + final Map> data = new ConcurrentHashMap<>(); int m = 5000; final CountDownLatch cdl = new CountDownLatch(m); for (int i = 0; i < m; i++) { final int j = i; - exec.execute(new Runnable() { - @Override - public void run() { - final AtomicInteger nexts = new AtomicInteger(); - try { - NbpObservable origin = NbpObservable.create(new FuncWithErrors(NUM_RETRIES)); - NbpTestSubscriber ts = new NbpTestSubscriber(); - origin.retry() - .observeOn(Schedulers.computation()).unsafeSubscribe(ts); - ts.awaitTerminalEvent(2500, TimeUnit.MILLISECONDS); - List onNextEvents = new ArrayList(ts.values()); - if (onNextEvents.size() != NUM_RETRIES + 2) { - for (Throwable t : ts.errors()) { - onNextEvents.add(t.toString()); - } - for (long err = ts.completions(); err != 0; err--) { - onNextEvents.add("onCompleted"); - } - data.put(j, onNextEvents); + exec.execute(() -> { + final AtomicInteger nexts = new AtomicInteger(); + try { + NbpObservable origin = NbpObservable.create(new FuncWithErrors(NUM_RETRIES)); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); + origin.retry() + .observeOn(Schedulers.computation()).unsafeSubscribe(ts); + ts.awaitTerminalEvent(2500, TimeUnit.MILLISECONDS); + List onNextEvents = new ArrayList<>(ts.values()); + if (onNextEvents.size() != NUM_RETRIES + 2) { + for (Throwable t : ts.errors()) { + onNextEvents.add(t.toString()); + } + for (long err = ts.completions(); err != 0; err--) { + onNextEvents.add("onCompleted"); } - } catch (Throwable t) { - timeouts.incrementAndGet(); - System.out.println(j + " | " + cdl.getCount() + " !!! " + nexts.get()); + data.put(j, onNextEvents); } - cdl.countDown(); + } catch (Throwable t) { + timeouts.incrementAndGet(); + System.out.println(j + " | " + cdl.getCount() + " !!! " + nexts.get()); } + cdl.countDown(); }); } cdl.await(); @@ -789,27 +695,12 @@ public void testIssue1900() throws InterruptedException { final AtomicInteger count = new AtomicInteger(); NbpObservable origin = NbpObservable.range(0, NUM_MSG) - .map(new Function() { - @Override - public String apply(Integer t1) { - return "msg: " + count.incrementAndGet(); - } - }); + .map(t1 -> "msg: " + count.incrementAndGet()); origin.retry() - .groupBy(new Function() { - @Override - public String apply(String t1) { - return t1; - } - }) - .flatMap(new Function, NbpObservable>() { - @Override - public NbpObservable apply(NbpGroupedObservable t1) { - return t1.take(1); - } - }) - .unsafeSubscribe(new NbpTestSubscriber(NbpObserver)); + .groupBy(t1 -> t1) + .flatMap(t1 -> t1.take(1)) + .unsafeSubscribe(new NbpTestSubscriber<>(NbpObserver)); InOrder inOrder = inOrder(NbpObserver); // should show 3 attempts @@ -841,19 +732,9 @@ public void accept(NbpSubscriber o) { }); origin.retry() - .groupBy(new Function() { - @Override - public String apply(String t1) { - return t1; - } - }) - .flatMap(new Function, NbpObservable>() { - @Override - public NbpObservable apply(NbpGroupedObservable t1) { - return t1.take(1); - } - }) - .unsafeSubscribe(new NbpTestSubscriber(NbpObserver)); + .groupBy(t1 -> t1) + .flatMap(t1 -> t1.take(1)) + .unsafeSubscribe(new NbpTestSubscriber<>(NbpObserver)); InOrder inOrder = inOrder(NbpObserver); // should show 3 attempts diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorRetryWithPredicateTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorRetryWithPredicateTest.java similarity index 76% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorRetryWithPredicateTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorRetryWithPredicateTest.java index 8ab79a2aaf..55fa120202 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorRetryWithPredicateTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorRetryWithPredicateTest.java @@ -35,24 +35,9 @@ import io.reactivex.subscribers.nbp.NbpTestSubscriber; public class NbpOperatorRetryWithPredicateTest { - BiPredicate retryTwice = new BiPredicate() { - @Override - public boolean test(Integer t1, Throwable t2) { - return t1 <= 2; - } - }; - BiPredicate retry5 = new BiPredicate() { - @Override - public boolean test(Integer t1, Throwable t2) { - return t1 <= 5; - } - }; - BiPredicate retryOnTestException = new BiPredicate() { - @Override - public boolean test(Integer t1, Throwable t2) { - return t2 instanceof IOException; - } - }; + BiPredicate retryTwice = (t1, t2) -> t1 <= 2; + BiPredicate retry5 = (t1, t2) -> t1 <= 5; + BiPredicate retryOnTestException = (t1, t2) -> t2 instanceof IOException; @Test public void testWithNothingToRetry() { NbpObservable source = NbpObservable.range(0, 3); @@ -210,12 +195,7 @@ public void accept(NbpSubscriber t1) { public void testUnsubscribeFromRetry() { NbpPublishSubject subject = NbpPublishSubject.create(); final AtomicInteger count = new AtomicInteger(0); - Disposable sub = subject.retry(retryTwice).subscribe(new Consumer() { - @Override - public void accept(Integer n) { - count.incrementAndGet(); - } - }); + Disposable sub = subject.retry(retryTwice).subscribe(n -> count.incrementAndGet()); subject.onNext(1); sub.dispose(); subject.onNext(2); @@ -233,7 +213,7 @@ public void testUnsubscribeAfterError() { .create(so) .retry(retry5); - NbpOperatorRetryTest.AsyncObserver async = new NbpOperatorRetryTest.AsyncObserver(NbpObserver); + NbpOperatorRetryTest.AsyncObserver async = new NbpOperatorRetryTest.AsyncObserver<>(NbpObserver); o.subscribe(async); @@ -260,7 +240,7 @@ public void testTimeoutWithRetry() { .timeout(80, TimeUnit.MILLISECONDS) .retry(retry5); - NbpOperatorRetryTest.AsyncObserver async = new NbpOperatorRetryTest.AsyncObserver(NbpObserver); + NbpOperatorRetryTest.AsyncObserver async = new NbpOperatorRetryTest.AsyncObserver<>(NbpObserver); o.subscribe(async); @@ -276,15 +256,12 @@ public void testTimeoutWithRetry() { @Test public void testIssue2826() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); final RuntimeException e = new RuntimeException("You shall not pass"); final AtomicInteger c = new AtomicInteger(); - NbpObservable.just(1).map(new Function() { - @Override - public Integer apply(Integer t1) { - c.incrementAndGet(); - throw e; - } + NbpObservable.just(1).map(t1 -> { + c.incrementAndGet(); + throw e; }).retry(retry5).subscribe(ts); ts.assertTerminated(); @@ -294,14 +271,11 @@ public Integer apply(Integer t1) { @Test public void testJustAndRetry() throws Exception { final AtomicBoolean throwException = new AtomicBoolean(true); - int value = NbpObservable.just(1).map(new Function() { - @Override - public Integer apply(Integer t1) { - if (throwException.compareAndSet(true, false)) { - throw new TestException(); - } - return t1; + int value = NbpObservable.just(1).map(t1 -> { + if (throwException.compareAndSet(true, false)) { + throw new TestException(); } + return t1; }).retry(1).toBlocking().single(); assertEquals(1, value); @@ -309,53 +283,39 @@ public Integer apply(Integer t1) { @Test public void testIssue3008RetryWithPredicate() { - final List list = new CopyOnWriteArrayList(); + final List list = new CopyOnWriteArrayList<>(); final AtomicBoolean isFirst = new AtomicBoolean(true); - NbpObservable. just(1L, 2L, 3L).map(new Function(){ - @Override - public Long apply(Long x) { - System.out.println("map " + x); - if (x == 2 && isFirst.getAndSet(false)) { - throw new RuntimeException("retryable error"); - } - return x; - }}) - .retry(new BiPredicate() { - @Override - public boolean test(Integer t1, Throwable t2) { - return true; - }}) - .forEach(new Consumer() { - - @Override - public void accept(Long t) { - System.out.println(t); - list.add(t); - }}); + NbpObservable.just(1L, 2L, 3L).map(x -> { + System.out.println("map " + x); + if (x == 2 && isFirst.getAndSet(false)) { + throw new RuntimeException("retryable error"); + } + return x; + }) + .retry((t1, t2) -> true) + .forEach(t -> { + System.out.println(t); + list.add(t); + }); assertEquals(Arrays.asList(1L,1L,2L,3L), list); } @Test public void testIssue3008RetryInfinite() { - final List list = new CopyOnWriteArrayList(); + final List list = new CopyOnWriteArrayList<>(); final AtomicBoolean isFirst = new AtomicBoolean(true); - NbpObservable. just(1L, 2L, 3L).map(new Function(){ - @Override - public Long apply(Long x) { - System.out.println("map " + x); - if (x == 2 && isFirst.getAndSet(false)) { - throw new RuntimeException("retryable error"); - } - return x; - }}) + NbpObservable.just(1L, 2L, 3L).map(x -> { + System.out.println("map " + x); + if (x == 2 && isFirst.getAndSet(false)) { + throw new RuntimeException("retryable error"); + } + return x; + }) .retry() - .forEach(new Consumer() { - - @Override - public void accept(Long t) { - System.out.println(t); - list.add(t); - }}); + .forEach(t -> { + System.out.println(t); + list.add(t); + }); assertEquals(Arrays.asList(1L,1L,2L,3L), list); } } \ No newline at end of file diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSampleTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSampleTest.java similarity index 93% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSampleTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSampleTest.java index 3626ea6759..4a94aac4f8 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSampleTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSampleTest.java @@ -49,24 +49,9 @@ public void testSample() { @Override public void accept(final NbpSubscriber observer1) { observer1.onSubscribe(EmptyDisposable.INSTANCE); - innerScheduler.schedule(new Runnable() { - @Override - public void run() { - observer1.onNext(1L); - } - }, 1, TimeUnit.SECONDS); - innerScheduler.schedule(new Runnable() { - @Override - public void run() { - observer1.onNext(2L); - } - }, 2, TimeUnit.SECONDS); - innerScheduler.schedule(new Runnable() { - @Override - public void run() { - observer1.onComplete(); - } - }, 3, TimeUnit.SECONDS); + innerScheduler.schedule(() -> observer1.onNext(1L), 1, TimeUnit.SECONDS); + innerScheduler.schedule(() -> observer1.onNext(2L), 2, TimeUnit.SECONDS); + innerScheduler.schedule(() -> observer1.onComplete(), 3, TimeUnit.SECONDS); } }); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorScanTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorScanTest.java similarity index 66% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorScanTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorScanTest.java index 3e0bb925d6..35f573bb26 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorScanTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorScanTest.java @@ -36,14 +36,7 @@ public void testScanIntegersWithInitialValue() { NbpObservable o = NbpObservable.just(1, 2, 3); - NbpObservable m = o.scan("", new BiFunction() { - - @Override - public String apply(String s, Integer n) { - return s + n.toString(); - } - - }); + NbpObservable m = o.scan("", (s, n) -> s + n.toString()); m.subscribe(NbpObserver); verify(NbpObserver, never()).onError(any(Throwable.class)); @@ -62,14 +55,7 @@ public void testScanIntegersWithoutInitialValue() { NbpObservable o = NbpObservable.just(1, 2, 3); - NbpObservable m = o.scan(new BiFunction() { - - @Override - public Integer apply(Integer t1, Integer t2) { - return t1 + t2; - } - - }); + NbpObservable m = o.scan((t1, t2) -> t1 + t2); m.subscribe(NbpObserver); verify(NbpObserver, never()).onError(any(Throwable.class)); @@ -88,14 +74,7 @@ public void testScanIntegersWithoutInitialValueAndOnlyOneValue() { NbpObservable o = NbpObservable.just(1); - NbpObservable m = o.scan(new BiFunction() { - - @Override - public Integer apply(Integer t1, Integer t2) { - return t1 + t2; - } - - }); + NbpObservable m = o.scan((t1, t2) -> t1 + t2); m.subscribe(NbpObserver); verify(NbpObserver, never()).onError(any(Throwable.class)); @@ -108,22 +87,10 @@ public Integer apply(Integer t1, Integer t2) { @Test public void shouldNotEmitUntilAfterSubscription() { - NbpTestSubscriber ts = new NbpTestSubscriber(); - NbpObservable.range(1, 100).scan(0, new BiFunction() { - - @Override - public Integer apply(Integer t1, Integer t2) { - return t1 + t2; - } - - }).filter(new Predicate() { - - @Override - public boolean test(Integer t1) { - // this will cause request(1) when 0 is emitted - return t1 > 0; - } - + NbpTestSubscriber ts = new NbpTestSubscriber<>(); + NbpObservable.range(1, 100).scan(0, (t1, t2) -> t1 + t2).filter(t1 -> { + // this will cause request(1) when 0 is emitted + return t1 > 0; }).subscribe(ts); assertEquals(100, ts.values().size()); @@ -133,14 +100,7 @@ public boolean test(Integer t1) { public void testNoBackpressureWithInitialValue() { final AtomicInteger count = new AtomicInteger(); NbpObservable.range(1, 100) - .scan(0, new BiFunction() { - - @Override - public Integer apply(Integer t1, Integer t2) { - return t1 + t2; - } - - }) + .scan(0, (t1, t2) -> t1 + t2) .subscribe(new NbpObserver() { @Override @@ -170,22 +130,8 @@ public void onNext(Integer t) { */ @Test public void testSeedFactory() { - NbpObservable> o = NbpObservable.range(1, 10) - .collect(new Supplier>() { - - @Override - public List get() { - return new ArrayList(); - } - - }, new BiConsumer, Integer>() { - - @Override - public void accept(List list, Integer t2) { - list.add(t2); - } - - }).takeLast(1); + NbpObservable> o = NbpObservable.range(1, 10) + .collect(ArrayList::new, List::add).takeLast(1); assertEquals(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10), o.toBlocking().single()); assertEquals(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10), o.toBlocking().single()); @@ -193,15 +139,8 @@ public void accept(List list, Integer t2) { @Test public void testScanWithRequestOne() { - NbpObservable o = NbpObservable.just(1, 2).scan(0, new BiFunction() { - - @Override - public Integer apply(Integer t1, Integer t2) { - return t1 + t2; - } - - }).take(1); - NbpTestSubscriber NbpSubscriber = new NbpTestSubscriber(); + NbpObservable o = NbpObservable.just(1, 2).scan(0, (t1, t2) -> t1 + t2).take(1); + NbpTestSubscriber NbpSubscriber = new NbpTestSubscriber<>(); o.subscribe(NbpSubscriber); NbpSubscriber.assertValue(0); NbpSubscriber.assertTerminated(); @@ -212,14 +151,9 @@ public Integer apply(Integer t1, Integer t2) { public void testInitialValueEmittedNoProducer() { NbpPublishSubject source = NbpPublishSubject.create(); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); - source.scan(0, new BiFunction() { - @Override - public Integer apply(Integer t1, Integer t2) { - return t1 + t2; - } - }).subscribe(ts); + source.scan(0, (t1, t2) -> t1 + t2).subscribe(ts); ts.assertNoErrors(); ts.assertNotComplete(); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSequenceEqualTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSequenceEqualTest.java similarity index 95% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSequenceEqualTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSequenceEqualTest.java index 725889e7db..d0a3c9fea9 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSequenceEqualTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSequenceEqualTest.java @@ -121,11 +121,8 @@ public void testWithNull2() { public void testWithEqualityError() { NbpObservable o = NbpObservable.sequenceEqual( NbpObservable.just("one"), NbpObservable.just("one"), - new BiPredicate() { - @Override - public boolean test(String t1, String t2) { - throw new TestException(); - } + (t1, t2) -> { + throw new TestException(); }); verifyError(o); } diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSerializeTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSerializeTest.java similarity index 80% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSerializeTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSerializeTest.java index 5158644866..0d735d3856 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSerializeTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSerializeTest.java @@ -221,22 +221,17 @@ public TestSingleThreadedObservable(final String... values) { public void accept(final NbpSubscriber NbpObserver) { NbpObserver.onSubscribe(EmptyDisposable.INSTANCE); System.out.println("TestSingleThreadedObservable subscribed to ..."); - t = new Thread(new Runnable() { - - @Override - public void run() { - try { - System.out.println("running TestSingleThreadedObservable thread"); - for (String s : values) { - System.out.println("TestSingleThreadedObservable onNext: " + s); - NbpObserver.onNext(s); - } - NbpObserver.onComplete(); - } catch (Throwable e) { - throw new RuntimeException(e); + t = new Thread(() -> { + try { + System.out.println("running TestSingleThreadedObservable thread"); + for (String s : values) { + System.out.println("TestSingleThreadedObservable onNext: " + s); + NbpObserver.onNext(s); } + NbpObserver.onComplete(); + } catch (Throwable e) { + throw new RuntimeException(e); } - }); System.out.println("starting TestSingleThreadedObservable thread"); t.start(); @@ -273,56 +268,48 @@ public void accept(final NbpSubscriber NbpObserver) { NbpObserver.onSubscribe(EmptyDisposable.INSTANCE); System.out.println("TestMultiThreadedObservable subscribed to ..."); final NullPointerException npe = new NullPointerException(); - t = new Thread(new Runnable() { - - @Override - public void run() { - try { - System.out.println("running TestMultiThreadedObservable thread"); - for (final String s : values) { - threadPool.execute(new Runnable() { - - @Override - public void run() { - threadsRunning.incrementAndGet(); - try { - // perform onNext call - if (s == null) { - System.out.println("TestMultiThreadedObservable onNext: null"); - // force an error - throw npe; - } else - System.out.println("TestMultiThreadedObservable onNext: " + s); - NbpObserver.onNext(s); - // capture 'maxThreads' - int concurrentThreads = threadsRunning.get(); - int maxThreads = maxConcurrentThreads.get(); - if (concurrentThreads > maxThreads) { - maxConcurrentThreads.compareAndSet(maxThreads, concurrentThreads); - } - } catch (Throwable e) { - NbpObserver.onError(e); - } finally { - threadsRunning.decrementAndGet(); - } + t = new Thread(() -> { + try { + System.out.println("running TestMultiThreadedObservable thread"); + for (final String s : values) { + threadPool.execute(() -> { + threadsRunning.incrementAndGet(); + try { + // perform onNext call + if (s == null) { + System.out.println("TestMultiThreadedObservable onNext: null"); + // force an error + throw npe; + } else + System.out.println("TestMultiThreadedObservable onNext: " + s); + NbpObserver.onNext(s); + // capture 'maxThreads' + int concurrentThreads = threadsRunning.get(); + int maxThreads = maxConcurrentThreads.get(); + if (concurrentThreads > maxThreads) { + maxConcurrentThreads.compareAndSet(maxThreads, concurrentThreads); } - }); - } - // we are done spawning threads - threadPool.shutdown(); - } catch (Throwable e) { - throw new RuntimeException(e); + } catch (Throwable e) { + NbpObserver.onError(e); + } finally { + threadsRunning.decrementAndGet(); + } + }); } + // we are done spawning threads + threadPool.shutdown(); + } catch (Throwable e) { + throw new RuntimeException(e); + } - // wait until all threads are done, then mark it as COMPLETED - try { - // wait for all the threads to finish - threadPool.awaitTermination(2, TimeUnit.SECONDS); - } catch (InterruptedException e) { - throw new RuntimeException(e); - } - NbpObserver.onComplete(); + // wait until all threads are done, then mark it as COMPLETED + try { + // wait for all the threads to finish + threadPool.awaitTermination(2, TimeUnit.SECONDS); + } catch (InterruptedException e) { + throw new RuntimeException(e); } + NbpObserver.onComplete(); }); System.out.println("starting TestMultiThreadedObservable thread"); t.start(); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSingleTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSingleTest.java similarity index 81% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSingleTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSingleTest.java index 2c112e4d3f..830bd2bf2c 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSingleTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSingleTest.java @@ -70,14 +70,7 @@ public void testSingleWithEmpty() { @Test public void testSingleWithPredicate() { NbpObservable o = NbpObservable.just(1, 2) - .filter( - new Predicate() { - - @Override - public boolean test(Integer t1) { - return t1 % 2 == 0; - } - }) + .filter(t1 -> t1 % 2 == 0) .single(); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); @@ -92,14 +85,7 @@ public boolean test(Integer t1) { @Test public void testSingleWithPredicateAndTooManyElements() { NbpObservable o = NbpObservable.just(1, 2, 3, 4) - .filter( - new Predicate() { - - @Override - public boolean test(Integer t1) { - return t1 % 2 == 0; - } - }) + .filter(t1 -> t1 % 2 == 0) .single(); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); @@ -114,14 +100,7 @@ public boolean test(Integer t1) { @Test public void testSingleWithPredicateAndEmpty() { NbpObservable o = NbpObservable.just(1) - .filter( - new Predicate() { - - @Override - public boolean test(Integer t1) { - return t1 % 2 == 0; - } - }) + .filter(t1 -> t1 % 2 == 0) .single(); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); o.subscribe(NbpObserver); @@ -175,12 +154,7 @@ public void testSingleOrDefaultWithEmpty() { @Test public void testSingleOrDefaultWithPredicate() { NbpObservable o = NbpObservable.just(1, 2) - .filter(new Predicate() { - @Override - public boolean test(Integer t1) { - return t1 % 2 == 0; - } - }) + .filter(t1 -> t1 % 2 == 0) .single(4); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); @@ -195,12 +169,7 @@ public boolean test(Integer t1) { @Test public void testSingleOrDefaultWithPredicateAndTooManyElements() { NbpObservable o = NbpObservable.just(1, 2, 3, 4) - .filter(new Predicate() { - @Override - public boolean test(Integer t1) { - return t1 % 2 == 0; - } - }) + .filter(t1 -> t1 % 2 == 0) .single(6); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); @@ -215,12 +184,7 @@ public boolean test(Integer t1) { @Test public void testSingleOrDefaultWithPredicateAndEmpty() { NbpObservable o = NbpObservable.just(1) - .filter(new Predicate() { - @Override - public boolean test(Integer t1) { - return t1 % 2 == 0; - } - }) + .filter(t1 -> t1 % 2 == 0) .single(2); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); @@ -236,12 +200,7 @@ public boolean test(Integer t1) { public void testIssue1527() throws InterruptedException { //https://github.com/ReactiveX/RxJava/pull/1527 NbpObservable source = NbpObservable.just(1, 2, 3, 4, 5, 6); - NbpObservable reduced = source.reduce(new BiFunction() { - @Override - public Integer apply(Integer i1, Integer i2) { - return i1 + i2; - } - }); + NbpObservable reduced = source.reduce((i1, i2) -> i1 + i2); Integer r = reduced.toBlocking().first(); assertEquals(21, r.intValue()); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipLastTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipLastTest.java similarity index 98% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipLastTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipLastTest.java index b5c4932e34..ecf551b60e 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipLastTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipLastTest.java @@ -95,7 +95,7 @@ public void testSkipLastWithNull() { @Test public void testSkipLastWithBackpressure() { NbpObservable o = NbpObservable.range(0, Observable.bufferSize() * 2).skipLast(Observable.bufferSize() + 10); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); o.observeOn(Schedulers.computation()).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipLastTimedTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipLastTimedTest.java similarity index 100% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipLastTimedTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipLastTimedTest.java diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipTest.java similarity index 98% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipTest.java index 78b2430cff..0db2188431 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipTest.java @@ -138,7 +138,7 @@ public void testSkipError() { @Test public void testRequestOverflowDoesNotOccur() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpObservable.range(1, 10).skip(5).subscribe(ts); ts.assertTerminated(); ts.assertComplete(); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipTimedTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipTimedTest.java similarity index 100% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipTimedTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipTimedTest.java diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipUntilTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipUntilTest.java similarity index 100% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipUntilTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipUntilTest.java diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipWhileTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipWhileTest.java similarity index 93% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipWhileTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipWhileTest.java index 986b015b92..17bc8ad266 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipWhileTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSkipWhileTest.java @@ -27,13 +27,10 @@ public class NbpOperatorSkipWhileTest { NbpSubscriber w = TestHelper.mockNbpSubscriber(); - private static final Predicate LESS_THAN_FIVE = new Predicate() { - @Override - public boolean test(Integer v) { - if (v == 42) - throw new RuntimeException("that's not the answer to everything!"); - return v < 5; - } + private static final Predicate LESS_THAN_FIVE = v -> { + if (v == 42) + throw new RuntimeException("that's not the answer to everything!"); + return v < 5; }; private static final Predicate INDEX_LESS_THAN_THREE = new Predicate() { diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSubscribeOnTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSubscribeOnTest.java similarity index 92% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSubscribeOnTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSubscribeOnTest.java index ea04f1adb2..55ee637db2 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSubscribeOnTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSubscribeOnTest.java @@ -36,7 +36,7 @@ public void testIssue813() throws InterruptedException { final CountDownLatch latch = new CountDownLatch(1); final CountDownLatch doneLatch = new CountDownLatch(1); - NbpTestSubscriber NbpObserver = new NbpTestSubscriber(); + NbpTestSubscriber NbpObserver = new NbpTestSubscriber<>(); NbpObservable .create(new NbpOnSubscribe() { @@ -75,14 +75,9 @@ public void accept( @Test @Ignore("NbpOnSubscribe.subscribe can't throw") public void testThrownErrorHandling() { - NbpTestSubscriber ts = new NbpTestSubscriber(); - NbpObservable.create(new NbpOnSubscribe() { - - @Override - public void accept(NbpSubscriber s) { - throw new RuntimeException("fail"); - } - + NbpTestSubscriber ts = new NbpTestSubscriber<>(); + NbpObservable.create(s -> { + throw new RuntimeException("fail"); }).subscribeOn(Schedulers.computation()).subscribe(ts); ts.awaitTerminalEvent(1000, TimeUnit.MILLISECONDS); ts.assertTerminated(); @@ -90,7 +85,7 @@ public void accept(NbpSubscriber s) { @Test public void testOnError() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpObservable.create(new NbpOnSubscribe() { @Override @@ -161,7 +156,7 @@ public Disposable schedule(final Runnable action, final long delayTime, final Ti @Test(timeout = 5000) public void testUnsubscribeInfiniteStream() throws InterruptedException { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); final AtomicInteger count = new AtomicInteger(); NbpObservable.create(new NbpOnSubscribe() { diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSwitchIfEmptyTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSwitchIfEmptyTest.java similarity index 85% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSwitchIfEmptyTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSwitchIfEmptyTest.java index e33c39d8df..042b1a6ba8 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSwitchIfEmptyTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSwitchIfEmptyTest.java @@ -33,12 +33,7 @@ public void testSwitchWhenNotEmpty() throws Exception { final AtomicBoolean subscribed = new AtomicBoolean(false); final NbpObservable o = NbpObservable.just(4) .switchIfEmpty(NbpObservable.just(2) - .doOnSubscribe(new Consumer() { - @Override - public void accept(Disposable s) { - subscribed.set(true); - } - })); + .doOnSubscribe(s -> subscribed.set(true))); assertEquals(4, o.toBlocking().single().intValue()); assertFalse(subscribed.get()); @@ -67,10 +62,7 @@ public void accept(final NbpSubscriber NbpSubscriber) { NbpObservable.empty() .switchIfEmpty(withProducer) - .lift(new NbpObservable.NbpOperator() { - @Override - public NbpSubscriber apply(final NbpSubscriber child) { - return new NbpObserver() { + .lift(child -> new NbpObserver() { @Override public void onComplete() { @@ -85,10 +77,8 @@ public void onError(Throwable e) { public void onNext(Long aLong) { cancel(); } - - }; - } - }).subscribe(); + + }).subscribe(); assertTrue(bs.isDisposed()); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSwitchTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSwitchTest.java similarity index 94% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSwitchTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSwitchTest.java index e51c516ee2..98fc984132 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSwitchTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorSwitchTest.java @@ -348,30 +348,15 @@ public void accept(NbpSubscriber NbpObserver) { } private void publishCompleted(final NbpSubscriber NbpObserver, long delay) { - innerScheduler.schedule(new Runnable() { - @Override - public void run() { - NbpObserver.onComplete(); - } - }, delay, TimeUnit.MILLISECONDS); + innerScheduler.schedule(NbpObserver::onComplete, delay, TimeUnit.MILLISECONDS); } private void publishError(final NbpSubscriber NbpObserver, long delay, final Throwable error) { - innerScheduler.schedule(new Runnable() { - @Override - public void run() { - NbpObserver.onError(error); - } - }, delay, TimeUnit.MILLISECONDS); + innerScheduler.schedule(() -> NbpObserver.onError(error), delay, TimeUnit.MILLISECONDS); } private void publishNext(final NbpSubscriber NbpObserver, long delay, final T value) { - innerScheduler.schedule(new Runnable() { - @Override - public void run() { - NbpObserver.onNext(value); - } - }, delay, TimeUnit.MILLISECONDS); + innerScheduler.schedule(() -> NbpObserver.onNext(value), delay, TimeUnit.MILLISECONDS); } @Test @@ -442,19 +427,9 @@ public void accept(final NbpSubscriber> NbpSubscr public void testIssue2654() { NbpObservable oneItem = NbpObservable.just("Hello").mergeWith(NbpObservable.never()); - NbpObservable src = oneItem.switchMap(new Function>() { - @Override - public NbpObservable apply(final String s) { - return NbpObservable.just(s) - .mergeWith(NbpObservable.interval(10, TimeUnit.MILLISECONDS) - .map(new Function() { - @Override - public String apply(Long i) { - return s + " " + i; - } - })).take(250); - } - }) + NbpObservable src = oneItem.switchMap(s -> NbpObservable.just(s) + .mergeWith(NbpObservable.interval(10, TimeUnit.MILLISECONDS) + .map(i -> s + " " + i)).take(250)) .share() ; diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeLastOneTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeLastOneTest.java similarity index 79% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeLastOneTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeLastOneTest.java index f533cfc741..1d42325098 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeLastOneTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeLastOneTest.java @@ -27,7 +27,7 @@ public class NbpOperatorTakeLastOneTest { @Test public void testLastOfManyReturnsLast() { - NbpTestSubscriber s = new NbpTestSubscriber(); + NbpTestSubscriber s = new NbpTestSubscriber<>(); NbpObservable.range(1, 10).takeLast(1).subscribe(s); s.assertValue(10); s.assertNoErrors(); @@ -38,7 +38,7 @@ public void testLastOfManyReturnsLast() { @Test public void testLastOfEmptyReturnsEmpty() { - NbpTestSubscriber s = new NbpTestSubscriber(); + NbpTestSubscriber s = new NbpTestSubscriber<>(); NbpObservable.empty().takeLast(1).subscribe(s); s.assertNoValues(); s.assertNoErrors(); @@ -49,7 +49,7 @@ public void testLastOfEmptyReturnsEmpty() { @Test public void testLastOfOneReturnsLast() { - NbpTestSubscriber s = new NbpTestSubscriber(); + NbpTestSubscriber s = new NbpTestSubscriber<>(); NbpObservable.just(1).takeLast(1).subscribe(s); s.assertValue(1); s.assertNoErrors(); @@ -61,12 +61,7 @@ public void testLastOfOneReturnsLast() { @Test public void testUnsubscribesFromUpstream() { final AtomicBoolean unsubscribed = new AtomicBoolean(false); - Runnable unsubscribeAction = new Runnable() { - @Override - public void run() { - unsubscribed.set(true); - } - }; + Runnable unsubscribeAction = () -> unsubscribed.set(true); NbpObservable.just(1).doOnCancel(unsubscribeAction) .takeLast(1).subscribe(); assertTrue(unsubscribed.get()); @@ -76,12 +71,7 @@ public void run() { public void testTakeLastZeroProcessesAllItemsButIgnoresThem() { final AtomicInteger upstreamCount = new AtomicInteger(); final int num = 10; - long count = NbpObservable.range(1,num).doOnNext(new Consumer() { - - @Override - public void accept(Integer t) { - upstreamCount.incrementAndGet(); - }}) + long count = NbpObservable.range(1,num).doOnNext(t -> upstreamCount.incrementAndGet()) .takeLast(0).count().toBlocking().single(); assertEquals(num, upstreamCount.get()); assertEquals(0L, count); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeLastTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeLastTest.java similarity index 94% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeLastTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeLastTest.java index caacf7b866..bb9be155a2 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeLastTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeLastTest.java @@ -103,7 +103,7 @@ public void testTakeLastWithNegativeCount() { @Test public void testBackpressure1() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpObservable.range(1, 100000).takeLast(1) .observeOn(Schedulers.newThread()) .map(newSlowProcessor()).subscribe(ts); @@ -114,7 +114,7 @@ public void testBackpressure1() { @Test public void testBackpressure2() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpObservable.range(1, 100000).takeLast(Observable.bufferSize() * 4) .observeOn(Schedulers.newThread()).map(newSlowProcessor()).subscribe(ts); ts.awaitTerminalEvent(); @@ -146,12 +146,7 @@ public void testIssue1522() { assertEquals(0, NbpObservable .empty() .count() - .filter(new Predicate() { - @Override - public boolean test(Long v) { - return false; - } - }) + .filter(v -> false) .toList() .toBlocking().single().size()); } diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeLastTimedTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeLastTimedTest.java similarity index 100% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeLastTimedTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeLastTimedTest.java diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeTest.java similarity index 81% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeTest.java index 48e4bffd69..1f3f731c45 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeTest.java @@ -67,23 +67,17 @@ public void testTake2() { @Test(expected = IllegalArgumentException.class) public void testTakeWithError() { NbpObservable.fromIterable(Arrays.asList(1, 2, 3)).take(1) - .map(new Function() { - @Override - public Integer apply(Integer t1) { - throw new IllegalArgumentException("some error"); - } + .map(t1 -> { + throw new IllegalArgumentException("some error"); }).toBlocking().single(); } @Test public void testTakeWithErrorHappeningInOnNext() { NbpObservable w = NbpObservable.fromIterable(Arrays.asList(1, 2, 3)) - .take(2).map(new Function() { - @Override - public Integer apply(Integer t1) { - throw new IllegalArgumentException("some error"); - } - }); + .take(2).map(t1 -> { + throw new IllegalArgumentException("some error"); + }); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); w.subscribe(NbpObserver); @@ -94,11 +88,8 @@ public Integer apply(Integer t1) { @Test public void testTakeWithErrorHappeningInTheLastOnNext() { - NbpObservable w = NbpObservable.fromIterable(Arrays.asList(1, 2, 3)).take(1).map(new Function() { - @Override - public Integer apply(Integer t1) { - throw new IllegalArgumentException("some error"); - } + NbpObservable w = NbpObservable.fromIterable(Arrays.asList(1, 2, 3)).take(1).map(t1 -> { + throw new IllegalArgumentException("some error"); }); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); @@ -190,14 +181,7 @@ public void testUnsubscribeAfterTake() { @Test(timeout = 2000) public void testUnsubscribeFromSynchronousInfiniteObservable() { final AtomicLong count = new AtomicLong(); - INFINITE_OBSERVABLE.take(10).subscribe(new Consumer() { - - @Override - public void accept(Long l) { - count.set(l); - } - - }); + INFINITE_OBSERVABLE.take(10).subscribe(count::set); assertEquals(10, count.get()); } @@ -217,15 +201,7 @@ public void accept(NbpSubscriber s) { } } - }).take(100).take(1).toBlocking().forEach(new Consumer() { - - @Override - public void accept(Integer t1) { - System.out.println("Receive: " + t1); - - } - - }); + }).take(100).take(1).toBlocking().forEach(t1 -> System.out.println("Receive: " + t1)); assertEquals(1, count.get()); } @@ -243,22 +219,17 @@ public TestObservableFunc(String... values) { public void accept(final NbpSubscriber NbpObserver) { NbpObserver.onSubscribe(EmptyDisposable.INSTANCE); System.out.println("TestObservable subscribed to ..."); - t = new Thread(new Runnable() { - - @Override - public void run() { - try { - System.out.println("running TestObservable thread"); - for (String s : values) { - System.out.println("TestObservable onNext: " + s); - NbpObserver.onNext(s); - } - NbpObserver.onComplete(); - } catch (Throwable e) { - throw new RuntimeException(e); + t = new Thread(() -> { + try { + System.out.println("running TestObservable thread"); + for (String s : values) { + System.out.println("TestObservable onNext: " + s); + NbpObserver.onNext(s); } + NbpObserver.onComplete(); + } catch (Throwable e) { + throw new RuntimeException(e); } - }); System.out.println("starting TestObservable thread"); t.start(); @@ -284,7 +255,7 @@ public void accept(NbpSubscriber op) { @Test(timeout = 2000) public void testTakeObserveOn() { NbpSubscriber o = TestHelper.mockNbpSubscriber(); - NbpTestSubscriber ts = new NbpTestSubscriber(o); + NbpTestSubscriber ts = new NbpTestSubscriber<>(o); INFINITE_OBSERVABLE .observeOn(Schedulers.newThread()).take(1).subscribe(ts); @@ -299,23 +270,18 @@ public void testTakeObserveOn() { @Test public void testInterrupt() throws InterruptedException { - final AtomicReference exception = new AtomicReference(); + final AtomicReference exception = new AtomicReference<>(); final CountDownLatch latch = new CountDownLatch(1); NbpObservable.just(1).subscribeOn(Schedulers.computation()).take(1) - .subscribe(new Consumer() { - - @Override - public void accept(Integer t1) { - try { - Thread.sleep(100); - } catch (Exception e) { - exception.set(e); - e.printStackTrace(); - } finally { - latch.countDown(); - } + .subscribe(t1 -> { + try { + Thread.sleep(100); + } catch (Exception e) { + exception.set(e); + e.printStackTrace(); + } finally { + latch.countDown(); } - }); latch.await(); @@ -344,14 +310,9 @@ public void onNext(Integer t) { public void testReentrantTake() { final NbpPublishSubject source = NbpPublishSubject.create(); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); - source.take(1).doOnNext(new Consumer() { - @Override - public void accept(Integer v) { - source.onNext(2); - } - }).subscribe(ts); + source.take(1).doOnNext(v -> source.onNext(2)).subscribe(ts); source.onNext(1); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeTimedTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeTimedTest.java similarity index 100% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeTimedTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeTimedTest.java diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeUntilPredicateTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeUntilPredicateTest.java similarity index 70% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeUntilPredicateTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeUntilPredicateTest.java index 0b2b83aedb..0d5f622679 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeUntilPredicateTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeUntilPredicateTest.java @@ -30,12 +30,7 @@ public class NbpOperatorTakeUntilPredicateTest { public void takeEmpty() { NbpSubscriber o = TestHelper.mockNbpSubscriber(); - NbpObservable.empty().takeUntil(new Predicate() { - @Override - public boolean test(Object v) { - return true; - } - }).subscribe(o); + NbpObservable.empty().takeUntil(v -> true).subscribe(o); verify(o, never()).onNext(any()); verify(o, never()).onError(any(Throwable.class)); @@ -45,12 +40,7 @@ public boolean test(Object v) { public void takeAll() { NbpSubscriber o = TestHelper.mockNbpSubscriber(); - NbpObservable.just(1, 2).takeUntil(new Predicate() { - @Override - public boolean test(Integer v) { - return false; - } - }).subscribe(o); + NbpObservable.just(1, 2).takeUntil(v -> false).subscribe(o); verify(o).onNext(1); verify(o).onNext(2); @@ -61,12 +51,7 @@ public boolean test(Integer v) { public void takeFirst() { NbpSubscriber o = TestHelper.mockNbpSubscriber(); - NbpObservable.just(1, 2).takeUntil(new Predicate() { - @Override - public boolean test(Integer v) { - return true; - } - }).subscribe(o); + NbpObservable.just(1, 2).takeUntil(v -> true).subscribe(o); verify(o).onNext(1); verify(o, never()).onNext(2); @@ -77,12 +62,7 @@ public boolean test(Integer v) { public void takeSome() { NbpSubscriber o = TestHelper.mockNbpSubscriber(); - NbpObservable.just(1, 2, 3).takeUntil(new Predicate() { - @Override - public boolean test(Integer t1) { - return t1 == 2; - } - }) + NbpObservable.just(1, 2, 3).takeUntil(t1 -> t1 == 2) .subscribe(o); verify(o).onNext(1); @@ -95,11 +75,8 @@ public boolean test(Integer t1) { public void functionThrows() { NbpSubscriber o = TestHelper.mockNbpSubscriber(); - Predicate predicate = (new Predicate() { - @Override - public boolean test(Integer t1) { - throw new TestException("Forced failure"); - } + Predicate predicate = (t1 -> { + throw new TestException("Forced failure"); }); NbpObservable.just(1, 2, 3).takeUntil(predicate).subscribe(o); @@ -116,12 +93,7 @@ public void sourceThrows() { NbpObservable.just(1) .concatWith(NbpObservable.error(new TestException())) .concatWith(NbpObservable.just(2)) - .takeUntil(new Predicate() { - @Override - public boolean test(Integer v) { - return false; - } - }).subscribe(o); + .takeUntil(v -> false).subscribe(o); verify(o).onNext(1); verify(o, never()).onNext(2); @@ -131,13 +103,10 @@ public boolean test(Integer v) { @Test public void testErrorIncludesLastValueAsCause() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); final TestException e = new TestException("Forced failure"); - Predicate predicate = (new Predicate() { - @Override - public boolean test(String t) { - throw e; - } + Predicate predicate = (t -> { + throw e; }); NbpObservable.just("abc").takeUntil(predicate).subscribe(ts); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeUntilTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeUntilTest.java similarity index 97% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeUntilTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeUntilTest.java index 9e1ca94aca..b1a6821105 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeUntilTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeUntilTest.java @@ -188,7 +188,7 @@ public void testUntilFires() { NbpPublishSubject source = NbpPublishSubject.create(); NbpPublishSubject until = NbpPublishSubject.create(); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); source.takeUntil(until).unsafeSubscribe(ts); @@ -213,7 +213,7 @@ public void testMainCompletes() { NbpPublishSubject source = NbpPublishSubject.create(); NbpPublishSubject until = NbpPublishSubject.create(); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); source.takeUntil(until).unsafeSubscribe(ts); @@ -236,7 +236,7 @@ public void testDownstreamUnsubscribes() { NbpPublishSubject source = NbpPublishSubject.create(); NbpPublishSubject until = NbpPublishSubject.create(); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); source.takeUntil(until).take(1).unsafeSubscribe(ts); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeWhileTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeWhileTest.java similarity index 78% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeWhileTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeWhileTest.java index f4c55b370f..9c223094ab 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeWhileTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTakeWhileTest.java @@ -33,12 +33,7 @@ public class NbpOperatorTakeWhileTest { @Test public void testTakeWhile1() { NbpObservable w = NbpObservable.just(1, 2, 3); - NbpObservable take = w.takeWhile(new Predicate() { - @Override - public boolean test(Integer input) { - return input < 3; - } - }); + NbpObservable take = w.takeWhile(input -> input < 3); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); take.subscribe(NbpObserver); @@ -52,12 +47,7 @@ public boolean test(Integer input) { @Test public void testTakeWhileOnSubject1() { NbpSubject s = NbpPublishSubject.create(); - NbpObservable take = s.takeWhile(new Predicate() { - @Override - public boolean test(Integer input) { - return input < 3; - } - }); + NbpObservable take = s.takeWhile(input -> input < 3); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); take.subscribe(NbpObserver); @@ -110,12 +100,7 @@ public void accept(NbpSubscriber NbpObserver) { } }); - source.takeWhile(new Predicate() { - @Override - public boolean test(String s) { - return false; - } - }).toBlocking().last(""); + source.takeWhile(s -> false).toBlocking().last(""); } @Test @@ -125,12 +110,9 @@ public void testTakeWhileProtectsPredicateCall() { NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); NbpObservable take = NbpObservable.create(source) - .takeWhile(new Predicate() { - @Override - public boolean test(String s) { - throw testException; - } - }); + .takeWhile(s -> { + throw testException; + }); take.subscribe(NbpObserver); // wait for the NbpObservable to complete @@ -192,22 +174,17 @@ public TestObservable(Disposable s, String... values) { public void accept(final NbpSubscriber NbpObserver) { System.out.println("TestObservable subscribed to ..."); NbpObserver.onSubscribe(s); - t = new Thread(new Runnable() { - - @Override - public void run() { - try { - System.out.println("running TestObservable thread"); - for (String s : values) { - System.out.println("TestObservable onNext: " + s); - NbpObserver.onNext(s); - } - NbpObserver.onComplete(); - } catch (Throwable e) { - throw new RuntimeException(e); + t = new Thread(() -> { + try { + System.out.println("running TestObservable thread"); + for (String s1 : values) { + System.out.println("TestObservable onNext: " + s1); + NbpObserver.onNext(s1); } + NbpObserver.onComplete(); + } catch (Throwable e) { + throw new RuntimeException(e); } - }); System.out.println("starting TestObservable thread"); t.start(); @@ -217,13 +194,8 @@ public void run() { @Test public void testNoUnsubscribeDownstream() { - NbpObservable source = NbpObservable.range(1, 1000).takeWhile(new Predicate() { - @Override - public boolean test(Integer t1) { - return t1 < 2; - } - }); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpObservable source = NbpObservable.range(1, 1000).takeWhile(t1 -> t1 < 2); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); source.unsafeSubscribe(ts); @@ -235,12 +207,9 @@ public boolean test(Integer t1) { @Test public void testErrorCauseIncludesLastValue() { - NbpTestSubscriber ts = new NbpTestSubscriber(); - NbpObservable.just("abc").takeWhile(new Predicate() { - @Override - public boolean test(String t1) { - throw new TestException(); - } + NbpTestSubscriber ts = new NbpTestSubscriber<>(); + NbpObservable.just("abc").takeWhile(t1 -> { + throw new TestException(); }).subscribe(ts); ts.assertTerminated(); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorThrottleFirstTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorThrottleFirstTest.java similarity index 90% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorThrottleFirstTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorThrottleFirstTest.java index 38115f1829..818ef49f1e 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorThrottleFirstTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorThrottleFirstTest.java @@ -94,30 +94,15 @@ public void accept(NbpSubscriber NbpObserver) { } private void publishCompleted(final NbpSubscriber NbpObserver, long delay) { - innerScheduler.schedule(new Runnable() { - @Override - public void run() { - NbpObserver.onComplete(); - } - }, delay, TimeUnit.MILLISECONDS); + innerScheduler.schedule(NbpObserver::onComplete, delay, TimeUnit.MILLISECONDS); } private void publishError(final NbpSubscriber NbpObserver, long delay, final Exception error) { - innerScheduler.schedule(new Runnable() { - @Override - public void run() { - NbpObserver.onError(error); - } - }, delay, TimeUnit.MILLISECONDS); + innerScheduler.schedule(() -> NbpObserver.onError(error), delay, TimeUnit.MILLISECONDS); } private void publishNext(final NbpSubscriber NbpObserver, long delay, final T value) { - innerScheduler.schedule(new Runnable() { - @Override - public void run() { - NbpObserver.onNext(value); - } - }, delay, TimeUnit.MILLISECONDS); + innerScheduler.schedule(() -> NbpObserver.onNext(value), delay, TimeUnit.MILLISECONDS); } @Test diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTimeIntervalTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTimeIntervalTest.java similarity index 92% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTimeIntervalTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTimeIntervalTest.java index 75bc01a448..59cf96ffdd 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTimeIntervalTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTimeIntervalTest.java @@ -57,11 +57,11 @@ public void testTimeInterval() { subject.onComplete(); inOrder.verify(NbpObserver, times(1)).onNext( - new Timed(1, 1000, TIME_UNIT)); + new Timed<>(1, 1000, TIME_UNIT)); inOrder.verify(NbpObserver, times(1)).onNext( - new Timed(2, 2000, TIME_UNIT)); + new Timed<>(2, 2000, TIME_UNIT)); inOrder.verify(NbpObserver, times(1)).onNext( - new Timed(3, 3000, TIME_UNIT)); + new Timed<>(3, 3000, TIME_UNIT)); inOrder.verify(NbpObserver, times(1)).onComplete(); inOrder.verifyNoMoreInteractions(); } diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTimeoutTests.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTimeoutTests.java similarity index 87% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTimeoutTests.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTimeoutTests.java index 9dc6ba7fc9..b72e1d3d8b 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTimeoutTests.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTimeoutTests.java @@ -48,7 +48,7 @@ public void setUp() { @Test public void shouldNotTimeoutIfOnNextWithinTimeout() { NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); - NbpTestSubscriber ts = new NbpTestSubscriber(NbpObserver); + NbpTestSubscriber ts = new NbpTestSubscriber<>(NbpObserver); withTimeout.subscribe(ts); @@ -63,7 +63,7 @@ public void shouldNotTimeoutIfOnNextWithinTimeout() { @Test public void shouldNotTimeoutIfSecondOnNextWithinTimeout() { NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); - NbpTestSubscriber ts = new NbpTestSubscriber(NbpObserver); + NbpTestSubscriber ts = new NbpTestSubscriber<>(NbpObserver); withTimeout.subscribe(ts); @@ -80,7 +80,7 @@ public void shouldNotTimeoutIfSecondOnNextWithinTimeout() { @Test public void shouldTimeoutIfOnNextNotWithinTimeout() { NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); - NbpTestSubscriber ts = new NbpTestSubscriber(NbpObserver); + NbpTestSubscriber ts = new NbpTestSubscriber<>(NbpObserver); withTimeout.subscribe(ts); @@ -92,7 +92,7 @@ public void shouldTimeoutIfOnNextNotWithinTimeout() { @Test public void shouldTimeoutIfSecondOnNextNotWithinTimeout() { NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); - NbpTestSubscriber ts = new NbpTestSubscriber(NbpObserver); + NbpTestSubscriber ts = new NbpTestSubscriber<>(NbpObserver); withTimeout.subscribe(NbpObserver); testScheduler.advanceTimeBy(2, TimeUnit.SECONDS); underlyingSubject.onNext("One"); @@ -105,7 +105,7 @@ public void shouldTimeoutIfSecondOnNextNotWithinTimeout() { @Test public void shouldCompleteIfUnderlyingComletes() { NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); - NbpTestSubscriber ts = new NbpTestSubscriber(NbpObserver); + NbpTestSubscriber ts = new NbpTestSubscriber<>(NbpObserver); withTimeout.subscribe(NbpObserver); testScheduler.advanceTimeBy(2, TimeUnit.SECONDS); underlyingSubject.onComplete(); @@ -118,7 +118,7 @@ public void shouldCompleteIfUnderlyingComletes() { @Test public void shouldErrorIfUnderlyingErrors() { NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); - NbpTestSubscriber ts = new NbpTestSubscriber(NbpObserver); + NbpTestSubscriber ts = new NbpTestSubscriber<>(NbpObserver); withTimeout.subscribe(NbpObserver); testScheduler.advanceTimeBy(2, TimeUnit.SECONDS); underlyingSubject.onError(new UnsupportedOperationException()); @@ -133,7 +133,7 @@ public void shouldSwitchToOtherIfOnNextNotWithinTimeout() { NbpObservable source = underlyingSubject.timeout(TIMEOUT, TIME_UNIT, other, testScheduler); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); - NbpTestSubscriber ts = new NbpTestSubscriber(NbpObserver); + NbpTestSubscriber ts = new NbpTestSubscriber<>(NbpObserver); source.subscribe(ts); testScheduler.advanceTimeBy(2, TimeUnit.SECONDS); @@ -156,7 +156,7 @@ public void shouldSwitchToOtherIfOnErrorNotWithinTimeout() { NbpObservable source = underlyingSubject.timeout(TIMEOUT, TIME_UNIT, other, testScheduler); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); - NbpTestSubscriber ts = new NbpTestSubscriber(NbpObserver); + NbpTestSubscriber ts = new NbpTestSubscriber<>(NbpObserver); source.subscribe(ts); testScheduler.advanceTimeBy(2, TimeUnit.SECONDS); @@ -179,7 +179,7 @@ public void shouldSwitchToOtherIfOnCompletedNotWithinTimeout() { NbpObservable source = underlyingSubject.timeout(TIMEOUT, TIME_UNIT, other, testScheduler); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); - NbpTestSubscriber ts = new NbpTestSubscriber(NbpObserver); + NbpTestSubscriber ts = new NbpTestSubscriber<>(NbpObserver); source.subscribe(ts); testScheduler.advanceTimeBy(2, TimeUnit.SECONDS); @@ -202,7 +202,7 @@ public void shouldSwitchToOtherAndCanBeUnsubscribedIfOnNextNotWithinTimeout() { NbpObservable source = underlyingSubject.timeout(TIMEOUT, TIME_UNIT, other, testScheduler); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); - NbpTestSubscriber ts = new NbpTestSubscriber(NbpObserver); + NbpTestSubscriber ts = new NbpTestSubscriber<>(NbpObserver); source.subscribe(ts); testScheduler.advanceTimeBy(2, TimeUnit.SECONDS); @@ -233,30 +233,26 @@ public void shouldTimeoutIfSynchronizedObservableEmitFirstOnNextNotWithinTimeout final CountDownLatch timeoutSetuped = new CountDownLatch(1); final NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); - final NbpTestSubscriber ts = new NbpTestSubscriber(NbpObserver); - - new Thread(new Runnable() { - - @Override - public void run() { - NbpObservable.create(new NbpOnSubscribe() { - - @Override - public void accept(NbpSubscriber NbpSubscriber) { - NbpSubscriber.onSubscribe(EmptyDisposable.INSTANCE); - try { - timeoutSetuped.countDown(); - exit.await(); - } catch (InterruptedException e) { - e.printStackTrace(); - } - NbpSubscriber.onNext("a"); - NbpSubscriber.onComplete(); + final NbpTestSubscriber ts = new NbpTestSubscriber<>(NbpObserver); + + new Thread(() -> { + NbpObservable.create(new NbpOnSubscribe() { + + @Override + public void accept(NbpSubscriber NbpSubscriber) { + NbpSubscriber.onSubscribe(EmptyDisposable.INSTANCE); + try { + timeoutSetuped.countDown(); + exit.await(); + } catch (InterruptedException e) { + e.printStackTrace(); } + NbpSubscriber.onNext("a"); + NbpSubscriber.onComplete(); + } - }).timeout(1, TimeUnit.SECONDS, testScheduler) - .subscribe(ts); - } + }).timeout(1, TimeUnit.SECONDS, testScheduler) + .subscribe(ts); }).start(); timeoutSetuped.await(); @@ -285,7 +281,7 @@ public void accept(NbpSubscriber NbpSubscriber) { NbpObservable observableWithTimeout = never.timeout(1000, TimeUnit.MILLISECONDS, testScheduler); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); - NbpTestSubscriber ts = new NbpTestSubscriber(NbpObserver); + NbpTestSubscriber ts = new NbpTestSubscriber<>(NbpObserver); observableWithTimeout.subscribe(ts); testScheduler.advanceTimeBy(2000, TimeUnit.MILLISECONDS); @@ -316,7 +312,7 @@ public void accept(NbpSubscriber NbpSubscriber) { testScheduler); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); - NbpTestSubscriber ts = new NbpTestSubscriber(NbpObserver); + NbpTestSubscriber ts = new NbpTestSubscriber<>(NbpObserver); observableWithTimeout.subscribe(ts); testScheduler.advanceTimeBy(2000, TimeUnit.MILLISECONDS); @@ -347,7 +343,7 @@ public void accept(NbpSubscriber NbpSubscriber) { testScheduler); NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); - NbpTestSubscriber ts = new NbpTestSubscriber(NbpObserver); + NbpTestSubscriber ts = new NbpTestSubscriber<>(NbpObserver); observableWithTimeout.subscribe(ts); testScheduler.advanceTimeBy(2000, TimeUnit.MILLISECONDS); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTimeoutWithSelectorTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTimeoutWithSelectorTest.java similarity index 59% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTimeoutWithSelectorTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTimeoutWithSelectorTest.java index 2867268eee..63d42f8449 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTimeoutWithSelectorTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTimeoutWithSelectorTest.java @@ -42,19 +42,9 @@ public void testTimeoutSelectorNormal1() { NbpPublishSubject source = NbpPublishSubject.create(); final NbpPublishSubject timeout = NbpPublishSubject.create(); - Function> timeoutFunc = new Function>() { - @Override - public NbpObservable apply(Integer t1) { - return timeout; - } - }; + Function> timeoutFunc = t1 -> timeout; - Supplier> firstTimeoutFunc = new Supplier>() { - @Override - public NbpObservable get() { - return timeout; - } - }; + Supplier> firstTimeoutFunc = () -> timeout; NbpObservable other = NbpObservable.fromIterable(Arrays.asList(100)); @@ -82,19 +72,9 @@ public void testTimeoutSelectorTimeoutFirst() throws InterruptedException { NbpObservable source = NbpObservable.never(); final NbpPublishSubject timeout = NbpPublishSubject.create(); - Function> timeoutFunc = new Function>() { - @Override - public NbpObservable apply(Integer t1) { - return timeout; - } - }; + Function> timeoutFunc = t1 -> timeout; - Supplier> firstTimeoutFunc = new Supplier>() { - @Override - public NbpObservable get() { - return timeout; - } - }; + Supplier> firstTimeoutFunc = () -> timeout; NbpObservable other = NbpObservable.fromIterable(Arrays.asList(100)); @@ -116,18 +96,10 @@ public void testTimeoutSelectorFirstThrows() { NbpObservable source = NbpObservable.never(); final NbpPublishSubject timeout = NbpPublishSubject.create(); - Function> timeoutFunc = new Function>() { - @Override - public NbpObservable apply(Integer t1) { - return timeout; - } - }; + Function> timeoutFunc = t1 -> timeout; - Supplier> firstTimeoutFunc = new Supplier>() { - @Override - public NbpObservable get() { - throw new TestException(); - } + Supplier> firstTimeoutFunc = () -> { + throw new TestException(); }; NbpObservable other = NbpObservable.fromIterable(Arrays.asList(100)); @@ -147,19 +119,11 @@ public void testTimeoutSelectorSubsequentThrows() { NbpPublishSubject source = NbpPublishSubject.create(); final NbpPublishSubject timeout = NbpPublishSubject.create(); - Function> timeoutFunc = new Function>() { - @Override - public NbpObservable apply(Integer t1) { - throw new TestException(); - } + Function> timeoutFunc = t1 -> { + throw new TestException(); }; - Supplier> firstTimeoutFunc = new Supplier>() { - @Override - public NbpObservable get() { - return timeout; - } - }; + Supplier> firstTimeoutFunc = () -> timeout; NbpObservable other = NbpObservable.fromIterable(Arrays.asList(100)); @@ -181,19 +145,9 @@ public void testTimeoutSelectorFirstObservableThrows() { NbpPublishSubject source = NbpPublishSubject.create(); final NbpPublishSubject timeout = NbpPublishSubject.create(); - Function> timeoutFunc = new Function>() { - @Override - public NbpObservable apply(Integer t1) { - return timeout; - } - }; + Function> timeoutFunc = t1 -> timeout; - Supplier> firstTimeoutFunc = new Supplier>() { - @Override - public NbpObservable get() { - return NbpObservable. error(new TestException()); - } - }; + Supplier> firstTimeoutFunc = () -> NbpObservable. error(new TestException()); NbpObservable other = NbpObservable.fromIterable(Arrays.asList(100)); @@ -212,19 +166,9 @@ public void testTimeoutSelectorSubsequentObservableThrows() { NbpPublishSubject source = NbpPublishSubject.create(); final NbpPublishSubject timeout = NbpPublishSubject.create(); - Function> timeoutFunc = new Function>() { - @Override - public NbpObservable apply(Integer t1) { - return NbpObservable. error(new TestException()); - } - }; + Function> timeoutFunc = t1 -> NbpObservable. error(new TestException()); - Supplier> firstTimeoutFunc = new Supplier>() { - @Override - public NbpObservable get() { - return timeout; - } - }; + Supplier> firstTimeoutFunc = () -> timeout; NbpObservable other = NbpObservable.fromIterable(Arrays.asList(100)); @@ -246,19 +190,9 @@ public void testTimeoutSelectorWithFirstTimeoutFirstAndNoOtherObservable() { NbpPublishSubject source = NbpPublishSubject.create(); final NbpPublishSubject timeout = NbpPublishSubject.create(); - Supplier> firstTimeoutFunc = new Supplier>() { - @Override - public NbpObservable get() { - return timeout; - } - }; + Supplier> firstTimeoutFunc = () -> timeout; - Function> timeoutFunc = new Function>() { - @Override - public NbpObservable apply(Integer t1) { - return NbpPublishSubject.create(); - } - }; + Function> timeoutFunc = t1 -> NbpPublishSubject.create(); NbpSubscriber o = TestHelper.mockNbpSubscriber(); source.timeout(firstTimeoutFunc, timeoutFunc).subscribe(o); @@ -275,19 +209,9 @@ public void testTimeoutSelectorWithTimeoutFirstAndNoOtherObservable() { NbpPublishSubject source = NbpPublishSubject.create(); final NbpPublishSubject timeout = NbpPublishSubject.create(); - Supplier> firstTimeoutFunc = new Supplier>() { - @Override - public NbpObservable get() { - return NbpPublishSubject.create(); - } - }; + Supplier> firstTimeoutFunc = NbpPublishSubject::create; - Function> timeoutFunc = new Function>() { - @Override - public NbpObservable apply(Integer t1) { - return timeout; - } - }; + Function> timeoutFunc = t1 -> timeout; NbpSubscriber o = TestHelper.mockNbpSubscriber(); source.timeout(firstTimeoutFunc, timeoutFunc).subscribe(o); @@ -321,87 +245,69 @@ public void testTimeoutSelectorWithTimeoutAndOnNextRaceCondition() throws Interr final CountDownLatch enteredTimeoutOne = new CountDownLatch(1); final AtomicBoolean latchTimeout = new AtomicBoolean(false); - final Function> timeoutFunc = new Function>() { - @Override - public NbpObservable apply(Integer t1) { - if (t1 == 1) { - // Force "unsubscribe" run on another thread - return NbpObservable.create(new NbpOnSubscribe() { - @Override - public void accept(NbpSubscriber NbpSubscriber) { - NbpSubscriber.onSubscribe(EmptyDisposable.INSTANCE); - enteredTimeoutOne.countDown(); - // force the timeout message be sent after NbpObserver.onNext(2) - while (true) { - try { - if (!observerReceivedTwo.await(30, TimeUnit.SECONDS)) { - // CountDownLatch timeout - // There should be something wrong - latchTimeout.set(true); - } - break; - } catch (InterruptedException e) { - // Since we just want to emulate a busy method, - // we ignore the interrupt signal from Scheduler. + final Function> timeoutFunc = t1 -> { + if (t1 == 1) { + // Force "unsubscribe" run on another thread + return NbpObservable.create(new NbpOnSubscribe() { + @Override + public void accept(NbpSubscriber NbpSubscriber) { + NbpSubscriber.onSubscribe(EmptyDisposable.INSTANCE); + enteredTimeoutOne.countDown(); + // force the timeout message be sent after NbpObserver.onNext(2) + while (true) { + try { + if (!observerReceivedTwo.await(30, TimeUnit.SECONDS)) { + // CountDownLatch timeout + // There should be something wrong + latchTimeout.set(true); } + break; + } catch (InterruptedException e) { + // Since we just want to emulate a busy method, + // we ignore the interrupt signal from Scheduler. } - NbpSubscriber.onNext(1); - timeoutEmittedOne.countDown(); } - }).subscribeOn(Schedulers.newThread()); - } else { - return NbpPublishSubject.create(); - } + NbpSubscriber.onNext(1); + timeoutEmittedOne.countDown(); + } + }).subscribeOn(Schedulers.newThread()); + } else { + return NbpPublishSubject.create(); } }; final NbpSubscriber o = TestHelper.mockNbpSubscriber(); - doAnswer(new Answer() { - - @Override - public Void answer(InvocationOnMock invocation) throws Throwable { - observerReceivedTwo.countDown(); - return null; - } - + doAnswer(invocation -> { + observerReceivedTwo.countDown(); + return null; }).when(o).onNext(2); - doAnswer(new Answer() { - - @Override - public Void answer(InvocationOnMock invocation) throws Throwable { - observerCompleted.countDown(); - return null; - } - + doAnswer(invocation -> { + observerCompleted.countDown(); + return null; }).when(o).onComplete(); - final NbpTestSubscriber ts = new NbpTestSubscriber(o); + final NbpTestSubscriber ts = new NbpTestSubscriber<>(o); - new Thread(new Runnable() { - - @Override - public void run() { - NbpPublishSubject source = NbpPublishSubject.create(); - source.timeout(timeoutFunc, NbpObservable.just(3)).subscribe(ts); - source.onNext(1); // start timeout - try { - if(!enteredTimeoutOne.await(30, TimeUnit.SECONDS)) { - latchTimeout.set(true); - } - } catch (InterruptedException e) { - e.printStackTrace(); + new Thread(() -> { + NbpPublishSubject source = NbpPublishSubject.create(); + source.timeout(timeoutFunc, NbpObservable.just(3)).subscribe(ts); + source.onNext(1); // start timeout + try { + if(!enteredTimeoutOne.await(30, TimeUnit.SECONDS)) { + latchTimeout.set(true); } - source.onNext(2); // disable timeout - try { - if(!timeoutEmittedOne.await(30, TimeUnit.SECONDS)) { - latchTimeout.set(true); - } - } catch (InterruptedException e) { - e.printStackTrace(); + } catch (InterruptedException e) { + e.printStackTrace(); + } + source.onNext(2); // disable timeout + try { + if(!timeoutEmittedOne.await(30, TimeUnit.SECONDS)) { + latchTimeout.set(true); } - source.onComplete(); + } catch (InterruptedException e) { + e.printStackTrace(); } - + source.onComplete(); }).start(); if(!observerCompleted.await(30, TimeUnit.SECONDS)) { diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTimestampTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTimestampTest.java similarity index 79% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTimestampTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTimestampTest.java index 750f2f7b19..cb658d389d 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTimestampTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorTimestampTest.java @@ -50,9 +50,9 @@ public void timestampWithScheduler() { InOrder inOrder = inOrder(NbpObserver); - inOrder.verify(NbpObserver, times(1)).onNext(new Timed(1, 0, TimeUnit.MILLISECONDS)); - inOrder.verify(NbpObserver, times(1)).onNext(new Timed(2, 100, TimeUnit.MILLISECONDS)); - inOrder.verify(NbpObserver, times(1)).onNext(new Timed(3, 200, TimeUnit.MILLISECONDS)); + inOrder.verify(NbpObserver, times(1)).onNext(new Timed<>(1, 0, TimeUnit.MILLISECONDS)); + inOrder.verify(NbpObserver, times(1)).onNext(new Timed<>(2, 100, TimeUnit.MILLISECONDS)); + inOrder.verify(NbpObserver, times(1)).onNext(new Timed<>(3, 200, TimeUnit.MILLISECONDS)); verify(NbpObserver, never()).onError(any(Throwable.class)); verify(NbpObserver, never()).onComplete(); @@ -74,9 +74,9 @@ public void timestampWithScheduler2() { InOrder inOrder = inOrder(NbpObserver); - inOrder.verify(NbpObserver, times(1)).onNext(new Timed(1, 0, TimeUnit.MILLISECONDS)); - inOrder.verify(NbpObserver, times(1)).onNext(new Timed(2, 0, TimeUnit.MILLISECONDS)); - inOrder.verify(NbpObserver, times(1)).onNext(new Timed(3, 200, TimeUnit.MILLISECONDS)); + inOrder.verify(NbpObserver, times(1)).onNext(new Timed<>(1, 0, TimeUnit.MILLISECONDS)); + inOrder.verify(NbpObserver, times(1)).onNext(new Timed<>(2, 0, TimeUnit.MILLISECONDS)); + inOrder.verify(NbpObserver, times(1)).onNext(new Timed<>(3, 200, TimeUnit.MILLISECONDS)); verify(NbpObserver, never()).onError(any(Throwable.class)); verify(NbpObserver, never()).onComplete(); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorToMapTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorToMapTest.java similarity index 62% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorToMapTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorToMapTest.java index 54f11be314..d9669789a3 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorToMapTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorToMapTest.java @@ -32,18 +32,8 @@ public void before() { objectObserver = TestHelper.mockNbpSubscriber(); } - Function lengthFunc = new Function() { - @Override - public Integer apply(String t1) { - return t1.length(); - } - }; - Function duplicate = new Function() { - @Override - public String apply(String t1) { - return t1 + t1; - } - }; + Function lengthFunc = String::length; + Function duplicate = t1 -> t1 + t1; @Test public void testToMap() { @@ -51,7 +41,7 @@ public void testToMap() { NbpObservable> mapped = source.toMap(lengthFunc); - Map expected = new HashMap(); + Map expected = new HashMap<>(); expected.put(1, "a"); expected.put(2, "bb"); expected.put(3, "ccc"); @@ -70,7 +60,7 @@ public void testToMapWithValueSelector() { NbpObservable> mapped = source.toMap(lengthFunc, duplicate); - Map expected = new HashMap(); + Map expected = new HashMap<>(); expected.put(1, "aa"); expected.put(2, "bbbb"); expected.put(3, "cccccc"); @@ -87,18 +77,15 @@ public void testToMapWithValueSelector() { public void testToMapWithError() { NbpObservable source = NbpObservable.just("a", "bb", "ccc", "dddd"); - Function lengthFuncErr = new Function() { - @Override - public Integer apply(String t1) { - if ("bb".equals(t1)) { - throw new RuntimeException("Forced Failure"); - } - return t1.length(); + Function lengthFuncErr = t1 -> { + if ("bb".equals(t1)) { + throw new RuntimeException("Forced Failure"); } + return t1.length(); }; NbpObservable> mapped = source.toMap(lengthFuncErr); - Map expected = new HashMap(); + Map expected = new HashMap<>(); expected.put(1, "a"); expected.put(2, "bb"); expected.put(3, "ccc"); @@ -116,19 +103,16 @@ public Integer apply(String t1) { public void testToMapWithErrorInValueSelector() { NbpObservable source = NbpObservable.just("a", "bb", "ccc", "dddd"); - Function duplicateErr = new Function() { - @Override - public String apply(String t1) { - if ("bb".equals(t1)) { - throw new RuntimeException("Forced failure"); - } - return t1 + t1; + Function duplicateErr = t1 -> { + if ("bb".equals(t1)) { + throw new RuntimeException("Forced failure"); } + return t1 + t1; }; NbpObservable> mapped = source.toMap(lengthFunc, duplicateErr); - Map expected = new HashMap(); + Map expected = new HashMap<>(); expected.put(1, "aa"); expected.put(2, "bbbb"); expected.put(3, "cccccc"); @@ -146,35 +130,20 @@ public String apply(String t1) { public void testToMapWithFactory() { NbpObservable source = NbpObservable.just("a", "bb", "ccc", "dddd"); - Supplier> mapFactory = new Supplier>() { - @Override - public Map get() { - return new LinkedHashMap() { - /** */ - private static final long serialVersionUID = -3296811238780863394L; - - @Override - protected boolean removeEldestEntry(Map.Entry eldest) { - return size() > 3; - } - }; - } - }; + Supplier> mapFactory = () -> new LinkedHashMap() { + /** */ + private static final long serialVersionUID = -3296811238780863394L; - Function lengthFunc = new Function() { @Override - public Integer apply(String t1) { - return t1.length(); + protected boolean removeEldestEntry(Map.Entry eldest) { + return size() > 3; } }; - NbpObservable> mapped = source.toMap(lengthFunc, new Function() { - @Override - public String apply(String v) { - return v; - } - }, mapFactory); - Map expected = new LinkedHashMap(); + Function lengthFunc = String::length; + NbpObservable> mapped = source.toMap(lengthFunc, v -> v, mapFactory); + + Map expected = new LinkedHashMap<>(); expected.put(2, "bb"); expected.put(3, "ccc"); expected.put(4, "dddd"); @@ -190,27 +159,14 @@ public String apply(String v) { public void testToMapWithErrorThrowingFactory() { NbpObservable source = NbpObservable.just("a", "bb", "ccc", "dddd"); - Supplier> mapFactory = new Supplier>() { - @Override - public Map get() { - throw new RuntimeException("Forced failure"); - } + Supplier> mapFactory = () -> { + throw new RuntimeException("Forced failure"); }; - Function lengthFunc = new Function() { - @Override - public Integer apply(String t1) { - return t1.length(); - } - }; - NbpObservable> mapped = source.toMap(lengthFunc, new Function() { - @Override - public String apply(String v) { - return v; - } - }, mapFactory); + Function lengthFunc = String::length; + NbpObservable> mapped = source.toMap(lengthFunc, v -> v, mapFactory); - Map expected = new LinkedHashMap(); + Map expected = new LinkedHashMap<>(); expected.put(2, "bb"); expected.put(3, "ccc"); expected.put(4, "dddd"); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorToMultimapTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorToMultimapTest.java similarity index 63% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorToMultimapTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorToMultimapTest.java index 4530788860..018acceeca 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorToMultimapTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorToMultimapTest.java @@ -32,18 +32,8 @@ public void before() { objectObserver = TestHelper.mockNbpSubscriber(); } - Function lengthFunc = new Function() { - @Override - public Integer apply(String t1) { - return t1.length(); - } - }; - Function duplicate = new Function() { - @Override - public String apply(String t1) { - return t1 + t1; - } - }; + Function lengthFunc = String::length; + Function duplicate = t1 -> t1 + t1; @Test public void testToMultimap() { @@ -51,7 +41,7 @@ public void testToMultimap() { NbpObservable>> mapped = source.toMultimap(lengthFunc); - Map> expected = new HashMap>(); + Map> expected = new HashMap<>(); expected.put(1, Arrays.asList("a", "b")); expected.put(2, Arrays.asList("cc", "dd")); @@ -68,7 +58,7 @@ public void testToMultimapWithValueSelector() { NbpObservable>> mapped = source.toMultimap(lengthFunc, duplicate); - Map> expected = new HashMap>(); + Map> expected = new HashMap<>(); expected.put(1, Arrays.asList("aa", "bb")); expected.put(2, Arrays.asList("cccc", "dddd")); @@ -83,38 +73,23 @@ public void testToMultimapWithValueSelector() { public void testToMultimapWithMapFactory() { NbpObservable source = NbpObservable.just("a", "b", "cc", "dd", "eee", "fff"); - Supplier>> mapFactory = new Supplier>>() { - @Override - public Map> get() { - return new LinkedHashMap>() { - /** */ - private static final long serialVersionUID = -2084477070717362859L; - - @Override - protected boolean removeEldestEntry(Map.Entry> eldest) { - return size() > 2; - } - }; - } - }; + Supplier>> mapFactory = () -> new LinkedHashMap>() { + /** */ + private static final long serialVersionUID = -2084477070717362859L; - Function identity = new Function() { @Override - public String apply(String v) { - return v; + protected boolean removeEldestEntry(Map.Entry> eldest) { + return size() > 2; } }; + + Function identity = v -> v; NbpObservable>> mapped = source.toMultimap( lengthFunc, identity, - mapFactory, new Function>() { - @Override - public Collection apply(Integer v) { - return new ArrayList(); - } - }); - - Map> expected = new HashMap>(); + mapFactory, v -> new ArrayList<>()); + + Map> expected = new HashMap<>(); expected.put(2, Arrays.asList("cc", "dd")); expected.put(3, Arrays.asList("eee", "fff")); @@ -129,36 +104,23 @@ public Collection apply(Integer v) { public void testToMultimapWithCollectionFactory() { NbpObservable source = NbpObservable.just("cc", "dd", "eee", "eee"); - Function> collectionFactory = new Function>() { - @Override - public Collection apply(Integer t1) { - if (t1 == 2) { - return new ArrayList(); - } else { - return new HashSet(); - } + Function> collectionFactory = t1 -> { + if (t1 == 2) { + return new ArrayList<>(); + } else { + return new HashSet<>(); } }; - Function identity = new Function() { - @Override - public String apply(String v) { - return v; - } - }; - Supplier>> mapSupplier = new Supplier>>() { - @Override - public Map> get() { - return new HashMap>(); - } - }; + Function identity = v -> v; + Supplier>> mapSupplier = HashMap::new; NbpObservable>> mapped = source .toMultimap(lengthFunc, identity, mapSupplier, collectionFactory); - Map> expected = new HashMap>(); + Map> expected = new HashMap<>(); expected.put(2, Arrays.asList("cc", "dd")); - expected.put(3, new HashSet(Arrays.asList("eee"))); + expected.put(3, new HashSet<>(Arrays.asList("eee"))); mapped.subscribe(objectObserver); @@ -171,19 +133,16 @@ public Map> get() { public void testToMultimapWithError() { NbpObservable source = NbpObservable.just("a", "b", "cc", "dd"); - Function lengthFuncErr = new Function() { - @Override - public Integer apply(String t1) { - if ("b".equals(t1)) { - throw new RuntimeException("Forced Failure"); - } - return t1.length(); + Function lengthFuncErr = t1 -> { + if ("b".equals(t1)) { + throw new RuntimeException("Forced Failure"); } + return t1.length(); }; NbpObservable>> mapped = source.toMultimap(lengthFuncErr); - Map> expected = new HashMap>(); + Map> expected = new HashMap<>(); expected.put(1, Arrays.asList("a", "b")); expected.put(2, Arrays.asList("cc", "dd")); @@ -198,19 +157,16 @@ public Integer apply(String t1) { public void testToMultimapWithErrorInValueSelector() { NbpObservable source = NbpObservable.just("a", "b", "cc", "dd"); - Function duplicateErr = new Function() { - @Override - public String apply(String t1) { - if ("b".equals(t1)) { - throw new RuntimeException("Forced failure"); - } - return t1 + t1; + Function duplicateErr = t1 -> { + if ("b".equals(t1)) { + throw new RuntimeException("Forced failure"); } + return t1 + t1; }; NbpObservable>> mapped = source.toMultimap(lengthFunc, duplicateErr); - Map> expected = new HashMap>(); + Map> expected = new HashMap<>(); expected.put(1, Arrays.asList("aa", "bb")); expected.put(2, Arrays.asList("cccc", "dddd")); @@ -225,22 +181,14 @@ public String apply(String t1) { public void testToMultimapWithMapThrowingFactory() { NbpObservable source = NbpObservable.just("a", "b", "cc", "dd", "eee", "fff"); - Supplier>> mapFactory = new Supplier>>() { - @Override - public Map> get() { - throw new RuntimeException("Forced failure"); - } + Supplier>> mapFactory = () -> { + throw new RuntimeException("Forced failure"); }; NbpObservable>> mapped = source - .toMultimap(lengthFunc, new Function() { - @Override - public String apply(String v) { - return v; - } - }, mapFactory); - - Map> expected = new HashMap>(); + .toMultimap(lengthFunc, v -> v, mapFactory); + + Map> expected = new HashMap<>(); expected.put(2, Arrays.asList("cc", "dd")); expected.put(3, Arrays.asList("eee", "fff")); @@ -255,34 +203,21 @@ public String apply(String v) { public void testToMultimapWithThrowingCollectionFactory() { NbpObservable source = NbpObservable.just("cc", "cc", "eee", "eee"); - Function> collectionFactory = new Function>() { - @Override - public Collection apply(Integer t1) { - if (t1 == 2) { - throw new RuntimeException("Forced failure"); - } else { - return new HashSet(); - } + Function> collectionFactory = t1 -> { + if (t1 == 2) { + throw new RuntimeException("Forced failure"); + } else { + return new HashSet<>(); } }; - Function identity = new Function() { - @Override - public String apply(String v) { - return v; - } - }; - Supplier>> mapSupplier = new Supplier>>() { - @Override - public Map> get() { - return new HashMap>(); - } - }; + Function identity = v -> v; + Supplier>> mapSupplier = HashMap::new; NbpObservable>> mapped = source.toMultimap(lengthFunc, identity, mapSupplier, collectionFactory); - Map> expected = new HashMap>(); + Map> expected = new HashMap<>(); expected.put(2, Arrays.asList("cc", "dd")); expected.put(3, Collections.singleton("eee")); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorToObservableListTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorToObservableListTest.java similarity index 100% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorToObservableListTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorToObservableListTest.java diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorToObservableSortedListTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorToObservableSortedListTest.java similarity index 93% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorToObservableSortedListTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorToObservableSortedListTest.java index 7998113777..3f44ebea88 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorToObservableSortedListTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorToObservableSortedListTest.java @@ -43,14 +43,7 @@ public void testSortedList() { @Test public void testSortedListWithCustomFunction() { NbpObservable w = NbpObservable.just(1, 3, 2, 5, 4); - NbpObservable> NbpObservable = w.toSortedList(new Comparator() { - - @Override - public int compare(Integer t1, Integer t2) { - return t2 - t1; - } - - }); + NbpObservable> NbpObservable = w.toSortedList((t1, t2) -> t2 - t1); NbpSubscriber> NbpObserver = TestHelper.mockNbpSubscriber(); NbpObservable.subscribe(NbpObserver); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorUnsubscribeOnTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorUnsubscribeOnTest.java similarity index 95% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorUnsubscribeOnTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorUnsubscribeOnTest.java index 5b59133dd1..6dcfffe187 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorUnsubscribeOnTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorUnsubscribeOnTest.java @@ -33,7 +33,7 @@ public void testUnsubscribeWhenSubscribeOnAndUnsubscribeOnAreOnSameThread() thro UIEventLoopScheduler UI_EVENT_LOOP = new UIEventLoopScheduler(); try { final ThreadSubscription subscription = new ThreadSubscription(); - final AtomicReference subscribeThread = new AtomicReference(); + final AtomicReference subscribeThread = new AtomicReference<>(); NbpObservable w = NbpObservable.create(new NbpOnSubscribe() { @Override @@ -46,7 +46,7 @@ public void accept(NbpSubscriber t1) { } }); - NbpTestSubscriber NbpObserver = new NbpTestSubscriber(); + NbpTestSubscriber NbpObserver = new NbpTestSubscriber<>(); w.subscribeOn(UI_EVENT_LOOP).observeOn(Schedulers.computation()).unsubscribeOn(UI_EVENT_LOOP).subscribe(NbpObserver); NbpObserver.awaitTerminalEvent(1, TimeUnit.SECONDS); @@ -77,7 +77,7 @@ public void testUnsubscribeWhenSubscribeOnAndUnsubscribeOnAreOnDifferentThreads( UIEventLoopScheduler UI_EVENT_LOOP = new UIEventLoopScheduler(); try { final ThreadSubscription subscription = new ThreadSubscription(); - final AtomicReference subscribeThread = new AtomicReference(); + final AtomicReference subscribeThread = new AtomicReference<>(); NbpObservable w = NbpObservable.create(new NbpOnSubscribe() { @Override @@ -90,7 +90,7 @@ public void accept(NbpSubscriber t1) { } }); - NbpTestSubscriber NbpObserver = new NbpTestSubscriber(); + NbpTestSubscriber NbpObserver = new NbpTestSubscriber<>(); w.subscribeOn(Schedulers.newThread()).observeOn(Schedulers.computation()).unsubscribeOn(UI_EVENT_LOOP).subscribe(NbpObserver); NbpObserver.awaitTerminalEvent(1, TimeUnit.SECONDS); @@ -148,14 +148,9 @@ public UIEventLoopScheduler() { * DON'T DO THIS IN PRODUCTION CODE */ final CountDownLatch latch = new CountDownLatch(1); - eventLoop.scheduleDirect(new Runnable() { - - @Override - public void run() { - t = Thread.currentThread(); - latch.countDown(); - } - + eventLoop.scheduleDirect(() -> { + t = Thread.currentThread(); + latch.countDown(); }); try { latch.await(); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowWithObservableTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowWithObservableTest.java similarity index 87% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowWithObservableTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowWithObservableTest.java index feab752c65..f16496c56c 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowWithObservableTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowWithObservableTest.java @@ -38,7 +38,7 @@ public void testWindowViaObservableNormal1() { final NbpSubscriber o = TestHelper.mockNbpSubscriber(); - final List> values = new ArrayList>(); + final List> values = new ArrayList<>(); NbpSubscriber> wo = new NbpObserver>() { @Override @@ -96,7 +96,7 @@ public void testWindowViaObservableBoundaryCompletes() { final NbpSubscriber o = TestHelper.mockNbpSubscriber(); - final List> values = new ArrayList>(); + final List> values = new ArrayList<>(); NbpSubscriber> wo = new NbpObserver>() { @Override @@ -152,7 +152,7 @@ public void testWindowViaObservableBoundaryThrows() { final NbpSubscriber o = TestHelper.mockNbpSubscriber(); - final List> values = new ArrayList>(); + final List> values = new ArrayList<>(); NbpSubscriber> wo = new NbpObserver>() { @Override @@ -202,7 +202,7 @@ public void testWindowViaObservableSourceThrows() { final NbpSubscriber o = TestHelper.mockNbpSubscriber(); - final List> values = new ArrayList>(); + final List> values = new ArrayList<>(); NbpSubscriber> wo = new NbpObserver>() { @Override @@ -266,12 +266,7 @@ public void onNext(NbpObservable t) { super.onNext(t); } }; - source.window(new Supplier>() { - @Override - public NbpObservable get() { - return NbpObservable.never(); - } - }).subscribe(ts); + source.window(NbpObservable::never).subscribe(ts); source.onNext(1); source.onComplete(); @@ -283,14 +278,9 @@ public NbpObservable get() { @Test public void testWindowViaObservableNoUnsubscribe() { NbpObservable source = NbpObservable.range(1, 10); - Supplier> boundary = new Supplier>() { - @Override - public NbpObservable get() { - return NbpObservable.empty(); - } - }; + Supplier> boundary = NbpObservable::empty; - NbpTestSubscriber> ts = new NbpTestSubscriber>(); + NbpTestSubscriber> ts = new NbpTestSubscriber<>(); source.window(boundary).unsafeSubscribe(ts); assertFalse(ts.isCancelled()); @@ -300,14 +290,9 @@ public NbpObservable get() { public void testBoundaryUnsubscribedOnMainCompletion() { NbpPublishSubject source = NbpPublishSubject.create(); final NbpPublishSubject boundary = NbpPublishSubject.create(); - Supplier> boundaryFunc = new Supplier>() { - @Override - public NbpObservable get() { - return boundary; - } - }; + Supplier> boundaryFunc = () -> boundary; - NbpTestSubscriber> ts = new NbpTestSubscriber>(); + NbpTestSubscriber> ts = new NbpTestSubscriber<>(); source.window(boundaryFunc).subscribe(ts); assertTrue(source.hasSubscribers()); @@ -326,14 +311,9 @@ public NbpObservable get() { public void testMainUnsubscribedOnBoundaryCompletion() { NbpPublishSubject source = NbpPublishSubject.create(); final NbpPublishSubject boundary = NbpPublishSubject.create(); - Supplier> boundaryFunc = new Supplier>() { - @Override - public NbpObservable get() { - return boundary; - } - }; + Supplier> boundaryFunc = () -> boundary; - NbpTestSubscriber> ts = new NbpTestSubscriber>(); + NbpTestSubscriber> ts = new NbpTestSubscriber<>(); source.window(boundaryFunc).subscribe(ts); assertTrue(source.hasSubscribers()); @@ -354,14 +334,9 @@ public NbpObservable get() { public void testChildUnsubscribed() { NbpPublishSubject source = NbpPublishSubject.create(); final NbpPublishSubject boundary = NbpPublishSubject.create(); - Supplier> boundaryFunc = new Supplier>() { - @Override - public NbpObservable get() { - return boundary; - } - }; + Supplier> boundaryFunc = () -> boundary; - NbpTestSubscriber> ts = new NbpTestSubscriber>(); + NbpTestSubscriber> ts = new NbpTestSubscriber<>(); source.window(boundaryFunc).subscribe(ts); assertTrue(source.hasSubscribers()); @@ -384,15 +359,12 @@ public void newBoundaryCalledAfterWindowClosed() { final AtomicInteger calls = new AtomicInteger(); NbpPublishSubject source = NbpPublishSubject.create(); final NbpPublishSubject boundary = NbpPublishSubject.create(); - Supplier> boundaryFunc = new Supplier>() { - @Override - public NbpObservable get() { - calls.getAndIncrement(); - return boundary; - } + Supplier> boundaryFunc = () -> { + calls.getAndIncrement(); + return boundary; }; - NbpTestSubscriber> ts = new NbpTestSubscriber>(); + NbpTestSubscriber> ts = new NbpTestSubscriber<>(); source.window(boundaryFunc).subscribe(ts); source.onNext(1); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowWithSizeTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowWithSizeTest.java similarity index 77% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowWithSizeTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowWithSizeTest.java index f361c79b3e..a81ae9253f 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowWithSizeTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowWithSizeTest.java @@ -32,20 +32,10 @@ public class NbpOperatorWindowWithSizeTest { private static List> toLists(NbpObservable> observables) { - final List> lists = new ArrayList>(); - NbpObservable.concat(observables.map(new Function, NbpObservable>>() { - @Override - public NbpObservable> apply(NbpObservable xs) { - return xs.toList(); - } - })) + final List> lists = new ArrayList<>(); + NbpObservable.concat(observables.map(NbpObservable::toList)) .toBlocking() - .forEach(new Consumer>() { - @Override - public void accept(List xs) { - lists.add(xs); - } - }); + .forEach(lists::add); return lists; } @@ -103,16 +93,9 @@ public void testSkipAndCountWindowsWithGaps() { @Test public void testWindowUnsubscribeNonOverlapping() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); final AtomicInteger count = new AtomicInteger(); - NbpObservable.merge(NbpObservable.range(1, 10000).doOnNext(new Consumer() { - - @Override - public void accept(Integer t1) { - count.incrementAndGet(); - } - - }).window(5).take(2)).subscribe(ts); + NbpObservable.merge(NbpObservable.range(1, 10000).doOnNext(t1 -> count.incrementAndGet()).window(5).take(2)).subscribe(ts); ts.awaitTerminalEvent(500, TimeUnit.MILLISECONDS); ts.assertTerminated(); ts.assertValues(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); @@ -122,17 +105,10 @@ public void accept(Integer t1) { @Test public void testWindowUnsubscribeNonOverlappingAsyncSource() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); final AtomicInteger count = new AtomicInteger(); NbpObservable.merge(NbpObservable.range(1, 100000) - .doOnNext(new Consumer() { - - @Override - public void accept(Integer t1) { - count.incrementAndGet(); - } - - }) + .doOnNext(t1 -> count.incrementAndGet()) .observeOn(Schedulers.computation()) .window(5) .take(2)) @@ -146,16 +122,9 @@ public void accept(Integer t1) { @Test public void testWindowUnsubscribeOverlapping() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); final AtomicInteger count = new AtomicInteger(); - NbpObservable.merge(NbpObservable.range(1, 10000).doOnNext(new Consumer() { - - @Override - public void accept(Integer t1) { - count.incrementAndGet(); - } - - }).window(5, 4).take(2)).subscribe(ts); + NbpObservable.merge(NbpObservable.range(1, 10000).doOnNext(t1 -> count.incrementAndGet()).window(5, 4).take(2)).subscribe(ts); ts.awaitTerminalEvent(500, TimeUnit.MILLISECONDS); ts.assertTerminated(); // System.out.println(ts.getOnNextEvents()); @@ -165,17 +134,10 @@ public void accept(Integer t1) { @Test public void testWindowUnsubscribeOverlappingAsyncSource() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); final AtomicInteger count = new AtomicInteger(); NbpObservable.merge(NbpObservable.range(1, 100000) - .doOnNext(new Consumer() { - - @Override - public void accept(Integer t1) { - count.incrementAndGet(); - } - - }) + .doOnNext(t1 -> count.incrementAndGet()) .observeOn(Schedulers.computation()) .window(5, 4) .take(2), 128) @@ -188,7 +150,7 @@ public void accept(Integer t1) { } private List list(String... args) { - List list = new ArrayList(); + List list = new ArrayList<>(); for (String arg : args) { list.add(arg); } @@ -222,19 +184,14 @@ public void accept(NbpSubscriber s) { @Test public void testTakeFlatMapCompletes() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); final int indicator = 999999999; hotStream() .window(10) .take(2) - .flatMap(new Function, NbpObservable>() { - @Override - public NbpObservable apply(NbpObservable w) { - return w.startWith(indicator); - } - }).subscribe(ts); + .flatMap(w -> w.startWith(indicator)).subscribe(ts); ts.awaitTerminalEvent(2, TimeUnit.SECONDS); ts.assertComplete(); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowWithStartEndObservableTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowWithStartEndObservableTest.java similarity index 62% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowWithStartEndObservableTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowWithStartEndObservableTest.java index 80a1af0a69..6b8a80248b 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowWithStartEndObservableTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowWithStartEndObservableTest.java @@ -41,8 +41,8 @@ public void before() { @Test public void testObservableBasedOpenerAndCloser() { - final List list = new ArrayList(); - final List> lists = new ArrayList>(); + final List list = new ArrayList<>(); + final List> lists = new ArrayList<>(); NbpObservable source = NbpObservable.create(new NbpOnSubscribe() { @Override @@ -57,29 +57,18 @@ public void accept(NbpSubscriber NbpObserver) { } }); - NbpObservable openings = NbpObservable.create(new NbpOnSubscribe() { - @Override - public void accept(NbpSubscriber NbpObserver) { - NbpObserver.onSubscribe(EmptyDisposable.INSTANCE); - push(NbpObserver, new Object(), 50); - push(NbpObserver, new Object(), 200); - complete(NbpObserver, 250); - } + NbpObservable openings = NbpObservable.create(NbpObserver -> { + NbpObserver.onSubscribe(EmptyDisposable.INSTANCE); + push(NbpObserver, new Object(), 50); + push(NbpObserver, new Object(), 200); + complete(NbpObserver, 250); }); - Function> closer = new Function>() { - @Override - public NbpObservable apply(Object opening) { - return NbpObservable.create(new NbpOnSubscribe() { - @Override - public void accept(NbpSubscriber NbpObserver) { - NbpObserver.onSubscribe(EmptyDisposable.INSTANCE); - push(NbpObserver, new Object(), 100); - complete(NbpObserver, 101); - } - }); - } - }; + Function> closer = opening -> NbpObservable.create(NbpObserver -> { + NbpObserver.onSubscribe(EmptyDisposable.INSTANCE); + push(NbpObserver, new Object(), 100); + complete(NbpObserver, 101); + }); NbpObservable> windowed = source.window(openings, closer); windowed.subscribe(observeWindow(list, lists)); @@ -92,8 +81,8 @@ public void accept(NbpSubscriber NbpObserver) { @Test public void testObservableBasedCloser() { - final List list = new ArrayList(); - final List> lists = new ArrayList>(); + final List list = new ArrayList<>(); + final List> lists = new ArrayList<>(); NbpObservable source = NbpObservable.create(new NbpOnSubscribe() { @Override @@ -112,19 +101,16 @@ public void accept(NbpSubscriber NbpObserver) { int calls; @Override public NbpObservable get() { - return NbpObservable.create(new NbpOnSubscribe() { - @Override - public void accept(NbpSubscriber NbpObserver) { - NbpObserver.onSubscribe(EmptyDisposable.INSTANCE); - int c = calls++; - if (c == 0) { - push(NbpObserver, new Object(), 100); - } else - if (c == 1) { - push(NbpObserver, new Object(), 100); - } else { - complete(NbpObserver, 101); - } + return NbpObservable.create(NbpObserver -> { + NbpObserver.onSubscribe(EmptyDisposable.INSTANCE); + int c = calls++; + if (c == 0) { + push(NbpObserver, new Object(), 100); + } else + if (c == 1) { + push(NbpObserver, new Object(), 100); + } else { + complete(NbpObserver, 101); } }); } @@ -141,7 +127,7 @@ public void accept(NbpSubscriber NbpObserver) { } private List list(String... args) { - List list = new ArrayList(); + List list = new ArrayList<>(); for (String arg : args) { list.add(arg); } @@ -149,46 +135,31 @@ private List list(String... args) { } private void push(final NbpSubscriber NbpObserver, final T value, int delay) { - innerScheduler.schedule(new Runnable() { - @Override - public void run() { - NbpObserver.onNext(value); - } - }, delay, TimeUnit.MILLISECONDS); + innerScheduler.schedule(() -> NbpObserver.onNext(value), delay, TimeUnit.MILLISECONDS); } private void complete(final NbpSubscriber NbpObserver, int delay) { - innerScheduler.schedule(new Runnable() { - @Override - public void run() { - NbpObserver.onComplete(); - } - }, delay, TimeUnit.MILLISECONDS); + innerScheduler.schedule(NbpObserver::onComplete, delay, TimeUnit.MILLISECONDS); } private Consumer> observeWindow(final List list, final List> lists) { - return new Consumer>() { + return stringObservable -> stringObservable.subscribe(new NbpObserver() { @Override - public void accept(NbpObservable stringObservable) { - stringObservable.subscribe(new NbpObserver() { - @Override - public void onComplete() { - lists.add(new ArrayList(list)); - list.clear(); - } + public void onComplete() { + lists.add(new ArrayList<>(list)); + list.clear(); + } - @Override - public void onError(Throwable e) { - fail(e.getMessage()); - } + @Override + public void onError(Throwable e) { + fail(e.getMessage()); + } - @Override - public void onNext(String args) { - list.add(args); - } - }); + @Override + public void onNext(String args) { + list.add(args); } - }; + }); } @Test @@ -198,14 +169,9 @@ public void testNoUnsubscribeAndNoLeak() { NbpPublishSubject open = NbpPublishSubject.create(); final NbpPublishSubject close = NbpPublishSubject.create(); - NbpTestSubscriber> ts = new NbpTestSubscriber>(); + NbpTestSubscriber> ts = new NbpTestSubscriber<>(); - source.window(open, new Function>() { - @Override - public NbpObservable apply(Integer t) { - return close; - } - }).unsafeSubscribe(ts); + source.window(open, t -> close).unsafeSubscribe(ts); open.onNext(1); source.onNext(1); @@ -235,14 +201,9 @@ public void testUnsubscribeAll() { NbpPublishSubject open = NbpPublishSubject.create(); final NbpPublishSubject close = NbpPublishSubject.create(); - NbpTestSubscriber> ts = new NbpTestSubscriber>(); + NbpTestSubscriber> ts = new NbpTestSubscriber<>(); - source.window(open, new Function>() { - @Override - public NbpObservable apply(Integer t) { - return close; - } - }).unsafeSubscribe(ts); + source.window(open, t -> close).unsafeSubscribe(ts); open.onNext(1); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowWithTimeTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowWithTimeTest.java similarity index 68% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowWithTimeTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowWithTimeTest.java index 3be973df40..a5923b3479 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowWithTimeTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorWindowWithTimeTest.java @@ -42,8 +42,8 @@ public void before() { @Test public void testTimedAndCount() { - final List list = new ArrayList(); - final List> lists = new ArrayList>(); + final List list = new ArrayList<>(); + final List> lists = new ArrayList<>(); NbpObservable source = NbpObservable.create(new NbpOnSubscribe() { @Override @@ -76,8 +76,8 @@ public void accept(NbpSubscriber NbpObserver) { @Test public void testTimed() { - final List list = new ArrayList(); - final List> lists = new ArrayList>(); + final List list = new ArrayList<>(); + final List> lists = new ArrayList<>(); NbpObservable source = NbpObservable.create(new NbpOnSubscribe() { @Override @@ -105,7 +105,7 @@ public void accept(NbpSubscriber NbpObserver) { } private List list(String... args) { - List list = new ArrayList(); + List list = new ArrayList<>(); for (String arg : args) { list.add(arg); } @@ -113,54 +113,39 @@ private List list(String... args) { } private void push(final NbpSubscriber NbpObserver, final T value, int delay) { - innerScheduler.schedule(new Runnable() { - @Override - public void run() { - NbpObserver.onNext(value); - } - }, delay, TimeUnit.MILLISECONDS); + innerScheduler.schedule(() -> NbpObserver.onNext(value), delay, TimeUnit.MILLISECONDS); } private void complete(final NbpSubscriber NbpObserver, int delay) { - innerScheduler.schedule(new Runnable() { - @Override - public void run() { - NbpObserver.onComplete(); - } - }, delay, TimeUnit.MILLISECONDS); + innerScheduler.schedule(NbpObserver::onComplete, delay, TimeUnit.MILLISECONDS); } private Consumer> observeWindow(final List list, final List> lists) { - return new Consumer>() { + return stringObservable -> stringObservable.subscribe(new NbpObserver() { @Override - public void accept(NbpObservable stringObservable) { - stringObservable.subscribe(new NbpObserver() { - @Override - public void onComplete() { - lists.add(new ArrayList(list)); - list.clear(); - } - - @Override - public void onError(Throwable e) { - fail(e.getMessage()); - } - - @Override - public void onNext(T args) { - list.add(args); - } - }); + public void onComplete() { + lists.add(new ArrayList<>(list)); + list.clear(); } - }; + + @Override + public void onError(Throwable e) { + fail(e.getMessage()); + } + + @Override + public void onNext(T args) { + list.add(args); + } + }); } @Test public void testExactWindowSize() { NbpObservable> source = NbpObservable.range(1, 10) .window(1, TimeUnit.MINUTES, scheduler, 3); - final List list = new ArrayList(); - final List> lists = new ArrayList>(); + final List list = new ArrayList<>(); + final List> lists = new ArrayList<>(); source.subscribe(observeWindow(list, lists)); @@ -177,7 +162,7 @@ public void testExactWindowSize() { @Test public void testTakeFlatMapCompletes() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); final AtomicInteger wip = new AtomicInteger(); @@ -186,31 +171,10 @@ public void testTakeFlatMapCompletes() { NbpOperatorWindowWithSizeTest.hotStream() .window(300, TimeUnit.MILLISECONDS) .take(10) - .doOnComplete(new Runnable() { - @Override - public void run() { - System.out.println("Main done!"); - } - }) - .flatMap(new Function, NbpObservable>() { - @Override - public NbpObservable apply(NbpObservable w) { - return w.startWith(indicator) - .doOnComplete(new Runnable() { - @Override - public void run() { - System.out.println("inner done: " + wip.incrementAndGet()); - } - }) - ; - } - }) - .doOnNext(new Consumer() { - @Override - public void accept(Integer pv) { - System.out.println(pv); - } - }) + .doOnComplete(() -> System.out.println("Main done!")) + .flatMap(w -> w.startWith(indicator) + .doOnComplete(() -> System.out.println("inner done: " + wip.incrementAndGet()))) + .doOnNext(System.out::println) .subscribe(ts); ts.awaitTerminalEvent(5, TimeUnit.SECONDS); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorWithLatestFromTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorWithLatestFromTest.java similarity index 89% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorWithLatestFromTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorWithLatestFromTest.java index 9053e9d063..cd0ddae44e 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorWithLatestFromTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorWithLatestFromTest.java @@ -28,17 +28,9 @@ import io.reactivex.subscribers.nbp.NbpTestSubscriber; public class NbpOperatorWithLatestFromTest { - static final BiFunction COMBINER = new BiFunction() { - @Override - public Integer apply(Integer t1, Integer t2) { - return (t1 << 8) + t2; - } - }; - static final BiFunction COMBINER_ERROR = new BiFunction() { - @Override - public Integer apply(Integer t1, Integer t2) { - throw new TestException("Forced failure"); - } + static final BiFunction COMBINER = (t1, t2) -> (t1 << 8) + t2; + static final BiFunction COMBINER_ERROR = (t1, t2) -> { + throw new TestException("Forced failure"); }; @Test public void testSimple() { @@ -83,7 +75,7 @@ public void testEmptySource() { NbpObservable result = source.withLatestFrom(other, COMBINER); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); result.subscribe(ts); @@ -109,7 +101,7 @@ public void testEmptyOther() { NbpObservable result = source.withLatestFrom(other, COMBINER); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); result.subscribe(ts); @@ -136,7 +128,7 @@ public void testUnsubscription() { NbpObservable result = source.withLatestFrom(other, COMBINER); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); result.subscribe(ts); @@ -163,7 +155,7 @@ public void testSourceThrows() { NbpObservable result = source.withLatestFrom(other, COMBINER); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); result.subscribe(ts); @@ -190,7 +182,7 @@ public void testOtherThrows() { NbpObservable result = source.withLatestFrom(other, COMBINER); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); result.subscribe(ts); @@ -218,7 +210,7 @@ public void testFunctionThrows() { NbpObservable result = source.withLatestFrom(other, COMBINER_ERROR); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); result.subscribe(ts); @@ -244,7 +236,7 @@ public void testNoDownstreamUnsubscribe() { NbpObservable result = source.withLatestFrom(other, COMBINER); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); result.unsafeSubscribe(ts); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorZipCompletionTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorZipCompletionTest.java similarity index 94% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorZipCompletionTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorZipCompletionTest.java index 7e201c1512..cc3ac2df54 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorZipCompletionTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorZipCompletionTest.java @@ -40,12 +40,7 @@ public class NbpOperatorZipCompletionTest { @Before public void setUp() { - concat2Strings = new BiFunction() { - @Override - public String apply(String t1, String t2) { - return t1 + "-" + t2; - } - }; + concat2Strings = (t1, t2) -> t1 + "-" + t2; s1 = NbpPublishSubject.create(); s2 = NbpPublishSubject.create(); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorZipIterableTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorZipIterableTest.java similarity index 77% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorZipIterableTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorZipIterableTest.java index 7fef53ded1..f89e844b6d 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorZipIterableTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorZipIterableTest.java @@ -40,12 +40,7 @@ public class NbpOperatorZipIterableTest { @Before public void setUp() { - concat2Strings = new BiFunction() { - @Override - public String apply(String t1, String t2) { - return t1 + "-" + t2; - } - }; + concat2Strings = (t1, t2) -> t1 + "-" + t2; s1 = NbpPublishSubject.create(); s2 = NbpPublishSubject.create(); @@ -57,22 +52,8 @@ public String apply(String t1, String t2) { zipped.subscribe(NbpObserver); } - BiFunction zipr2 = new BiFunction() { - - @Override - public String apply(Object t1, Object t2) { - return "" + t1 + t2; - } - - }; - Function3 zipr3 = new Function3() { - - @Override - public String apply(Object t1, Object t2, Object t3) { - return "" + t1 + t2 + t3; - } - - }; + BiFunction zipr2 = (t1, t2) -> "" + t1 + t2; + Function3 zipr3 = (t1, t2, t3) -> "" + t1 + t2 + t3; @Test public void testZipIterableSameSize() { @@ -218,11 +199,8 @@ public void testZipIterableIteratorThrows() { NbpSubscriber o = TestHelper.mockNbpSubscriber(); InOrder io = inOrder(o); - Iterable r2 = new Iterable() { - @Override - public Iterator iterator() { - throw new TestException(); - } + Iterable r2 = () -> { + throw new TestException(); }; r1.zipWith(r2, zipr2).subscribe(o); @@ -245,33 +223,26 @@ public void testZipIterableHasNextThrows() { NbpSubscriber o = TestHelper.mockNbpSubscriber(); InOrder io = inOrder(o); - Iterable r2 = new Iterable() { + Iterable r2 = () -> new Iterator() { + int count; @Override - public Iterator iterator() { - return new Iterator() { - int count; - - @Override - public boolean hasNext() { - if (count == 0) { - return true; - } - throw new TestException(); - } - - @Override - public String next() { - count++; - return "1"; - } - - @Override - public void remove() { - throw new UnsupportedOperationException("Not supported yet."); - } - - }; + public boolean hasNext() { + if (count == 0) { + return true; + } + throw new TestException(); + } + + @Override + public String next() { + count++; + return "1"; + } + + @Override + public void remove() { + throw new UnsupportedOperationException("Not supported yet."); } }; @@ -295,27 +266,20 @@ public void testZipIterableNextThrows() { NbpSubscriber o = TestHelper.mockNbpSubscriber(); InOrder io = inOrder(o); - Iterable r2 = new Iterable() { + Iterable r2 = () -> new Iterator() { + @Override + public boolean hasNext() { + return true; + } + + @Override + public String next() { + throw new TestException(); + } @Override - public Iterator iterator() { - return new Iterator() { - @Override - public boolean hasNext() { - return true; - } - - @Override - public String next() { - throw new TestException(); - } - - @Override - public void remove() { - throw new UnsupportedOperationException("Not supported yet."); - } - - }; + public void remove() { + throw new UnsupportedOperationException("Not supported yet."); } }; @@ -331,12 +295,7 @@ public void remove() { } - Consumer printer = new Consumer() { - @Override - public void accept(String pv) { - System.out.println(pv); - } - }; + Consumer printer = pv -> System.out.println(pv); static final class SquareStr implements Function { final AtomicInteger counter = new AtomicInteger(); diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorZipTest.java b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorZipTest.java similarity index 98% rename from src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorZipTest.java rename to rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorZipTest.java index 60b755ea42..9ae36ab2e6 100644 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorZipTest.java +++ b/rxjava/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorZipTest.java @@ -350,7 +350,7 @@ public void testAggregatorUnsubscribe() { NbpPublishSubject r2 = NbpPublishSubject.create(); /* define a NbpSubscriber to receive aggregated events */ NbpSubscriber NbpObserver = TestHelper.mockNbpSubscriber(); - NbpTestSubscriber ts = new NbpTestSubscriber(NbpObserver); + NbpTestSubscriber ts = new NbpTestSubscriber<>(NbpObserver); NbpObservable.zip(r1, r2, zipr2).subscribe(ts); @@ -768,7 +768,7 @@ public String apply(Integer a, Integer b) { } }); - final ArrayList list = new ArrayList(); + final ArrayList list = new ArrayList<>(); os.subscribe(new Consumer() { @Override @@ -795,7 +795,7 @@ public String apply(Integer a, Integer b) { } }).take(5); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); os.subscribe(ts); ts.awaitTerminalEvent(); @@ -820,7 +820,7 @@ public String apply(Integer a, Integer b) { } }); - final ArrayList list = new ArrayList(); + final ArrayList list = new ArrayList<>(); os.subscribe(new NbpObserver() { @Override @@ -866,7 +866,7 @@ public String apply(Integer t1, String t2) { }); - final ArrayList list = new ArrayList(); + final ArrayList list = new ArrayList<>(); o.subscribe(new Consumer() { @Override @@ -915,7 +915,7 @@ public String apply(Try> t1, Try> t2) { }); - final ArrayList list = new ArrayList(); + final ArrayList list = new ArrayList<>(); o.subscribe(new Consumer() { @Override @@ -944,7 +944,7 @@ public String apply(Integer t1, String t2) { }); - final ArrayList list = new ArrayList(); + final ArrayList list = new ArrayList<>(); o.subscribe(new Consumer() { @Override @@ -971,7 +971,7 @@ public Object apply(final Object[] args) { } }); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); o.subscribe(ts); ts.awaitTerminalEvent(200, TimeUnit.MILLISECONDS); ts.assertNoValues(); @@ -1005,7 +1005,7 @@ public void testDownstreamBackpressureRequestsWithFiniteSyncObservables() { NbpObservable o1 = createInfiniteObservable(generatedA).take(Observable.bufferSize() * 2); NbpObservable o2 = createInfiniteObservable(generatedB).take(Observable.bufferSize() * 2); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpObservable.zip(o1, o2, new BiFunction() { @Override @@ -1120,7 +1120,7 @@ public Integer apply(Integer i1, Integer i2) { return i1 + i2; } }); - List expected = new ArrayList(); + List expected = new ArrayList<>(); for (int i = 0; i < 1026; i++) { expected.add(i * 3); } diff --git a/src/test/java/io/reactivex/internal/subscriptions/AsyncSubscriptionTest.java b/rxjava/src/test/java/io/reactivex/internal/subscriptions/AsyncSubscriptionTest.java similarity index 100% rename from src/test/java/io/reactivex/internal/subscriptions/AsyncSubscriptionTest.java rename to rxjava/src/test/java/io/reactivex/internal/subscriptions/AsyncSubscriptionTest.java diff --git a/src/test/java/io/reactivex/nbp/NbpCombineLatestTests.java b/rxjava/src/test/java/io/reactivex/nbp/NbpCombineLatestTests.java similarity index 67% rename from src/test/java/io/reactivex/nbp/NbpCombineLatestTests.java rename to rxjava/src/test/java/io/reactivex/nbp/NbpCombineLatestTests.java index 163140323e..9a27651784 100644 --- a/src/test/java/io/reactivex/nbp/NbpCombineLatestTests.java +++ b/rxjava/src/test/java/io/reactivex/nbp/NbpCombineLatestTests.java @@ -42,45 +42,20 @@ public void testCovarianceOfCombineLatest() { NbpObservable. combineLatest(horrors, ratings, combine); } - BiFunction combine = new BiFunction() { - @Override - public ExtendedResult apply(Media m, Rating r) { - return new ExtendedResult(); - } - }; + BiFunction combine = (m, r) -> new ExtendedResult(); - Consumer action = new Consumer() { - @Override - public void accept(Result t1) { - System.out.println("Result: " + t1); - } - }; + Consumer action = t1 -> System.out.println("Result: " + t1); - Consumer extendedAction = new Consumer() { - @Override - public void accept(ExtendedResult t1) { - System.out.println("Result: " + t1); - } - }; + Consumer extendedAction = t1 -> System.out.println("Result: " + t1); @Ignore @Test public void testNullEmitting() throws Exception { // FIXME this is no longer allowed - NbpObservable nullNbpObservable = NbpBehaviorSubject.createDefault((Boolean) null); + NbpObservable nullNbpObservable = NbpBehaviorSubject.createDefault(null); NbpObservable nonNullNbpObservable = NbpBehaviorSubject.createDefault(true); NbpObservable combined = - combineLatest(nullNbpObservable, nonNullNbpObservable, new BiFunction() { - @Override - public Boolean apply(Boolean bool1, Boolean bool2) { - return bool1 == null ? null : bool2; - } - }); - combined.subscribe(new Consumer() { - @Override - public void accept(Boolean aBoolean) { - Assert.assertNull(aBoolean); - } - }); + combineLatest(nullNbpObservable, nonNullNbpObservable, (bool1, bool2) -> bool1 == null ? null : bool2); + combined.subscribe(Assert::assertNull); } } \ No newline at end of file diff --git a/src/test/java/io/reactivex/nbp/NbpConcatTests.java b/rxjava/src/test/java/io/reactivex/nbp/NbpConcatTests.java similarity index 100% rename from src/test/java/io/reactivex/nbp/NbpConcatTests.java rename to rxjava/src/test/java/io/reactivex/nbp/NbpConcatTests.java diff --git a/rxjava/src/test/java/io/reactivex/nbp/NbpCovarianceTest.java b/rxjava/src/test/java/io/reactivex/nbp/NbpCovarianceTest.java new file mode 100644 index 0000000000..8faed962fa --- /dev/null +++ b/rxjava/src/test/java/io/reactivex/nbp/NbpCovarianceTest.java @@ -0,0 +1,179 @@ +/** + * Copyright 2016 Netflix, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.reactivex.nbp; + +import static org.junit.Assert.assertEquals; + +import java.util.*; + +import org.junit.Test; + +import io.reactivex.NbpObservable; +import io.reactivex.NbpObservable.NbpTransformer; +import io.reactivex.functions.*; +import io.reactivex.observables.nbp.NbpGroupedObservable; +import io.reactivex.subscribers.nbp.NbpTestSubscriber; + +/** + * Test super/extends of generics. + * + * See https://github.com/Netflix/RxJava/pull/331 + */ +public class NbpCovarianceTest { + + /** + * This won't compile if super/extends isn't done correctly on generics + */ + @Test + public void testCovarianceOfFrom() { + NbpObservable. just(new HorrorMovie()); + NbpObservable. fromIterable(new ArrayList()); + // NbpObservable.from(new Movie()); // may not compile + } + + @Test + public void testSortedList() { + Comparator SORT_FUNCTION = (t1, t2) -> 1; + + // this one would work without the covariance generics + NbpObservable o = NbpObservable.just(new Movie(), new TVSeason(), new Album()); + o.toSortedList(SORT_FUNCTION); + + // this one would NOT work without the covariance generics + NbpObservable o2 = NbpObservable.just(new Movie(), new ActionMovie(), new HorrorMovie()); + o2.toSortedList(SORT_FUNCTION); + } + + @Test + public void testGroupByCompose() { + NbpObservable movies = NbpObservable.just(new HorrorMovie(), new ActionMovie(), new Movie()); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); + movies + .groupBy(Object::getClass) + .doOnNext(g -> System.out.println(g.key())) + .flatMap(g -> g.doOnNext(System.out::println) + .compose(m -> m.concatWith(NbpObservable.just(new ActionMovie()))) + .map(Movie::toString)) + .subscribe(ts); + ts.assertTerminated(); + ts.assertNoErrors(); + //System.out.println(ts.getOnNextEvents()); + assertEquals(6, ts.valueCount()); + } + + @SuppressWarnings("unused") + @Test + public void testCovarianceOfCompose() { + NbpObservable movie = NbpObservable.just(new HorrorMovie()); + NbpObservable movie2 = movie.compose(t -> NbpObservable.just(new Movie())); + } + + @SuppressWarnings("unused") + @Test + public void testCovarianceOfCompose2() { + NbpObservable movie = NbpObservable.just(new HorrorMovie()); + NbpObservable movie2 = movie.compose(t -> NbpObservable.just(new HorrorMovie())); + } + + @SuppressWarnings("unused") + @Test + public void testCovarianceOfCompose3() { + NbpObservable movie = NbpObservable.just(new HorrorMovie()); + NbpObservable movie2 = movie.compose(t -> NbpObservable.just(new HorrorMovie()).map(v -> v) + ); + } + + @SuppressWarnings("unused") + @Test + public void testCovarianceOfCompose4() { + NbpObservable movie = NbpObservable.just(new HorrorMovie()); + NbpObservable movie2 = movie.compose(t1 -> t1.map(v -> v)); + } + + @Test + public void testComposeWithDeltaLogic() { + List list1 = Arrays.asList(new Movie(), new HorrorMovie(), new ActionMovie()); + List list2 = Arrays.asList(new ActionMovie(), new Movie(), new HorrorMovie(), new ActionMovie()); + NbpObservable> movies = NbpObservable.just(list1, list2); + movies.compose(deltaTransformer); + } + + static Function>, NbpObservable> calculateDelta = listOfLists -> { + if (listOfLists.size() == 1) { + return NbpObservable.fromIterable(listOfLists.get(0)); + } else { + // diff the two + List newList = listOfLists.get(1); + List oldList = new ArrayList<>(listOfLists.get(0)); + + Set delta = new LinkedHashSet<>(); + delta.addAll(newList); + // remove all that match in old + delta.removeAll(oldList); + + // filter oldList to those that aren't in the newList + oldList.removeAll(newList); + + // for all left in the oldList we'll create DROP events + for (@SuppressWarnings("unused") Movie old : oldList) { + delta.add(new Movie()); + } + + return NbpObservable.fromIterable(delta); + } + }; + + static NbpTransformer, Movie> deltaTransformer = movieList -> movieList + .startWith(new ArrayList()) + .buffer(2, 1) + .skip(1) + .flatMap(calculateDelta); + + /* + * Most tests are moved into their applicable classes such as [Operator]Tests.java + */ + + static class Media { + } + + static class Movie extends Media { + } + + static class HorrorMovie extends Movie { + } + + static class ActionMovie extends Movie { + } + + static class Album extends Media { + } + + static class TVSeason extends Media { + } + + static class Rating { + } + + static class CoolRating extends Rating { + } + + static class Result { + } + + static class ExtendedResult extends Result { + } +} diff --git a/src/test/java/io/reactivex/nbp/NbpErrorHandlingTests.java b/rxjava/src/test/java/io/reactivex/nbp/NbpErrorHandlingTests.java similarity index 98% rename from src/test/java/io/reactivex/nbp/NbpErrorHandlingTests.java rename to rxjava/src/test/java/io/reactivex/nbp/NbpErrorHandlingTests.java index 6a095691ec..83731b0dde 100644 --- a/src/test/java/io/reactivex/nbp/NbpErrorHandlingTests.java +++ b/rxjava/src/test/java/io/reactivex/nbp/NbpErrorHandlingTests.java @@ -33,7 +33,7 @@ public class NbpErrorHandlingTests { @Test public void testOnNextError() throws InterruptedException { final CountDownLatch latch = new CountDownLatch(1); - final AtomicReference caughtError = new AtomicReference(); + final AtomicReference caughtError = new AtomicReference<>(); NbpObservable o = NbpObservable.interval(50, TimeUnit.MILLISECONDS); NbpSubscriber observer = new NbpObserver() { @@ -69,7 +69,7 @@ public void onNext(Long args) { @Test public void testOnNextErrorAcrossThread() throws InterruptedException { final CountDownLatch latch = new CountDownLatch(1); - final AtomicReference caughtError = new AtomicReference(); + final AtomicReference caughtError = new AtomicReference<>(); NbpObservable o = NbpObservable.interval(50, TimeUnit.MILLISECONDS); NbpSubscriber observer = new NbpObserver() { diff --git a/src/test/java/io/reactivex/nbp/NbpEventStream.java b/rxjava/src/test/java/io/reactivex/nbp/NbpEventStream.java similarity index 81% rename from src/test/java/io/reactivex/nbp/NbpEventStream.java rename to rxjava/src/test/java/io/reactivex/nbp/NbpEventStream.java index 2515f35d33..e208b5c08d 100644 --- a/src/test/java/io/reactivex/nbp/NbpEventStream.java +++ b/rxjava/src/test/java/io/reactivex/nbp/NbpEventStream.java @@ -29,23 +29,20 @@ private NbpEventStream() { } public static NbpObservable getEventStream(final String type, final int numInstances) { - return NbpObservable.generate(new Consumer>() { - @Override - public void accept(NbpSubscriber s) { - s.onNext(randomEvent(type, numInstances)); - try { - // slow it down somewhat - Thread.sleep(50); - } catch (InterruptedException e) { - Thread.currentThread().interrupt(); - s.onError(e); - } + return NbpObservable.generate(s -> { + s.onNext(randomEvent(type, numInstances)); + try { + // slow it down somewhat + Thread.sleep(50); + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + s.onError(e); } }).subscribeOn(Schedulers.newThread()); } public static Event randomEvent(String type, int numInstances) { - Map values = new LinkedHashMap(); + Map values = new LinkedHashMap<>(); values.put("count200", randomIntFrom0to(4000)); values.put("count4xx", randomIntFrom0to(300)); values.put("count5xx", randomIntFrom0to(500)); diff --git a/src/test/java/io/reactivex/nbp/NbpGroupByTests.java b/rxjava/src/test/java/io/reactivex/nbp/NbpGroupByTests.java similarity index 53% rename from src/test/java/io/reactivex/nbp/NbpGroupByTests.java rename to rxjava/src/test/java/io/reactivex/nbp/NbpGroupByTests.java index 57fc9bc838..c182cf5709 100644 --- a/src/test/java/io/reactivex/nbp/NbpGroupByTests.java +++ b/rxjava/src/test/java/io/reactivex/nbp/NbpGroupByTests.java @@ -29,20 +29,12 @@ public void testTakeUnsubscribesOnGroupBy() { NbpEventStream.getEventStream("HTTP-ClusterB", 20) ) // group by type (2 clusters) - .groupBy(new Function() { - @Override - public String apply(Event event) { - return event.type; - } - }) + .groupBy(event -> event.type) .take(1) .toBlocking() - .forEach(new Consumer>() { - @Override - public void accept(NbpGroupedObservable v) { - System.out.println(v); - v.take(1).subscribe(); // FIXME groups need consumption to a certain degree to cancel upstream - } + .forEach((Consumer>) v -> { + System.out.println(v); + v.take(1).subscribe(); // FIXME groups need consumption to a certain degree to cancel upstream }); System.out.println("**** finished"); @@ -55,31 +47,11 @@ public void testTakeUnsubscribesOnFlatMapOfGroupBy() { NbpEventStream.getEventStream("HTTP-ClusterB", 20) ) // group by type (2 clusters) - .groupBy(new Function() { - @Override - public String apply(Event event) { - return event.type; - } - }) - .flatMap(new Function, NbpObservable>() { - @Override - public NbpObservable apply(NbpGroupedObservable g) { - return g.map(new Function() { - @Override - public Object apply(Event event) { - return event.instanceId + " - " + event.values.get("count200"); - } - }); - } - }) + .groupBy(event -> event.type) + .flatMap(g -> g.map(event -> event.instanceId + " - " + event.values.get("count200"))) .take(20) .toBlocking() - .forEach(new Consumer() { - @Override - public void accept(Object pv) { - System.out.println(pv); - } - }); + .forEach(System.out::println); System.out.println("**** finished"); } diff --git a/src/test/java/io/reactivex/nbp/NbpMergeTests.java b/rxjava/src/test/java/io/reactivex/nbp/NbpMergeTests.java similarity index 90% rename from src/test/java/io/reactivex/nbp/NbpMergeTests.java rename to rxjava/src/test/java/io/reactivex/nbp/NbpMergeTests.java index 2c01b3a7f6..7a8bfcb836 100644 --- a/src/test/java/io/reactivex/nbp/NbpMergeTests.java +++ b/rxjava/src/test/java/io/reactivex/nbp/NbpMergeTests.java @@ -75,15 +75,10 @@ public void testMergeCovariance3() { @Test public void testMergeCovariance4() { - NbpObservable o1 = NbpObservable.defer(new Supplier>() { - @Override - public NbpObservable get() { - return NbpObservable.just( - new HorrorMovie(), - new Movie() - ); - } - }); + NbpObservable o1 = NbpObservable.defer(() -> NbpObservable.just( + new HorrorMovie(), + new Movie() + )); NbpObservable o2 = NbpObservable.just(new Media(), new HorrorMovie()); diff --git a/src/test/java/io/reactivex/nbp/NbpObservableDoOnTest.java b/rxjava/src/test/java/io/reactivex/nbp/NbpObservableDoOnTest.java similarity index 67% rename from src/test/java/io/reactivex/nbp/NbpObservableDoOnTest.java rename to rxjava/src/test/java/io/reactivex/nbp/NbpObservableDoOnTest.java index 02a5c9bf56..528be04e78 100644 --- a/src/test/java/io/reactivex/nbp/NbpObservableDoOnTest.java +++ b/rxjava/src/test/java/io/reactivex/nbp/NbpObservableDoOnTest.java @@ -26,13 +26,8 @@ public class NbpObservableDoOnTest { @Test public void testDoOnEach() { - final AtomicReference r = new AtomicReference(); - String output = NbpObservable.just("one").doOnNext(new Consumer() { - @Override - public void accept(String v) { - r.set(v); - } - }).toBlocking().single(); + final AtomicReference r = new AtomicReference<>(); + String output = NbpObservable.just("one").doOnNext(r::set).toBlocking().single(); assertEquals("one", output); assertEquals("one", r.get()); @@ -40,16 +35,11 @@ public void accept(String v) { @Test public void testDoOnError() { - final AtomicReference r = new AtomicReference(); + final AtomicReference r = new AtomicReference<>(); Throwable t = null; try { NbpObservable. error(new RuntimeException("an error")) - .doOnError(new Consumer() { - @Override - public void accept(Throwable v) { - r.set(v); - } - }).toBlocking().single(); + .doOnError(r::set).toBlocking().single(); fail("expected exception, not a return value"); } catch (Throwable e) { t = e; @@ -62,12 +52,7 @@ public void accept(Throwable v) { @Test public void testDoOnCompleted() { final AtomicBoolean r = new AtomicBoolean(); - String output = NbpObservable.just("one").doOnComplete(new Runnable() { - @Override - public void run() { - r.set(true); - } - }).toBlocking().single(); + String output = NbpObservable.just("one").doOnComplete(() -> r.set(true)).toBlocking().single(); assertEquals("one", output); assertTrue(r.get()); diff --git a/src/test/java/io/reactivex/nbp/NbpObservableTest.java b/rxjava/src/test/java/io/reactivex/nbp/NbpObservableTest.java similarity index 76% rename from src/test/java/io/reactivex/nbp/NbpObservableTest.java rename to rxjava/src/test/java/io/reactivex/nbp/NbpObservableTest.java index 626440961e..fd7caa59ff 100644 --- a/src/test/java/io/reactivex/nbp/NbpObservableTest.java +++ b/rxjava/src/test/java/io/reactivex/nbp/NbpObservableTest.java @@ -23,12 +23,7 @@ public class NbpObservableTest { @Test public void testFlatMap() { - List list = NbpObservable.range(1, 5).flatMap(new Function>() { - @Override - public NbpObservable apply(Integer v) { - return NbpObservable.range(v, 2); - } - }).getList(); + List list = NbpObservable.range(1, 5).flatMap(v -> NbpObservable.range(v, 2)).getList(); Assert.assertEquals(Arrays.asList(1, 2, 2, 3, 3, 4, 4, 5, 5, 6), list); } diff --git a/src/test/java/io/reactivex/nbp/NbpObservableTests.java b/rxjava/src/test/java/io/reactivex/nbp/NbpObservableTests.java similarity index 76% rename from src/test/java/io/reactivex/nbp/NbpObservableTests.java rename to rxjava/src/test/java/io/reactivex/nbp/NbpObservableTests.java index 87889e9a02..7087ea002f 100644 --- a/src/test/java/io/reactivex/nbp/NbpObservableTests.java +++ b/rxjava/src/test/java/io/reactivex/nbp/NbpObservableTests.java @@ -38,12 +38,7 @@ public class NbpObservableTests { NbpSubscriber w; - private static final Predicate IS_EVEN = new Predicate() { - @Override - public boolean test(Integer v) { - return v % 2 == 0; - } - }; + private static final Predicate IS_EVEN = v -> v % 2 == 0; @Before public void before() { @@ -60,7 +55,7 @@ public void fromArray() { @Test public void fromIterable() { - ArrayList items = new ArrayList(); + ArrayList items = new ArrayList<>(); items.add("one"); items.add("two"); items.add("three"); @@ -129,11 +124,8 @@ public void testCountZeroItems() { @Test public void testCountError() { - NbpObservable o = NbpObservable.error(new Supplier() { - @Override - public Throwable get() { - return new RuntimeException(); - } + NbpObservable o = NbpObservable.error(() -> { + return new RuntimeException(); }); o.count().subscribe(w); @@ -200,13 +192,7 @@ public void testFirstWithPredicateOfNoneMatchingThePredicate() { @Test public void testReduce() { NbpObservable o = NbpObservable.just(1, 2, 3, 4); - o.reduce(new BiFunction() { - @Override - public Integer apply(Integer t1, Integer t2) { - return t1 + t2; - } - }) - .subscribe(w); + o.reduce((t1, t2) -> t1 + t2).subscribe(w); // we should be called only once verify(w, times(1)).onNext(anyInt()); verify(w).onNext(10); @@ -218,17 +204,9 @@ public Integer apply(Integer t1, Integer t2) { @Test(expected = NoSuchElementException.class) public void testReduceWithEmptyNbpObservable() { NbpObservable o = NbpObservable.range(1, 0); - o.reduce(new BiFunction() { - @Override - public Integer apply(Integer t1, Integer t2) { - return t1 + t2; - } - }) - .toBlocking().forEach(new Consumer() { - @Override - public void accept(Integer t1) { - // do nothing ... we expect an exception instead - } + o.reduce((t1, t2) -> t1 + t2) + .toBlocking().forEach((Consumer) t1 -> { + // do nothing ... we expect an exception instead }); fail("Expected an exception to be thrown"); @@ -242,13 +220,7 @@ public void accept(Integer t1) { @Test public void testReduceWithEmptyNbpObservableAndSeed() { NbpObservable o = NbpObservable.range(1, 0); - int value = o.reduce(1, new BiFunction() { - @Override - public Integer apply(Integer t1, Integer t2) { - return t1 + t2; - } - }) - .toBlocking().last(); + int value = o.reduce(1, (t1, t2) -> t1 + t2).toBlocking().last(); assertEquals(1, value); } @@ -256,12 +228,7 @@ public Integer apply(Integer t1, Integer t2) { @Test public void testReduceWithInitialValue() { NbpObservable o = NbpObservable.just(1, 2, 3, 4); - o.reduce(50, new BiFunction() { - @Override - public Integer apply(Integer t1, Integer t2) { - return t1 + t2; - } - }) + o.reduce(50, (t1, t2) -> t1 + t2) .subscribe(w); // we should be called only once verify(w, times(1)).onNext(anyInt()); @@ -274,10 +241,7 @@ public void testOnSubscribeFails() { NbpSubscriber observer = TestHelper.mockNbpSubscriber(); final RuntimeException re = new RuntimeException("bad impl"); - NbpObservable o = NbpObservable.create(new NbpOnSubscribe() { - @Override - public void accept(NbpSubscriber s) { throw re; } - }); + NbpObservable o = NbpObservable.create(s -> { throw re; }); o.subscribe(observer); verify(observer, times(0)).onNext(anyString()); @@ -311,7 +275,7 @@ public void testMaterializeDematerializeChaining() { public void testCustomNbpObservableWithErrorInObserverAsynchronous() throws InterruptedException { final CountDownLatch latch = new CountDownLatch(1); final AtomicInteger count = new AtomicInteger(); - final AtomicReference error = new AtomicReference(); + final AtomicReference error = new AtomicReference<>(); // FIXME custom built??? NbpObservable.just("1", "2", "three", "4") @@ -359,7 +323,7 @@ public void onNext(String v) { @Test public void testCustomNbpObservableWithErrorInObserverSynchronous() { final AtomicInteger count = new AtomicInteger(); - final AtomicReference error = new AtomicReference(); + final AtomicReference error = new AtomicReference<>(); // FIXME custom built??? NbpObservable.just("1", "2", "three", "4") @@ -402,14 +366,9 @@ public void onNext(String v) { @Test public void testCustomNbpObservableWithErrorInNbpObservableSynchronous() { final AtomicInteger count = new AtomicInteger(); - final AtomicReference error = new AtomicReference(); + final AtomicReference error = new AtomicReference<>(); // FIXME custom built??? - NbpObservable.just("1", "2").concatWith(NbpObservable.error(new Supplier() { - @Override - public Throwable get() { - return new NumberFormatException(); - } - })) + NbpObservable.just("1", "2").concatWith(NbpObservable.error(NumberFormatException::new)) .subscribe(new NbpObserver() { @Override @@ -441,30 +400,21 @@ public void onNext(String v) { @Test public void testPublishLast() throws InterruptedException { final AtomicInteger count = new AtomicInteger(); - NbpConnectableObservable connectable = NbpObservable.create(new NbpOnSubscribe() { - @Override - public void accept(final NbpSubscriber observer) { - observer.onSubscribe(EmptyDisposable.INSTANCE); - count.incrementAndGet(); - new Thread(new Runnable() { - @Override - public void run() { - observer.onNext("first"); - observer.onNext("last"); - observer.onComplete(); - } - }).start(); - } + NbpConnectableObservable connectable = NbpObservable.create(observer -> { + observer.onSubscribe(EmptyDisposable.INSTANCE); + count.incrementAndGet(); + new Thread(() -> { + observer.onNext("first"); + observer.onNext("last"); + observer.onComplete(); + }).start(); }).takeLast(1).publish(); // subscribe once final CountDownLatch latch = new CountDownLatch(1); - connectable.subscribe(new Consumer() { - @Override - public void accept(String value) { - assertEquals("last", value); - latch.countDown(); - } + connectable.subscribe(value -> { + assertEquals("last", value); + latch.countDown(); }); // subscribe twice @@ -479,20 +429,13 @@ public void accept(String value) { @Test public void testReplay() throws InterruptedException { final AtomicInteger counter = new AtomicInteger(); - NbpConnectableObservable o = NbpObservable.create(new NbpOnSubscribe() { - @Override - public void accept(final NbpSubscriber observer) { - observer.onSubscribe(EmptyDisposable.INSTANCE); - new Thread(new Runnable() { - - @Override - public void run() { - counter.incrementAndGet(); - observer.onNext("one"); - observer.onComplete(); - } - }).start(); - } + NbpConnectableObservable o = NbpObservable.create(observer -> { + observer.onSubscribe(EmptyDisposable.INSTANCE); + new Thread(() -> { + counter.incrementAndGet(); + observer.onNext("one"); + observer.onComplete(); + }).start(); }).replay(); // we connect immediately and it will emit the value @@ -503,21 +446,15 @@ public void run() { final CountDownLatch latch = new CountDownLatch(2); // subscribe once - o.subscribe(new Consumer() { - @Override - public void accept(String v) { - assertEquals("one", v); - latch.countDown(); - } + o.subscribe(v -> { + assertEquals("one", v); + latch.countDown(); }); // subscribe again - o.subscribe(new Consumer() { - @Override - public void accept(String v) { - assertEquals("one", v); - latch.countDown(); - } + o.subscribe(v -> { + assertEquals("one", v); + latch.countDown(); }); if (!latch.await(1000, TimeUnit.MILLISECONDS)) { @@ -532,40 +469,28 @@ public void accept(String v) { @Test public void testCache() throws InterruptedException { final AtomicInteger counter = new AtomicInteger(); - NbpObservable o = NbpObservable.create(new NbpOnSubscribe() { - @Override - public void accept(final NbpSubscriber observer) { - observer.onSubscribe(EmptyDisposable.INSTANCE); - new Thread(new Runnable() { - @Override - public void run() { - counter.incrementAndGet(); - observer.onNext("one"); - observer.onComplete(); - } - }).start(); - } + NbpObservable o = NbpObservable.create(observer -> { + observer.onSubscribe(EmptyDisposable.INSTANCE); + new Thread(() -> { + counter.incrementAndGet(); + observer.onNext("one"); + observer.onComplete(); + }).start(); }).cache(); // we then expect the following 2 subscriptions to get that same value final CountDownLatch latch = new CountDownLatch(2); // subscribe once - o.subscribe(new Consumer() { - @Override - public void accept(String v) { - assertEquals("one", v); - latch.countDown(); - } + o.subscribe(v -> { + assertEquals("one", v); + latch.countDown(); }); // subscribe again - o.subscribe(new Consumer() { - @Override - public void accept(String v) { - assertEquals("one", v); - latch.countDown(); - } + o.subscribe(v -> { + assertEquals("one", v); + latch.countDown(); }); if (!latch.await(1000, TimeUnit.MILLISECONDS)) { @@ -577,40 +502,28 @@ public void accept(String v) { @Test public void testCacheWithCapacity() throws InterruptedException { final AtomicInteger counter = new AtomicInteger(); - NbpObservable o = NbpObservable.create(new NbpOnSubscribe() { - @Override - public void accept(final NbpSubscriber observer) { - observer.onSubscribe(EmptyDisposable.INSTANCE); - new Thread(new Runnable() { - @Override - public void run() { - counter.incrementAndGet(); - observer.onNext("one"); - observer.onComplete(); - } - }).start(); - } + NbpObservable o = NbpObservable.create(observer -> { + observer.onSubscribe(EmptyDisposable.INSTANCE); + new Thread(() -> { + counter.incrementAndGet(); + observer.onNext("one"); + observer.onComplete(); + }).start(); }).cache(1); // we then expect the following 2 subscriptions to get that same value final CountDownLatch latch = new CountDownLatch(2); // subscribe once - o.subscribe(new Consumer() { - @Override - public void accept(String v) { - assertEquals("one", v); - latch.countDown(); - } + o.subscribe(v -> { + assertEquals("one", v); + latch.countDown(); }); // subscribe again - o.subscribe(new Consumer() { - @Override - public void accept(String v) { - assertEquals("one", v); - latch.countDown(); - } + o.subscribe(v -> { + assertEquals("one", v); + latch.countDown(); }); if (!latch.await(1000, TimeUnit.MILLISECONDS)) { @@ -655,24 +568,16 @@ public void testErrorThrownWithoutErrorHandlerSynchronous() { @Ignore("Subscribers can't throw") public void testErrorThrownWithoutErrorHandlerAsynchronous() throws InterruptedException { final CountDownLatch latch = new CountDownLatch(1); - final AtomicReference exception = new AtomicReference(); - NbpObservable.create(new NbpOnSubscribe() { - @Override - public void accept(final NbpSubscriber observer) { - new Thread(new Runnable() { - @Override - public void run() { - try { - observer.onError(new Error("failure")); - } catch (Throwable e) { - // without an onError handler it has to just throw on whatever thread invokes it - exception.set(e); - } - latch.countDown(); - } - }).start(); - } - }).subscribe(); + final AtomicReference exception = new AtomicReference<>(); + NbpObservable.create(observer -> new Thread(() -> { + try { + observer.onError(new Error("failure")); + } catch (Throwable e) { + // without an onError handler it has to just throw on whatever thread invokes it + exception.set(e); + } + latch.countDown(); + }).start()).subscribe(); // wait for exception latch.await(3000, TimeUnit.MILLISECONDS); assertNotNull(exception.get()); @@ -682,7 +587,7 @@ public void run() { @Test public void testTakeWithErrorInObserver() { final AtomicInteger count = new AtomicInteger(); - final AtomicReference error = new AtomicReference(); + final AtomicReference error = new AtomicReference<>(); NbpObservable.just("1", "2", "three", "4").take(3) .safeSubscribe(new NbpObserver() { @@ -733,9 +638,9 @@ public void testOfType() { @Test public void testOfTypeWithPolymorphism() { - ArrayList l1 = new ArrayList(); + ArrayList l1 = new ArrayList<>(); l1.add(1); - LinkedList l2 = new LinkedList(); + LinkedList l2 = new LinkedList<>(); l2.add(2); @SuppressWarnings("rawtypes") @@ -888,17 +793,7 @@ public void testRangeWithScheduler() { @Test public void testCollectToList() { NbpObservable> o = NbpObservable.just(1, 2, 3) - .collect(new Supplier>() { - @Override - public List get() { - return new ArrayList(); - } - }, new BiConsumer, Integer>() { - @Override - public void accept(List list, Integer v) { - list.add(v); - } - }); + .collect(ArrayList::new, List::add); List list = o.toBlocking().last(); @@ -918,42 +813,34 @@ public void accept(List list, Integer v) { @Test public void testCollectToString() { - String value = NbpObservable.just(1, 2, 3).collect(new Supplier() { - @Override - public StringBuilder get() { - return new StringBuilder(); - } - }, - new BiConsumer() { - @Override - public void accept(StringBuilder sb, Integer v) { + String value = NbpObservable.just(1, 2, 3).collect(StringBuilder::new, + (sb, v) -> { if (sb.length() > 0) { sb.append("-"); } sb.append(v); - } - }).toBlocking().last().toString(); + }).toBlocking().last().toString(); assertEquals("1-2-3", value); } @Test public void testMergeWith() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpObservable.just(1).mergeWith(NbpObservable.just(2)).subscribe(ts); ts.assertValues(1, 2); } @Test public void testConcatWith() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpObservable.just(1).concatWith(NbpObservable.just(2)).subscribe(ts); ts.assertValues(1, 2); } @Test public void testAmbWith() { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpObservable.just(1).ambWith(NbpObservable.just(2)).subscribe(ts); ts.assertValue(1); } @@ -976,19 +863,9 @@ public void testTakeWhileToList() { for (int i = 0;i < expectedCount; i++) { NbpObservable .just(Boolean.TRUE, Boolean.FALSE) - .takeWhile(new Predicate() { - @Override - public boolean test(Boolean v) { - return v; - } - }) + .takeWhile(v -> v) .toList() - .doOnNext(new Consumer>() { - @Override - public void accept(List booleans) { - count.incrementAndGet(); - } - }) + .doOnNext(booleans -> count.incrementAndGet()) .subscribe(); } assertEquals(expectedCount, count.get()); @@ -996,18 +873,8 @@ public void accept(List booleans) { @Test public void testCompose() { - NbpTestSubscriber ts = new NbpTestSubscriber(); - NbpObservable.just(1, 2, 3).compose(new Function, NbpObservable>() { - @Override - public NbpObservable apply(NbpObservable t1) { - return t1.map(new Function() { - @Override - public String apply(Integer v) { - return String.valueOf(v); - } - }); - } - }) + NbpTestSubscriber ts = new NbpTestSubscriber<>(); + NbpObservable.just(1, 2, 3).compose(t1 -> t1.map(v -> String.valueOf(v))) .subscribe(ts); ts.assertTerminated(); ts.assertNoErrors(); @@ -1075,17 +942,14 @@ public void testForEachWithNull() { @Test public void testExtend() { - final NbpTestSubscriber subscriber = new NbpTestSubscriber(); + final NbpTestSubscriber subscriber = new NbpTestSubscriber<>(); final Object value = new Object(); - NbpObservable.just(value).to(new Function, Object>() { - @Override - public Object apply(NbpObservable onSubscribe) { - onSubscribe.subscribe(subscriber); - subscriber.assertNoErrors(); - subscriber.assertComplete(); - subscriber.assertValue(value); - return subscriber.values().get(0); - } - }); + NbpObservable.just(value).to(onSubscribe -> { + onSubscribe.subscribe(subscriber); + subscriber.assertNoErrors(); + subscriber.assertComplete(); + subscriber.assertValue(value); + return subscriber.values().get(0); + }); } } \ No newline at end of file diff --git a/src/test/java/io/reactivex/nbp/NbpObservableWindowTests.java b/rxjava/src/test/java/io/reactivex/nbp/NbpObservableWindowTests.java similarity index 68% rename from src/test/java/io/reactivex/nbp/NbpObservableWindowTests.java rename to rxjava/src/test/java/io/reactivex/nbp/NbpObservableWindowTests.java index cc6f09e9ba..d99c6d40d5 100644 --- a/src/test/java/io/reactivex/nbp/NbpObservableWindowTests.java +++ b/rxjava/src/test/java/io/reactivex/nbp/NbpObservableWindowTests.java @@ -26,24 +26,14 @@ public class NbpObservableWindowTests { @Test public void testWindow() { - final ArrayList> lists = new ArrayList>(); + final ArrayList> lists = new ArrayList<>(); NbpObservable.concat( NbpObservable.just(1, 2, 3, 4, 5, 6) .window(3) - .map(new Function, NbpObservable>>() { - @Override - public NbpObservable> apply(NbpObservable xs) { - return xs.toList(); - } - }) + .map(NbpObservable::toList) ) - .toBlocking().forEach(new Consumer>() { - @Override - public void accept(List xs) { - lists.add(xs); - } - }); + .toBlocking().forEach(lists::add); assertArrayEquals(lists.get(0).toArray(new Integer[3]), new Integer[] { 1, 2, 3 }); assertArrayEquals(lists.get(1).toArray(new Integer[3]), new Integer[] { 4, 5, 6 }); diff --git a/src/test/java/io/reactivex/nbp/NbpReduceTests.java b/rxjava/src/test/java/io/reactivex/nbp/NbpReduceTests.java similarity index 69% rename from src/test/java/io/reactivex/nbp/NbpReduceTests.java rename to rxjava/src/test/java/io/reactivex/nbp/NbpReduceTests.java index b467e4e635..5606d36409 100644 --- a/src/test/java/io/reactivex/nbp/NbpReduceTests.java +++ b/rxjava/src/test/java/io/reactivex/nbp/NbpReduceTests.java @@ -26,12 +26,7 @@ public class NbpReduceTests { @Test public void reduceInts() { NbpObservable o = NbpObservable.just(1, 2, 3); - int value = o.reduce(new BiFunction() { - @Override - public Integer apply(Integer t1, Integer t2) { - return t1 + t2; - } - }).toBlocking().single(); + int value = o.reduce((t1, t2) -> t1 + t2).toBlocking().single(); assertEquals(6, value); } @@ -41,19 +36,9 @@ public Integer apply(Integer t1, Integer t2) { public void reduceWithObjects() { NbpObservable horrorMovies = NbpObservable. just(new HorrorMovie()); - NbpObservable reduceResult = horrorMovies.scan(new BiFunction() { - @Override - public Movie apply(Movie t1, Movie t2) { - return t2; - } - }).takeLast(1); - - NbpObservable reduceResult2 = horrorMovies.reduce(new BiFunction() { - @Override - public Movie apply(Movie t1, Movie t2) { - return t2; - } - }); + NbpObservable reduceResult = horrorMovies.scan((t1, t2) -> t2).takeLast(1); + + NbpObservable reduceResult2 = horrorMovies.reduce((t1, t2) -> t2); } /** @@ -66,12 +51,7 @@ public Movie apply(Movie t1, Movie t2) { public void reduceWithCovariantObjects() { NbpObservable horrorMovies = NbpObservable. just(new HorrorMovie()); - NbpObservable reduceResult2 = horrorMovies.reduce(new BiFunction() { - @Override - public Movie apply(Movie t1, Movie t2) { - return t2; - } - }); + NbpObservable reduceResult2 = horrorMovies.reduce((t1, t2) -> t2); } /** @@ -91,12 +71,7 @@ public void reduceCovariance() { */ public void libraryFunctionActingOnMovieNbpObservables(NbpObservable obs) { - obs.reduce(new BiFunction() { - @Override - public Movie apply(Movie t1, Movie t2) { - return t2; - } - }); + obs.reduce((t1, t2) -> t2); } } \ No newline at end of file diff --git a/src/test/java/io/reactivex/nbp/NbpScanTests.java b/rxjava/src/test/java/io/reactivex/nbp/NbpScanTests.java similarity index 78% rename from src/test/java/io/reactivex/nbp/NbpScanTests.java rename to rxjava/src/test/java/io/reactivex/nbp/NbpScanTests.java index 5192061b28..74e18f4b8e 100644 --- a/src/test/java/io/reactivex/nbp/NbpScanTests.java +++ b/rxjava/src/test/java/io/reactivex/nbp/NbpScanTests.java @@ -26,7 +26,7 @@ public class NbpScanTests { public void testUnsubscribeScan() { NbpEventStream.getEventStream("HTTP-ClusterB", 20) - .scan(new HashMap(), new BiFunction, Event, HashMap>() { + .scan(new HashMap<>(), new BiFunction, Event, HashMap>() { @Override public HashMap apply(HashMap accum, Event perInstanceEvent) { accum.put("instance", perInstanceEvent.instanceId); @@ -35,11 +35,6 @@ public HashMap apply(HashMap accum, Event perIns }) .take(10) .toBlocking() - .forEach(new Consumer>() { - @Override - public void accept(HashMap pv) { - System.out.println(pv); - } - }); + .forEach(System.out::println); } } \ No newline at end of file diff --git a/src/test/java/io/reactivex/nbp/NbpStartWithTests.java b/rxjava/src/test/java/io/reactivex/nbp/NbpStartWithTests.java similarity index 94% rename from src/test/java/io/reactivex/nbp/NbpStartWithTests.java rename to rxjava/src/test/java/io/reactivex/nbp/NbpStartWithTests.java index 8bdd2e3a1a..6becd7676c 100644 --- a/src/test/java/io/reactivex/nbp/NbpStartWithTests.java +++ b/rxjava/src/test/java/io/reactivex/nbp/NbpStartWithTests.java @@ -34,7 +34,7 @@ public void startWith1() { @Test public void startWithIterable() { - List li = new ArrayList(); + List li = new ArrayList<>(); li.add("alpha"); li.add("beta"); List values = NbpObservable.just("one", "two").startWith(li).toList().toBlocking().single(); @@ -47,7 +47,7 @@ public void startWithIterable() { @Test public void startWithObservable() { - List li = new ArrayList(); + List li = new ArrayList<>(); li.add("alpha"); li.add("beta"); List values = NbpObservable.just("one", "two") diff --git a/src/test/java/io/reactivex/nbp/NbpSubscriberTest.java b/rxjava/src/test/java/io/reactivex/nbp/NbpSubscriberTest.java similarity index 100% rename from src/test/java/io/reactivex/nbp/NbpSubscriberTest.java rename to rxjava/src/test/java/io/reactivex/nbp/NbpSubscriberTest.java diff --git a/src/test/java/io/reactivex/nbp/NbpThrottleLastTests.java b/rxjava/src/test/java/io/reactivex/nbp/NbpThrottleLastTests.java similarity index 100% rename from src/test/java/io/reactivex/nbp/NbpThrottleLastTests.java rename to rxjava/src/test/java/io/reactivex/nbp/NbpThrottleLastTests.java diff --git a/src/test/java/io/reactivex/nbp/NbpThrottleWithTimeoutTests.java b/rxjava/src/test/java/io/reactivex/nbp/NbpThrottleWithTimeoutTests.java similarity index 100% rename from src/test/java/io/reactivex/nbp/NbpThrottleWithTimeoutTests.java rename to rxjava/src/test/java/io/reactivex/nbp/NbpThrottleWithTimeoutTests.java diff --git a/src/test/java/io/reactivex/nbp/NbpZipTests.java b/rxjava/src/test/java/io/reactivex/nbp/NbpZipTests.java similarity index 55% rename from src/test/java/io/reactivex/nbp/NbpZipTests.java rename to rxjava/src/test/java/io/reactivex/nbp/NbpZipTests.java index cd63343db1..db0f68bd48 100644 --- a/src/test/java/io/reactivex/nbp/NbpZipTests.java +++ b/rxjava/src/test/java/io/reactivex/nbp/NbpZipTests.java @@ -30,33 +30,14 @@ public class NbpZipTests { @Test public void testZipNbpObservableOfNbpObservables() { NbpEventStream.getEventStream("HTTP-ClusterB", 20) - .groupBy(new Function() { - @Override - public String apply(Event e) { - return e.instanceId; - } - }) + .groupBy(e -> e.instanceId) // now we have streams of cluster+instanceId - .flatMap(new Function, NbpObservable>>() { - @Override - public NbpObservable> apply(final NbpGroupedObservable ge) { - return ge.scan(new HashMap(), new BiFunction, Event, HashMap>() { - @Override - public HashMap apply(HashMap accum, - Event perInstanceEvent) { - accum.put("instance", ge.key()); - return accum; - } - }); - } - }) + .flatMap(ge -> ge.scan(new HashMap<>(), (accum, perInstanceEvent) -> { + accum.put("instance", ge.key()); + return accum; + })) .take(10) - .toBlocking().forEach(new Consumer() { - @Override - public void accept(Object pv) { - System.out.println(pv); - } - }); + .toBlocking().forEach(System.out::println); System.out.println("**** finished"); } @@ -91,36 +72,18 @@ public void nonBlockingNbpObservable() { Collection> NbpObservables = Collections.emptyList(); - NbpObservable result = NbpObservable.zip(NbpObservables, new Function() { - @Override - public Object apply(Object[] args) { - System.out.println("received: " + args); - Assert.assertEquals("No argument should have been passed", 0, args.length); - return invoked; - } + NbpObservable result = NbpObservable.zip(NbpObservables, args -> { + System.out.println("received: " + args); + Assert.assertEquals("No argument should have been passed", 0, args.length); + return invoked; }); assertSame(invoked, result.toBlocking().last()); } - BiFunction combine = new BiFunction() { - @Override - public ExtendedResult apply(Media m, Rating r) { - return new ExtendedResult(); - } - }; - - Consumer action = new Consumer() { - @Override - public void accept(Result t1) { - System.out.println("Result: " + t1); - } - }; - - Consumer extendedAction = new Consumer() { - @Override - public void accept(ExtendedResult t1) { - System.out.println("Result: " + t1); - } - }; + BiFunction combine = (m, r) -> new ExtendedResult(); + + Consumer action = t1 -> System.out.println("Result: " + t1); + + Consumer extendedAction = t1 -> System.out.println("Result: " + t1); } \ No newline at end of file diff --git a/src/test/java/io/reactivex/schedulers/AbstractSchedulerConcurrencyTests.java b/rxjava/src/test/java/io/reactivex/schedulers/AbstractSchedulerConcurrencyTests.java similarity index 90% rename from src/test/java/io/reactivex/schedulers/AbstractSchedulerConcurrencyTests.java rename to rxjava/src/test/java/io/reactivex/schedulers/AbstractSchedulerConcurrencyTests.java index 3b96eb32dc..6ec986afb8 100644 --- a/src/test/java/io/reactivex/schedulers/AbstractSchedulerConcurrencyTests.java +++ b/rxjava/src/test/java/io/reactivex/schedulers/AbstractSchedulerConcurrencyTests.java @@ -46,12 +46,9 @@ public final void testUnSubscribeForScheduler() throws InterruptedException { final CountDownLatch latch = new CountDownLatch(1); Observable.interval(50, TimeUnit.MILLISECONDS) - .map(new Function() { - @Override - public Long apply(Long aLong) { - countGenerated.incrementAndGet(); - return aLong; - } + .map(aLong -> { + countGenerated.incrementAndGet(); + return aLong; }) .subscribeOn(getScheduler()) .observeOn(getScheduler()) @@ -363,16 +360,12 @@ public final void testSubscribeWithScheduler() throws InterruptedException { final AtomicInteger count = new AtomicInteger(); - Observable o1 = Observable. just(1, 2, 3, 4, 5); + Observable o1 = Observable.just(1, 2, 3, 4, 5); - o1.subscribe(new Consumer() { - - @Override - public void accept(Integer t) { - System.out.println("Thread: " + Thread.currentThread().getName()); - System.out.println("t: " + t); - count.incrementAndGet(); - } + o1.subscribe(t -> { + System.out.println("Thread: " + Thread.currentThread().getName()); + System.out.println("t: " + t); + count.incrementAndGet(); }); // the above should be blocking so we should see a count of 5 @@ -388,23 +381,19 @@ public void accept(Integer t) { final CountDownLatch latch = new CountDownLatch(5); final CountDownLatch first = new CountDownLatch(1); - o1.subscribeOn(scheduler).subscribe(new Consumer() { - - @Override - public void accept(Integer t) { - try { - // we block the first one so we can assert this executes asynchronously with a count - first.await(1000, TimeUnit.SECONDS); - } catch (InterruptedException e) { - throw new RuntimeException("The latch should have released if we are async.", e); - } - - assertFalse(Thread.currentThread().getName().equals(currentThreadName)); - System.out.println("Thread: " + Thread.currentThread().getName()); - System.out.println("t: " + t); - count.incrementAndGet(); - latch.countDown(); + o1.subscribeOn(scheduler).subscribe(t -> { + try { + // we block the first one so we can assert this executes asynchronously with a count + first.await(1000, TimeUnit.SECONDS); + } catch (InterruptedException e) { + throw new RuntimeException("The latch should have released if we are async.", e); } + + assertFalse(Thread.currentThread().getName().equals(currentThreadName)); + System.out.println("Thread: " + Thread.currentThread().getName()); + System.out.println("t: " + t); + count.incrementAndGet(); + latch.countDown(); }); // assert we are async diff --git a/src/test/java/io/reactivex/schedulers/AbstractSchedulerTests.java b/rxjava/src/test/java/io/reactivex/schedulers/AbstractSchedulerTests.java similarity index 74% rename from src/test/java/io/reactivex/schedulers/AbstractSchedulerTests.java rename to rxjava/src/test/java/io/reactivex/schedulers/AbstractSchedulerTests.java index 1c765153cd..c0bfc0d72f 100644 --- a/src/test/java/io/reactivex/schedulers/AbstractSchedulerTests.java +++ b/rxjava/src/test/java/io/reactivex/schedulers/AbstractSchedulerTests.java @@ -58,30 +58,21 @@ public void testNestedActions() throws InterruptedException { final Runnable thirdStepStart = mock(Runnable.class); final Runnable thirdStepEnd = mock(Runnable.class); - final Runnable firstAction = new Runnable() { - @Override - public void run() { - firstStepStart.run(); - firstStepEnd.run(); - latch.countDown(); - } + final Runnable firstAction = () -> { + firstStepStart.run(); + firstStepEnd.run(); + latch.countDown(); }; - final Runnable secondAction = new Runnable() { - @Override - public void run() { - secondStepStart.run(); - inner.schedule(firstAction); - secondStepEnd.run(); - - } + final Runnable secondAction = () -> { + secondStepStart.run(); + inner.schedule(firstAction); + secondStepEnd.run(); + }; - final Runnable thirdAction = new Runnable() { - @Override - public void run() { - thirdStepStart.run(); - inner.schedule(secondAction); - thirdStepEnd.run(); - } + final Runnable thirdAction = () -> { + thirdStepStart.run(); + inner.schedule(secondAction); + thirdStepEnd.run(); }; InOrder inOrder = inOrder(firstStepStart, firstStepEnd, secondStepStart, secondStepEnd, thirdStepStart, thirdStepEnd); @@ -106,21 +97,10 @@ public final void testNestedScheduling() { Observable ids = Observable.fromIterable(Arrays.asList(1, 2)).subscribeOn(getScheduler()); - Observable m = ids.flatMap(new Function>() { - - @Override - public Observable apply(Integer id) { - return Observable.fromIterable(Arrays.asList("a-" + id, "b-" + id)).subscribeOn(getScheduler()) - .map(new Function() { - - @Override - public String apply(String s) { - return "names=>" + s; - } - }); - } - - }); + Observable m = ids.flatMap(id -> + Observable.fromIterable(Arrays.asList("a-" + id, "b-" + id)) + .subscribeOn(getScheduler()) + .map(s -> "names=>" + s)); List strings = m.toList().toBlocking().last(); @@ -148,26 +128,18 @@ public final void testSequenceOfActions() throws InterruptedException { final Runnable second = mock(Runnable.class); // make it wait until both the first and second are called - doAnswer(new Answer() { - - @Override - public Object answer(InvocationOnMock invocation) throws Throwable { - try { - return invocation.getMock(); - } finally { - latch.countDown(); - } + doAnswer(invocation -> { + try { + return invocation.getMock(); + } finally { + latch.countDown(); } }).when(first).run(); - doAnswer(new Answer() { - - @Override - public Object answer(InvocationOnMock invocation) throws Throwable { - try { - return invocation.getMock(); - } finally { - latch.countDown(); - } + doAnswer(invocation -> { + try { + return invocation.getMock(); + } finally { + latch.countDown(); } }).when(second).run(); @@ -193,19 +165,10 @@ public void testSequenceOfDelayedActions() throws InterruptedException { final Runnable first = mock(Runnable.class); final Runnable second = mock(Runnable.class); - inner.schedule(new Runnable() { - @Override - public void run() { - inner.schedule(first, 30, TimeUnit.MILLISECONDS); - inner.schedule(second, 10, TimeUnit.MILLISECONDS); - inner.schedule(new Runnable() { - - @Override - public void run() { - latch.countDown(); - } - }, 40, TimeUnit.MILLISECONDS); - } + inner.schedule(() -> { + inner.schedule(first, 30, TimeUnit.MILLISECONDS); + inner.schedule(second, 10, TimeUnit.MILLISECONDS); + inner.schedule(latch::countDown, 40, TimeUnit.MILLISECONDS); }); latch.await(); @@ -230,21 +193,12 @@ public void testMixOfDelayedAndNonDelayedActions() throws InterruptedException { final Runnable third = mock(Runnable.class); final Runnable fourth = mock(Runnable.class); - inner.schedule(new Runnable() { - @Override - public void run() { - inner.schedule(first); - inner.schedule(second, 300, TimeUnit.MILLISECONDS); - inner.schedule(third, 100, TimeUnit.MILLISECONDS); - inner.schedule(fourth); - inner.schedule(new Runnable() { - - @Override - public void run() { - latch.countDown(); - } - }, 400, TimeUnit.MILLISECONDS); - } + inner.schedule(() -> { + inner.schedule(first); + inner.schedule(second, 300, TimeUnit.MILLISECONDS); + inner.schedule(third, 100, TimeUnit.MILLISECONDS); + inner.schedule(fourth); + inner.schedule(latch::countDown, 400, TimeUnit.MILLISECONDS); }); latch.await(); @@ -349,13 +303,9 @@ public void run() { }); final AtomicInteger lastValue = new AtomicInteger(); - obs.toBlocking().forEach(new Consumer() { - - @Override - public void accept(Integer v) { - System.out.println("Value: " + v); - lastValue.set(v); - } + obs.toBlocking().forEach(v -> { + System.out.println("Value: " + v); + lastValue.set(v); }); assertEquals(42, lastValue.get()); @@ -372,20 +322,16 @@ public void subscribe(final Subscriber observer) { observer.onSubscribe(EmptySubscription.INSTANCE); for (int i = 0; i < count; i++) { final int v = i; - new Thread(new Runnable() { + new Thread(() -> { + observer.onNext("v: " + v); - @Override - public void run() { - observer.onNext("v: " + v); - - latch.countDown(); - } + latch.countDown(); }).start(); } } }); - ConcurrentObserverValidator observer = new ConcurrentObserverValidator(); + ConcurrentObserverValidator observer = new ConcurrentObserverValidator<>(); // this should call onNext concurrently o.subscribe(observer); @@ -404,7 +350,7 @@ public final void testObserveOn() throws InterruptedException { Observable o = Observable.fromArray("one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten"); - ConcurrentObserverValidator observer = new ConcurrentObserverValidator(); + ConcurrentObserverValidator observer = new ConcurrentObserverValidator<>(); o.observeOn(scheduler).subscribe(observer); @@ -423,23 +369,14 @@ public final void testSubscribeOnNestedConcurrency() throws InterruptedException final Scheduler scheduler = getScheduler(); Observable o = Observable.fromArray("one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten") - .flatMap(new Function>() { - - @Override - public Observable apply(final String v) { - return Observable.create(new Publisher() { - - @Override - public void subscribe(Subscriber observer) { - observer.onSubscribe(EmptySubscription.INSTANCE); - observer.onNext("value_after_map-" + v); - observer.onComplete(); - } - }).subscribeOn(scheduler); + .flatMap(v -> Observable.create(observer -> { + observer.onSubscribe(EmptySubscription.INSTANCE); + observer.onNext("value_after_map-" + v); + observer.onComplete(); } - }); + ).subscribeOn(scheduler)); - ConcurrentObserverValidator observer = new ConcurrentObserverValidator(); + ConcurrentObserverValidator observer = new ConcurrentObserverValidator<>(); o.subscribe(observer); @@ -461,7 +398,7 @@ public void subscribe(Subscriber observer) { private static class ConcurrentObserverValidator extends Observer { final AtomicInteger concurrentCounter = new AtomicInteger(); - final AtomicReference error = new AtomicReference(); + final AtomicReference error = new AtomicReference<>(); final CountDownLatch completed = new CountDownLatch(1); @Override diff --git a/src/test/java/io/reactivex/schedulers/CachedThreadSchedulerTest.java b/rxjava/src/test/java/io/reactivex/schedulers/CachedThreadSchedulerTest.java similarity index 79% rename from src/test/java/io/reactivex/schedulers/CachedThreadSchedulerTest.java rename to rxjava/src/test/java/io/reactivex/schedulers/CachedThreadSchedulerTest.java index 1db6d57cb3..12210515ea 100644 --- a/src/test/java/io/reactivex/schedulers/CachedThreadSchedulerTest.java +++ b/rxjava/src/test/java/io/reactivex/schedulers/CachedThreadSchedulerTest.java @@ -37,21 +37,13 @@ public final void testIOScheduler() { Observable o1 = Observable.just(1, 2, 3, 4, 5); Observable o2 = Observable.just(6, 7, 8, 9, 10); - Observable o = Observable.merge(o1, o2).map(new Function() { - - @Override - public String apply(Integer t) { - assertTrue(Thread.currentThread().getName().startsWith("RxCachedThreadScheduler")); - return "Value_" + t + "_Thread_" + Thread.currentThread().getName(); - } + Observable o = Observable.merge(o1, o2).map(t -> { + assertTrue(Thread.currentThread().getName().startsWith("RxCachedThreadScheduler")); + return "Value_" + t + "_Thread_" + Thread.currentThread().getName(); }); - o.subscribeOn(Schedulers.io()).toBlocking().forEach(new Consumer() { - - @Override - public void accept(String t) { - System.out.println("t: " + t); - } + o.subscribeOn(Schedulers.io()).toBlocking().forEach((Consumer) t -> { + System.out.println("t: " + t); }); } diff --git a/src/test/java/io/reactivex/schedulers/ComputationSchedulerTests.java b/rxjava/src/test/java/io/reactivex/schedulers/ComputationSchedulerTests.java similarity index 72% rename from src/test/java/io/reactivex/schedulers/ComputationSchedulerTests.java rename to rxjava/src/test/java/io/reactivex/schedulers/ComputationSchedulerTests.java index 1a6f780163..01cc62370c 100644 --- a/src/test/java/io/reactivex/schedulers/ComputationSchedulerTests.java +++ b/rxjava/src/test/java/io/reactivex/schedulers/ComputationSchedulerTests.java @@ -38,7 +38,7 @@ public void testThreadSafetyWhenSchedulerIsHoppingBetweenThreads() { final int NUM = 1000000; final CountDownLatch latch = new CountDownLatch(1); - final HashMap map = new HashMap(); + final HashMap map = new HashMap<>(); final Scheduler.Worker inner = Schedulers.computation().createWorker(); @@ -90,23 +90,15 @@ public void run() { @Test public final void testComputationThreadPool1() { - Observable o1 = Observable. just(1, 2, 3, 4, 5); - Observable o2 = Observable. just(6, 7, 8, 9, 10); - Observable o = Observable. merge(o1, o2).map(new Function() { - - @Override - public String apply(Integer t) { - assertTrue(Thread.currentThread().getName().startsWith("RxComputationThreadPool")); - return "Value_" + t + "_Thread_" + Thread.currentThread().getName(); - } + Observable o1 = Observable.just(1, 2, 3, 4, 5); + Observable o2 = Observable.just(6, 7, 8, 9, 10); + Observable o = Observable.merge(o1, o2).map(t -> { + assertTrue(Thread.currentThread().getName().startsWith("RxComputationThreadPool")); + return "Value_" + t + "_Thread_" + Thread.currentThread().getName(); }); - o.subscribeOn(Schedulers.computation()).toBlocking().forEach(new Consumer() { - - @Override - public void accept(String t) { - System.out.println("t: " + t); - } + o.subscribeOn(Schedulers.computation()).toBlocking().forEach(t -> { + System.out.println("t: " + t); }); } @@ -116,25 +108,15 @@ public final void testMergeWithExecutorScheduler() { final String currentThreadName = Thread.currentThread().getName(); - Observable o1 = Observable. just(1, 2, 3, 4, 5); - Observable o2 = Observable. just(6, 7, 8, 9, 10); - Observable o = Observable. merge(o1, o2).subscribeOn(Schedulers.computation()).map(new Function() { - - @Override - public String apply(Integer t) { - assertFalse(Thread.currentThread().getName().equals(currentThreadName)); - assertTrue(Thread.currentThread().getName().startsWith("RxComputationThreadPool")); - return "Value_" + t + "_Thread_" + Thread.currentThread().getName(); - } + Observable o1 = Observable.just(1, 2, 3, 4, 5); + Observable o2 = Observable.just(6, 7, 8, 9, 10); + Observable o = Observable.merge(o1, o2).subscribeOn(Schedulers.computation()).map(t -> { + assertFalse(Thread.currentThread().getName().equals(currentThreadName)); + assertTrue(Thread.currentThread().getName().startsWith("RxComputationThreadPool")); + return "Value_" + t + "_Thread_" + Thread.currentThread().getName(); }); - o.toBlocking().forEach(new Consumer() { - - @Override - public void accept(String t) { - System.out.println("t: " + t); - } - }); + o.toBlocking().forEach(t -> System.out.println("t: " + t)); } @Test diff --git a/src/test/java/io/reactivex/schedulers/ExecutorSchedulerTest.java b/rxjava/src/test/java/io/reactivex/schedulers/ExecutorSchedulerTest.java similarity index 93% rename from src/test/java/io/reactivex/schedulers/ExecutorSchedulerTest.java rename to rxjava/src/test/java/io/reactivex/schedulers/ExecutorSchedulerTest.java index 10c087f873..8ee4c8a70c 100644 --- a/src/test/java/io/reactivex/schedulers/ExecutorSchedulerTest.java +++ b/rxjava/src/test/java/io/reactivex/schedulers/ExecutorSchedulerTest.java @@ -67,17 +67,11 @@ public static void testCancelledRetention(Scheduler.Worker w, boolean periodic) int n = 100 * 1000; if (periodic) { final CountDownLatch cdl = new CountDownLatch(n); - final Runnable action = new Runnable() { - @Override - public void run() { - cdl.countDown(); - } - }; for (int i = 0; i < n; i++) { if (i % 50000 == 0) { System.out.println(" -> still scheduling: " + i); } - w.schedulePeriodically(action, 0, 1, TimeUnit.DAYS); + w.schedulePeriodically(cdl::countDown, 0, 1, TimeUnit.DAYS); } System.out.println("Waiting for the first round to finish..."); @@ -145,7 +139,7 @@ public void testCancelledTaskRetention() throws InterruptedException { /** A simple executor which queues tasks and executes them one-by-one if executeOne() is called. */ static final class TestExecutor implements Executor { - final ConcurrentLinkedQueue queue = new ConcurrentLinkedQueue(); + final ConcurrentLinkedQueue queue = new ConcurrentLinkedQueue<>(); @Override public void execute(Runnable command) { queue.offer(command); @@ -167,12 +161,7 @@ public void executeAll() { @Test public void testCancelledTasksDontRun() { final AtomicInteger calls = new AtomicInteger(); - Runnable task = new Runnable() { - @Override - public void run() { - calls.getAndIncrement(); - } - }; + Runnable task = calls::getAndIncrement; TestExecutor exec = new TestExecutor(); Scheduler custom = Schedulers.from(exec); Worker w = custom.createWorker(); @@ -195,12 +184,7 @@ public void run() { @Test public void testCancelledWorkerDoesntRunTasks() { final AtomicInteger calls = new AtomicInteger(); - Runnable task = new Runnable() { - @Override - public void run() { - calls.getAndIncrement(); - } - }; + Runnable task = calls::getAndIncrement; TestExecutor exec = new TestExecutor(); Scheduler custom = Schedulers.from(exec); Worker w = custom.createWorker(); diff --git a/src/test/java/io/reactivex/schedulers/NewThreadSchedulerTest.java b/rxjava/src/test/java/io/reactivex/schedulers/NewThreadSchedulerTest.java similarity index 100% rename from src/test/java/io/reactivex/schedulers/NewThreadSchedulerTest.java rename to rxjava/src/test/java/io/reactivex/schedulers/NewThreadSchedulerTest.java diff --git a/src/test/java/io/reactivex/schedulers/SchedulerLifecycleTest.java b/rxjava/src/test/java/io/reactivex/schedulers/SchedulerLifecycleTest.java similarity index 92% rename from src/test/java/io/reactivex/schedulers/SchedulerLifecycleTest.java rename to rxjava/src/test/java/io/reactivex/schedulers/SchedulerLifecycleTest.java index eba99ec5b1..78e2cd262a 100644 --- a/src/test/java/io/reactivex/schedulers/SchedulerLifecycleTest.java +++ b/rxjava/src/test/java/io/reactivex/schedulers/SchedulerLifecycleTest.java @@ -32,7 +32,7 @@ public void testShutdown() throws InterruptedException { System.out.println("testShutdown >> Giving time threads to spin-up"); Thread.sleep(500); - Set rxThreads = new HashSet(); + Set rxThreads = new HashSet<>(); for (Thread t : Thread.getAllStackTraces().keySet()) { if (t.getName().startsWith("Rx")) { rxThreads.add(t); @@ -67,12 +67,7 @@ public void testShutdown() throws InterruptedException { private void tryOutSchedulers() throws InterruptedException { final CountDownLatch cdl = new CountDownLatch(4); - final Runnable countAction = new Runnable() { - @Override - public void run() { - cdl.countDown(); - } - }; + final Runnable countAction = cdl::countDown; CompositeDisposable csub = new CompositeDisposable(); @@ -109,7 +104,7 @@ public void testStartIdempotence() throws InterruptedException { System.out.println("testStartIdempotence >> giving some time"); Thread.sleep(500); - Set rxThreadsBefore = new HashSet(); + Set rxThreadsBefore = new HashSet<>(); for (Thread t : Thread.getAllStackTraces().keySet()) { if (t.getName().startsWith("Rx")) { rxThreadsBefore.add(t); @@ -121,7 +116,7 @@ public void testStartIdempotence() throws InterruptedException { System.out.println("testStartIdempotence >> giving some time again"); Thread.sleep(500); - Set rxThreadsAfter = new HashSet(); + Set rxThreadsAfter = new HashSet<>(); for (Thread t : Thread.getAllStackTraces().keySet()) { if (t.getName().startsWith("Rx")) { rxThreadsAfter.add(t); diff --git a/src/test/java/io/reactivex/schedulers/SchedulerTests.java b/rxjava/src/test/java/io/reactivex/schedulers/SchedulerTests.java similarity index 99% rename from src/test/java/io/reactivex/schedulers/SchedulerTests.java rename to rxjava/src/test/java/io/reactivex/schedulers/SchedulerTests.java index 972fefb0ad..4b2b288776 100644 --- a/src/test/java/io/reactivex/schedulers/SchedulerTests.java +++ b/rxjava/src/test/java/io/reactivex/schedulers/SchedulerTests.java @@ -69,7 +69,7 @@ static void testHandledErrorIsNotDeliveredToThreadHandler(Scheduler scheduler) t Thread.UncaughtExceptionHandler originalHandler = Thread.getDefaultUncaughtExceptionHandler(); try { CapturingUncaughtExceptionHandler handler = new CapturingUncaughtExceptionHandler(); - CapturingObserver observer = new CapturingObserver(); + CapturingObserver observer = new CapturingObserver<>(); Thread.setDefaultUncaughtExceptionHandler(handler); IllegalStateException error = new IllegalStateException("Should be delivered to handler"); Observable.error(error) diff --git a/src/test/java/io/reactivex/schedulers/TestSchedulerTest.java b/rxjava/src/test/java/io/reactivex/schedulers/TestSchedulerTest.java similarity index 93% rename from src/test/java/io/reactivex/schedulers/TestSchedulerTest.java rename to rxjava/src/test/java/io/reactivex/schedulers/TestSchedulerTest.java index c33a847f92..785a248ba4 100644 --- a/src/test/java/io/reactivex/schedulers/TestSchedulerTest.java +++ b/rxjava/src/test/java/io/reactivex/schedulers/TestSchedulerTest.java @@ -42,12 +42,9 @@ public final void testPeriodicScheduling() { final Scheduler.Worker inner = scheduler.createWorker(); try { - inner.schedulePeriodically(new Runnable() { - @Override - public void run() { - System.out.println(scheduler.now(TimeUnit.MILLISECONDS)); - calledOp.apply(scheduler.now(TimeUnit.MILLISECONDS)); - } + inner.schedulePeriodically(() -> { + System.out.println(scheduler.now(TimeUnit.MILLISECONDS)); + calledOp.apply(scheduler.now(TimeUnit.MILLISECONDS)); }, 1, 2, TimeUnit.SECONDS); verify(calledOp, never()).apply(anyLong()); @@ -88,12 +85,9 @@ public final void testPeriodicSchedulingUnsubscription() { final Scheduler.Worker inner = scheduler.createWorker(); try { - final Disposable subscription = inner.schedulePeriodically(new Runnable() { - @Override - public void run() { - System.out.println(scheduler.now(TimeUnit.MILLISECONDS)); - calledOp.apply(scheduler.now(TimeUnit.MILLISECONDS)); - } + final Disposable subscription = inner.schedulePeriodically(() -> { + System.out.println(scheduler.now(TimeUnit.MILLISECONDS)); + calledOp.apply(scheduler.now(TimeUnit.MILLISECONDS)); }, 1, 2, TimeUnit.SECONDS); verify(calledOp, never()).apply(anyLong()); diff --git a/src/test/java/io/reactivex/schedulers/TrampolineSchedulerTest.java b/rxjava/src/test/java/io/reactivex/schedulers/TrampolineSchedulerTest.java similarity index 58% rename from src/test/java/io/reactivex/schedulers/TrampolineSchedulerTest.java rename to rxjava/src/test/java/io/reactivex/schedulers/TrampolineSchedulerTest.java index 8d04ec12ee..2601af02ad 100644 --- a/src/test/java/io/reactivex/schedulers/TrampolineSchedulerTest.java +++ b/rxjava/src/test/java/io/reactivex/schedulers/TrampolineSchedulerTest.java @@ -44,51 +44,29 @@ public final void testMergeWithCurrentThreadScheduler1() { Observable o1 = Observable. just(1, 2, 3, 4, 5); Observable o2 = Observable. just(6, 7, 8, 9, 10); - Observable o = Observable. merge(o1, o2).subscribeOn(Schedulers.trampoline()).map(new Function() { - - @Override - public String apply(Integer t) { - assertTrue(Thread.currentThread().getName().equals(currentThreadName)); - return "Value_" + t + "_Thread_" + Thread.currentThread().getName(); - } + Observable o = Observable. merge(o1, o2).subscribeOn(Schedulers.trampoline()).map(t -> { + assertTrue(Thread.currentThread().getName().equals(currentThreadName)); + return "Value_" + t + "_Thread_" + Thread.currentThread().getName(); }); - o.toBlocking().forEach(new Consumer() { - - @Override - public void accept(String t) { - System.out.println("t: " + t); - } - }); + o.toBlocking().forEach(t -> System.out.println("t: " + t)); } @Test public void testNestedTrampolineWithUnsubscribe() { - final ArrayList workDone = new ArrayList(); + final ArrayList workDone = new ArrayList<>(); final CompositeDisposable workers = new CompositeDisposable(); Worker worker = Schedulers.trampoline().createWorker(); try { workers.add(worker); - worker.schedule(new Runnable() { - - @Override - public void run() { - workers.add(doWorkOnNewTrampoline("A", workDone)); - } - - }); + worker.schedule(() -> workers.add(doWorkOnNewTrampoline("A", workDone))); final Worker worker2 = Schedulers.trampoline().createWorker(); workers.add(worker2); - worker2.schedule(new Runnable() { - - @Override - public void run() { - workers.add(doWorkOnNewTrampoline("B", workDone)); - // we unsubscribe worker2 ... it should not affect work scheduled on a separate Trampline.Worker - worker2.dispose(); - } - + worker2.schedule(() -> { + workers.add(doWorkOnNewTrampoline("B", workDone)); + // we unsubscribe worker2 ... it should not affect work scheduled on a separate Trampline.Worker + worker2.dispose(); }); assertEquals(6, workDone.size()); @@ -108,23 +86,13 @@ public void run() { public void testTrampolineWorkerHandlesConcurrentScheduling() { final Worker trampolineWorker = Schedulers.trampoline().createWorker(); final Subscriber observer = TestHelper.mockSubscriber(); - final TestSubscriber ts = new TestSubscriber(observer); + final TestSubscriber ts = new TestSubscriber<>(observer); // Spam the trampoline with actions. Observable.range(0, 50) - .flatMap(new Function>() { - @Override - public Publisher apply(Integer count) { - return Observable - .interval(1, TimeUnit.MICROSECONDS) - .map(new Function() { - @Override - public Disposable apply(Long ount1) { - return trampolineWorker.schedule(Functions.emptyRunnable()); - } - }).take(100); - } - }) + .flatMap(count -> Observable + .interval(1, TimeUnit.MICROSECONDS) + .map(ount1 -> trampolineWorker.schedule(Functions.emptyRunnable())).take(100)) .subscribeOn(Schedulers.computation()) .subscribe(ts); ts.awaitTerminalEvent(); @@ -133,31 +101,21 @@ public Disposable apply(Long ount1) { private static Worker doWorkOnNewTrampoline(final String key, final ArrayList workDone) { Worker worker = Schedulers.trampoline().createWorker(); - worker.schedule(new Runnable() { - - @Override - public void run() { - String msg = key + ".1"; - workDone.add(msg); - System.out.println(msg); - Worker worker3 = Schedulers.trampoline().createWorker(); - worker3.schedule(createPrintAction(key + ".B.1", workDone)); - worker3.schedule(createPrintAction(key + ".B.2", workDone)); - } - + worker.schedule(() -> { + String msg = key + ".1"; + workDone.add(msg); + System.out.println(msg); + Worker worker3 = Schedulers.trampoline().createWorker(); + worker3.schedule(createPrintAction(key + ".B.1", workDone)); + worker3.schedule(createPrintAction(key + ".B.2", workDone)); }); return worker; } private static Runnable createPrintAction(final String message, final ArrayList workDone) { - return new Runnable() { - - @Override - public void run() { - System.out.println(message); - workDone.add(message); - } - + return () -> { + System.out.println(message); + workDone.add(message); }; } } \ No newline at end of file diff --git a/src/test/java/io/reactivex/subjects/AsyncSubjectTest.java b/rxjava/src/test/java/io/reactivex/subjects/AsyncSubjectTest.java similarity index 94% rename from src/test/java/io/reactivex/subjects/AsyncSubjectTest.java rename to rxjava/src/test/java/io/reactivex/subjects/AsyncSubjectTest.java index e0258061ed..88fe1b7ada 100644 --- a/src/test/java/io/reactivex/subjects/AsyncSubjectTest.java +++ b/rxjava/src/test/java/io/reactivex/subjects/AsyncSubjectTest.java @@ -146,7 +146,7 @@ public void testUnsubscribeBeforeCompleted() { AsyncSubject subject = AsyncSubject.create(); Subscriber observer = TestHelper.mockSubscriber(); - TestSubscriber ts = new TestSubscriber(observer); + TestSubscriber ts = new TestSubscriber<>(observer); subject.subscribe(ts); subject.onNext("one"); @@ -195,30 +195,21 @@ public void testSubscribeCompletionRaceCondition() { */ for (int i = 0; i < 50; i++) { final AsyncSubject subject = AsyncSubject.create(); - final AtomicReference value1 = new AtomicReference(); - - subject.subscribe(new Consumer() { - - @Override - public void accept(String t1) { - try { - // simulate a slow observer - Thread.sleep(50); - } catch (InterruptedException e) { - e.printStackTrace(); - } - value1.set(t1); + final AtomicReference value1 = new AtomicReference<>(); + + subject.subscribe(t1 -> { + try { + // simulate a slow observer + Thread.sleep(50); + } catch (InterruptedException e) { + e.printStackTrace(); } - + value1.set(t1); }); - Thread t1 = new Thread(new Runnable() { - - @Override - public void run() { - subject.onNext("value"); - subject.onComplete(); - } + Thread t1 = new Thread(() -> { + subject.onNext("value"); + subject.onComplete(); }); SubjectSubscriberThread t2 = new SubjectSubscriberThread(subject); @@ -253,7 +244,7 @@ public void run() { private static class SubjectSubscriberThread extends Thread { private final AsyncSubject subject; - private final AtomicReference value = new AtomicReference(); + private final AtomicReference value = new AtomicReference<>(); public SubjectSubscriberThread(AsyncSubject subject) { this.subject = subject; diff --git a/src/test/java/io/reactivex/subjects/BehaviorSubjectTest.java b/rxjava/src/test/java/io/reactivex/subjects/BehaviorSubjectTest.java similarity index 94% rename from src/test/java/io/reactivex/subjects/BehaviorSubjectTest.java rename to rxjava/src/test/java/io/reactivex/subjects/BehaviorSubjectTest.java index 3f77f941f9..a991360e61 100644 --- a/src/test/java/io/reactivex/subjects/BehaviorSubjectTest.java +++ b/rxjava/src/test/java/io/reactivex/subjects/BehaviorSubjectTest.java @@ -128,7 +128,7 @@ public void testCompletedStopsEmittingData() { Subscriber observerB = TestHelper.mockSubscriber(); Subscriber observerC = TestHelper.mockSubscriber(); - TestSubscriber ts = new TestSubscriber(observerA); + TestSubscriber ts = new TestSubscriber<>(observerA); channel.subscribe(ts); channel.subscribe(observerB); @@ -246,13 +246,7 @@ public void testUnsubscriptionCase() { src.onNext(v); System.out.printf("Turn: %d%n", i); src.first() - .flatMap(new Function>() { - - @Override - public Observable apply(String t1) { - return Observable.just(t1 + ", " + t1); - } - }) + .flatMap(t1 -> Observable.just(t1 + ", " + t1)) .subscribe(new Observer() { @Override public void onNext(String t) { @@ -412,19 +406,16 @@ public void testEmissionSubscriptionRace() throws Exception { final CountDownLatch finish = new CountDownLatch(1); final CountDownLatch start = new CountDownLatch(1); - worker.schedule(new Runnable() { - @Override - public void run() { - try { - start.await(); - } catch (Exception e1) { - e1.printStackTrace(); - } - rs.onNext(1); + worker.schedule(() -> { + try { + start.await(); + } catch (Exception e1) { + e1.printStackTrace(); } + rs.onNext(1); }); - final AtomicReference o = new AtomicReference(); + final AtomicReference o = new AtomicReference<>(); rs.subscribeOn(s).observeOn(Schedulers.io()) .subscribe(new Observer() { @@ -458,12 +449,7 @@ public void onNext(Object t) { break; } else { Assert.assertEquals(1, o.get()); - worker.schedule(new Runnable() { - @Override - public void run() { - rs.onComplete(); - } - }); + worker.schedule(rs::onComplete); } } } finally { @@ -500,7 +486,7 @@ public void testCurrentStateMethodsNormalEmptyStart() { @Test public void testCurrentStateMethodsNormalSomeStart() { - BehaviorSubject as = BehaviorSubject.createDefault((Object)1); + BehaviorSubject as = BehaviorSubject.createDefault(1); assertTrue(as.hasValue()); assertFalse(as.hasThrowable()); diff --git a/src/test/java/io/reactivex/subjects/PublishSubjectTest.java b/rxjava/src/test/java/io/reactivex/subjects/PublishSubjectTest.java similarity index 89% rename from src/test/java/io/reactivex/subjects/PublishSubjectTest.java rename to rxjava/src/test/java/io/reactivex/subjects/PublishSubjectTest.java index f7e9343d5b..a3cfa99e9e 100644 --- a/src/test/java/io/reactivex/subjects/PublishSubjectTest.java +++ b/rxjava/src/test/java/io/reactivex/subjects/PublishSubjectTest.java @@ -62,7 +62,7 @@ public void testCompletedStopsEmittingData() { Subscriber observerB = TestHelper.mockSubscriber(); Subscriber observerC = TestHelper.mockSubscriber(); - TestSubscriber ts = new TestSubscriber(observerA); + TestSubscriber ts = new TestSubscriber<>(observerA); channel.subscribe(ts); channel.subscribe(observerB); @@ -171,7 +171,7 @@ public void testUnsubscribeFirstSubscriber() { PublishSubject subject = PublishSubject.create(); Subscriber observer = TestHelper.mockSubscriber(); - TestSubscriber ts = new TestSubscriber(observer); + TestSubscriber ts = new TestSubscriber<>(observer); subject.subscribe(ts); subject.onNext("one"); @@ -206,34 +206,19 @@ public void testNestedSubscribe() { final AtomicInteger countChildren = new AtomicInteger(); final AtomicInteger countTotal = new AtomicInteger(); - final ArrayList list = new ArrayList(); + final ArrayList list = new ArrayList<>(); - s.flatMap(new Function>() { - - @Override - public Observable apply(final Integer v) { - countParent.incrementAndGet(); - - // then subscribe to subject again (it will not receive the previous value) - return s.map(new Function() { - - @Override - public String apply(Integer v2) { - countChildren.incrementAndGet(); - return "Parent: " + v + " Child: " + v2; - } - - }); - } - - }).subscribe(new Consumer() { - - @Override - public void accept(String v) { - countTotal.incrementAndGet(); - list.add(v); - } + s.flatMap(v -> { + countParent.incrementAndGet(); + // then subscribe to subject again (it will not receive the previous value) + return s.map(v2 -> { + countChildren.incrementAndGet(); + return "Parent: " + v + " Child: " + v2; + }); + }).subscribe(v -> { + countTotal.incrementAndGet(); + list.add(v); }); for (int i = 0; i < 10; i++) { @@ -257,7 +242,7 @@ public void testReSubscribe() { final PublishSubject ps = PublishSubject.create(); Subscriber o1 = TestHelper.mockSubscriber(); - TestSubscriber ts = new TestSubscriber(o1); + TestSubscriber ts = new TestSubscriber<>(o1); ps.subscribe(ts); // emit @@ -275,7 +260,7 @@ public void testReSubscribe() { ps.onNext(2); Subscriber o2 = TestHelper.mockSubscriber(); - TestSubscriber ts2 = new TestSubscriber(o2); + TestSubscriber ts2 = new TestSubscriber<>(o2); ps.subscribe(ts2); // emit @@ -301,13 +286,7 @@ public void testUnsubscriptionCase() { String v = "" + i; System.out.printf("Turn: %d%n", i); src.first() - .flatMap(new Function>() { - - @Override - public Observable apply(String t1) { - return Observable.just(t1 + ", " + t1); - } - }) + .flatMap(t1 -> Observable.just(t1 + ", " + t1)) .subscribe(new Observer() { @Override public void onNext(String t) { diff --git a/src/test/java/io/reactivex/subjects/ReplaySubjectBoundedConcurrencyTest.java b/rxjava/src/test/java/io/reactivex/subjects/ReplaySubjectBoundedConcurrencyTest.java similarity index 65% rename from src/test/java/io/reactivex/subjects/ReplaySubjectBoundedConcurrencyTest.java rename to rxjava/src/test/java/io/reactivex/subjects/ReplaySubjectBoundedConcurrencyTest.java index aeb728ec75..37bc9c74fb 100644 --- a/src/test/java/io/reactivex/subjects/ReplaySubjectBoundedConcurrencyTest.java +++ b/rxjava/src/test/java/io/reactivex/subjects/ReplaySubjectBoundedConcurrencyTest.java @@ -35,23 +35,19 @@ public class ReplaySubjectBoundedConcurrencyTest { @Test(timeout = 4000) public void testReplaySubjectConcurrentSubscribersDoingReplayDontBlockEachOther() throws InterruptedException { final ReplaySubject replay = ReplaySubject.createUnbounded(); - Thread source = new Thread(new Runnable() { + Thread source = new Thread(() -> { + Observable.create(new Publisher() { - @Override - public void run() { - Observable.create(new Publisher() { - - @Override - public void subscribe(Subscriber o) { - System.out.println("********* Start Source Data ***********"); - for (long l = 1; l <= 10000; l++) { - o.onNext(l); - } - System.out.println("********* Finished Source Data ***********"); - o.onComplete(); + @Override + public void subscribe(Subscriber o) { + System.out.println("********* Start Source Data ***********"); + for (long l = 1; l <= 10000; l++) { + o.onNext(l); } - }).subscribe(replay); - } + System.out.println("********* Finished Source Data ***********"); + o.onComplete(); + } + }).subscribe(replay); }); source.start(); @@ -60,76 +56,68 @@ public void subscribe(Subscriber o) { // it's been played through once so now it will all be replays final CountDownLatch slowLatch = new CountDownLatch(1); - Thread slowThread = new Thread(new Runnable() { + Thread slowThread = new Thread(() -> { + Subscriber slow = new Observer() { - @Override - public void run() { - Subscriber slow = new Observer() { + @Override + public void onComplete() { + System.out.println("*** Slow Observer completed"); + slowLatch.countDown(); + } - @Override - public void onComplete() { - System.out.println("*** Slow Observer completed"); - slowLatch.countDown(); - } + @Override + public void onError(Throwable e) { + } - @Override - public void onError(Throwable e) { + @Override + public void onNext(Long args) { + if (args == 1) { + System.out.println("*** Slow Observer STARTED"); } - - @Override - public void onNext(Long args) { - if (args == 1) { - System.out.println("*** Slow Observer STARTED"); - } - try { - if (args % 10 == 0) { - Thread.sleep(1); - } - } catch (InterruptedException e) { - e.printStackTrace(); + try { + if (args % 10 == 0) { + Thread.sleep(1); } + } catch (InterruptedException e) { + e.printStackTrace(); } - }; - replay.subscribe(slow); - try { - slowLatch.await(); - } catch (InterruptedException e1) { - e1.printStackTrace(); } + }; + replay.subscribe(slow); + try { + slowLatch.await(); + } catch (InterruptedException e1) { + e1.printStackTrace(); } }); slowThread.start(); - Thread fastThread = new Thread(new Runnable() { - - @Override - public void run() { - final CountDownLatch fastLatch = new CountDownLatch(1); - Subscriber fast = new Observer() { + Thread fastThread = new Thread(() -> { + final CountDownLatch fastLatch = new CountDownLatch(1); + Subscriber fast = new Observer() { - @Override - public void onComplete() { - System.out.println("*** Fast Observer completed"); - fastLatch.countDown(); - } + @Override + public void onComplete() { + System.out.println("*** Fast Observer completed"); + fastLatch.countDown(); + } - @Override - public void onError(Throwable e) { - } + @Override + public void onError(Throwable e) { + } - @Override - public void onNext(Long args) { - if (args == 1) { - System.out.println("*** Fast Observer STARTED"); - } + @Override + public void onNext(Long args) { + if (args == 1) { + System.out.println("*** Fast Observer STARTED"); } - }; - replay.subscribe(fast); - try { - fastLatch.await(); - } catch (InterruptedException e1) { - e1.printStackTrace(); } + }; + replay.subscribe(fast); + try { + fastLatch.await(); + } catch (InterruptedException e1) { + e1.printStackTrace(); } }); fastThread.start(); @@ -144,28 +132,24 @@ public void onNext(Long args) { @Test public void testReplaySubjectConcurrentSubscriptions() throws InterruptedException { final ReplaySubject replay = ReplaySubject.createUnbounded(); - Thread source = new Thread(new Runnable() { + Thread source = new Thread(() -> { + Observable.create(new Publisher() { - @Override - public void run() { - Observable.create(new Publisher() { - - @Override - public void subscribe(Subscriber o) { - System.out.println("********* Start Source Data ***********"); - for (long l = 1; l <= 10000; l++) { - o.onNext(l); - } - System.out.println("********* Finished Source Data ***********"); - o.onComplete(); + @Override + public void subscribe(Subscriber o) { + System.out.println("********* Start Source Data ***********"); + for (long l = 1; l <= 10000; l++) { + o.onNext(l); } - }).subscribe(replay); - } + System.out.println("********* Finished Source Data ***********"); + o.onComplete(); + } + }).subscribe(replay); }); // used to collect results of each thread - final List> listOfListsOfValues = Collections.synchronizedList(new ArrayList>()); - final List threads = Collections.synchronizedList(new ArrayList()); + final List> listOfListsOfValues = Collections.synchronizedList(new ArrayList<>()); + final List threads = Collections.synchronizedList(new ArrayList<>()); for (int i = 1; i <= 200; i++) { final int count = i; @@ -178,14 +162,10 @@ public void subscribe(Subscriber o) { // wait for source to finish then keep adding after it's done source.join(); } - Thread t = new Thread(new Runnable() { - - @Override - public void run() { - List values = replay.toList().toBlocking().last(); - listOfListsOfValues.add(values); - System.out.println("Finished thread: " + count); - } + Thread t = new Thread(() -> { + List values = replay.toList().toBlocking().last(); + listOfListsOfValues.add(values); + System.out.println("Finished thread: " + count); }); t.start(); System.out.println("Started thread: " + i); @@ -198,7 +178,7 @@ public void run() { } // assert all threads got the same results - List sums = new ArrayList(); + List sums = new ArrayList<>(); for (List values : listOfListsOfValues) { long v = 0; for (long l : values) { @@ -231,30 +211,21 @@ public void run() { public void testSubscribeCompletionRaceCondition() { for (int i = 0; i < 50; i++) { final ReplaySubject subject = ReplaySubject.createUnbounded(); - final AtomicReference value1 = new AtomicReference(); - - subject.subscribe(new Consumer() { + final AtomicReference value1 = new AtomicReference<>(); - @Override - public void accept(String t1) { - try { - // simulate a slow observer - Thread.sleep(50); - } catch (InterruptedException e) { - e.printStackTrace(); - } - value1.set(t1); + subject.subscribe(t1 -> { + try { + // simulate a slow observer + Thread.sleep(50); + } catch (InterruptedException e) { + e.printStackTrace(); } - + value1.set(t1); }); - Thread t1 = new Thread(new Runnable() { - - @Override - public void run() { - subject.onNext("value"); - subject.onComplete(); - } + Thread t1 = new Thread(() -> { + subject.onNext("value"); + subject.onComplete(); }); SubjectObserverThread t2 = new SubjectObserverThread(subject); @@ -293,7 +264,7 @@ public void run() { public void testRaceForTerminalState() { final List expected = Arrays.asList(1); for (int i = 0; i < 100000; i++) { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.just(1).subscribeOn(Schedulers.computation()).cache().subscribe(ts); ts.awaitTerminalEvent(); ts.assertValueSequence(expected); @@ -304,7 +275,7 @@ public void testRaceForTerminalState() { private static class SubjectObserverThread extends Thread { private final ReplaySubject subject; - private final AtomicReference value = new AtomicReference(); + private final AtomicReference value = new AtomicReference<>(); public SubjectObserverThread(ReplaySubject subject) { this.subject = subject; @@ -337,20 +308,17 @@ public void testReplaySubjectEmissionSubscriptionRace() throws Exception { // int j = i; - worker.schedule(new Runnable() { - @Override - public void run() { - try { - start.await(); - } catch (Exception e1) { - e1.printStackTrace(); - } -// System.out.println("> " + j); - rs.onNext(1); + worker.schedule(() -> { + try { + start.await(); + } catch (Exception e1) { + e1.printStackTrace(); } +// System.out.println("> " + j); + rs.onNext(1); }); - final AtomicReference o = new AtomicReference(); + final AtomicReference o = new AtomicReference<>(); rs // .doOnSubscribe(v -> System.out.println("!! " + j)) @@ -394,12 +362,7 @@ public void onNext(Object t) { break; } else { Assert.assertEquals(1, o.get()); - worker.schedule(new Runnable() { - @Override - public void run() { - rs.onComplete(); - } - }); + worker.schedule(rs::onComplete); } } } finally { @@ -411,22 +374,19 @@ public void testConcurrentSizeAndHasAnyValue() throws InterruptedException { final ReplaySubject rs = ReplaySubject.createUnbounded(); final CyclicBarrier cb = new CyclicBarrier(2); - Thread t = new Thread(new Runnable() { - @Override - public void run() { - try { - cb.await(); - } catch (InterruptedException e) { - return; - } catch (BrokenBarrierException e) { - return; - } - for (int i = 0; i < 1000000; i++) { - rs.onNext(i); - } - rs.onComplete(); - System.out.println("Replay fill Thread finished!"); + Thread t = new Thread(() -> { + try { + cb.await(); + } catch (InterruptedException e) { + return; + } catch (BrokenBarrierException e) { + return; + } + for (int i = 0; i < 1000000; i++) { + rs.onNext(i); } + rs.onComplete(); + System.out.println("Replay fill Thread finished!"); }); t.start(); try { @@ -465,22 +425,19 @@ public void testConcurrentSizeAndHasAnyValueBounded() throws InterruptedExceptio final ReplaySubject rs = ReplaySubject.createWithSize(3); final CyclicBarrier cb = new CyclicBarrier(2); - Thread t = new Thread(new Runnable() { - @Override - public void run() { - try { - cb.await(); - } catch (InterruptedException e) { - return; - } catch (BrokenBarrierException e) { - return; - } - for (int i = 0; i < 1000000; i++) { - rs.onNext(i); - } - rs.onComplete(); - System.out.println("Replay fill Thread finished!"); + Thread t = new Thread(() -> { + try { + cb.await(); + } catch (InterruptedException e) { + return; + } catch (BrokenBarrierException e) { + return; } + for (int i = 0; i < 1000000; i++) { + rs.onNext(i); + } + rs.onComplete(); + System.out.println("Replay fill Thread finished!"); }); t.start(); try { @@ -508,29 +465,26 @@ public void testConcurrentSizeAndHasAnyValueTimeBounded() throws InterruptedExce final ReplaySubject rs = ReplaySubject.createWithTime(1, TimeUnit.MILLISECONDS, Schedulers.computation()); final CyclicBarrier cb = new CyclicBarrier(2); - Thread t = new Thread(new Runnable() { - @Override - public void run() { - try { - cb.await(); - } catch (InterruptedException e) { - return; - } catch (BrokenBarrierException e) { - return; - } - for (int i = 0; i < 1000000; i++) { - rs.onNext(i); - if (i % 10000 == 0) { - try { - Thread.sleep(1); - } catch (InterruptedException e) { - return; - } + Thread t = new Thread(() -> { + try { + cb.await(); + } catch (InterruptedException e) { + return; + } catch (BrokenBarrierException e) { + return; + } + for (int i = 0; i < 1000000; i++) { + rs.onNext(i); + if (i % 10000 == 0) { + try { + Thread.sleep(1); + } catch (InterruptedException e) { + return; } } - rs.onComplete(); - System.out.println("Replay fill Thread finished!"); } + rs.onComplete(); + System.out.println("Replay fill Thread finished!"); }); t.start(); try { diff --git a/src/test/java/io/reactivex/subjects/ReplaySubjectConcurrencyTest.java b/rxjava/src/test/java/io/reactivex/subjects/ReplaySubjectConcurrencyTest.java similarity index 64% rename from src/test/java/io/reactivex/subjects/ReplaySubjectConcurrencyTest.java rename to rxjava/src/test/java/io/reactivex/subjects/ReplaySubjectConcurrencyTest.java index 316f7dff1a..4c155b1aa0 100644 --- a/src/test/java/io/reactivex/subjects/ReplaySubjectConcurrencyTest.java +++ b/rxjava/src/test/java/io/reactivex/subjects/ReplaySubjectConcurrencyTest.java @@ -35,23 +35,19 @@ public class ReplaySubjectConcurrencyTest { @Test(timeout = 4000) public void testReplaySubjectConcurrentSubscribersDoingReplayDontBlockEachOther() throws InterruptedException { final ReplaySubject replay = ReplaySubject.create(); - Thread source = new Thread(new Runnable() { + Thread source = new Thread(() -> { + Observable.create(new Publisher() { - @Override - public void run() { - Observable.create(new Publisher() { - - @Override - public void subscribe(Subscriber o) { - System.out.println("********* Start Source Data ***********"); - for (long l = 1; l <= 10000; l++) { - o.onNext(l); - } - System.out.println("********* Finished Source Data ***********"); - o.onComplete(); + @Override + public void subscribe(Subscriber o) { + System.out.println("********* Start Source Data ***********"); + for (long l = 1; l <= 10000; l++) { + o.onNext(l); } - }).subscribe(replay); - } + System.out.println("********* Finished Source Data ***********"); + o.onComplete(); + } + }).subscribe(replay); }); source.start(); @@ -60,76 +56,68 @@ public void subscribe(Subscriber o) { // it's been played through once so now it will all be replays final CountDownLatch slowLatch = new CountDownLatch(1); - Thread slowThread = new Thread(new Runnable() { + Thread slowThread = new Thread(() -> { + Subscriber slow = new Observer() { - @Override - public void run() { - Subscriber slow = new Observer() { + @Override + public void onComplete() { + System.out.println("*** Slow Observer completed"); + slowLatch.countDown(); + } - @Override - public void onComplete() { - System.out.println("*** Slow Observer completed"); - slowLatch.countDown(); - } + @Override + public void onError(Throwable e) { + } - @Override - public void onError(Throwable e) { + @Override + public void onNext(Long args) { + if (args == 1) { + System.out.println("*** Slow Observer STARTED"); } - - @Override - public void onNext(Long args) { - if (args == 1) { - System.out.println("*** Slow Observer STARTED"); - } - try { - if (args % 10 == 0) { - Thread.sleep(1); - } - } catch (InterruptedException e) { - e.printStackTrace(); + try { + if (args % 10 == 0) { + Thread.sleep(1); } + } catch (InterruptedException e) { + e.printStackTrace(); } - }; - replay.subscribe(slow); - try { - slowLatch.await(); - } catch (InterruptedException e1) { - e1.printStackTrace(); } + }; + replay.subscribe(slow); + try { + slowLatch.await(); + } catch (InterruptedException e1) { + e1.printStackTrace(); } }); slowThread.start(); - Thread fastThread = new Thread(new Runnable() { - - @Override - public void run() { - final CountDownLatch fastLatch = new CountDownLatch(1); - Subscriber fast = new Observer() { + Thread fastThread = new Thread(() -> { + final CountDownLatch fastLatch = new CountDownLatch(1); + Subscriber fast = new Observer() { - @Override - public void onComplete() { - System.out.println("*** Fast Observer completed"); - fastLatch.countDown(); - } + @Override + public void onComplete() { + System.out.println("*** Fast Observer completed"); + fastLatch.countDown(); + } - @Override - public void onError(Throwable e) { - } + @Override + public void onError(Throwable e) { + } - @Override - public void onNext(Long args) { - if (args == 1) { - System.out.println("*** Fast Observer STARTED"); - } + @Override + public void onNext(Long args) { + if (args == 1) { + System.out.println("*** Fast Observer STARTED"); } - }; - replay.subscribe(fast); - try { - fastLatch.await(); - } catch (InterruptedException e1) { - e1.printStackTrace(); } + }; + replay.subscribe(fast); + try { + fastLatch.await(); + } catch (InterruptedException e1) { + e1.printStackTrace(); } }); fastThread.start(); @@ -144,28 +132,24 @@ public void onNext(Long args) { @Test public void testReplaySubjectConcurrentSubscriptions() throws InterruptedException { final ReplaySubject replay = ReplaySubject.create(); - Thread source = new Thread(new Runnable() { - - @Override - public void run() { - Observable.create(new Publisher() { + Thread source = new Thread(() -> { + Observable.create(new Publisher() { - @Override - public void subscribe(Subscriber o) { - System.out.println("********* Start Source Data ***********"); - for (long l = 1; l <= 10000; l++) { - o.onNext(l); - } - System.out.println("********* Finished Source Data ***********"); - o.onComplete(); + @Override + public void subscribe(Subscriber o) { + System.out.println("********* Start Source Data ***********"); + for (long l = 1; l <= 10000; l++) { + o.onNext(l); } - }).subscribe(replay); - } + System.out.println("********* Finished Source Data ***********"); + o.onComplete(); + } + }).subscribe(replay); }); // used to collect results of each thread - final List> listOfListsOfValues = Collections.synchronizedList(new ArrayList>()); - final List threads = Collections.synchronizedList(new ArrayList()); + final List> listOfListsOfValues = Collections.synchronizedList(new ArrayList<>()); + final List threads = Collections.synchronizedList(new ArrayList<>()); for (int i = 1; i <= 200; i++) { final int count = i; @@ -178,14 +162,10 @@ public void subscribe(Subscriber o) { // wait for source to finish then keep adding after it's done source.join(); } - Thread t = new Thread(new Runnable() { - - @Override - public void run() { - List values = replay.toList().toBlocking().last(); - listOfListsOfValues.add(values); - System.out.println("Finished thread: " + count); - } + Thread t = new Thread(() -> { + List values = replay.toList().toBlocking().last(); + listOfListsOfValues.add(values); + System.out.println("Finished thread: " + count); }); t.start(); System.out.println("Started thread: " + i); @@ -198,7 +178,7 @@ public void run() { } // assert all threads got the same results - List sums = new ArrayList(); + List sums = new ArrayList<>(); for (List values : listOfListsOfValues) { long v = 0; for (long l : values) { @@ -231,30 +211,21 @@ public void run() { public void testSubscribeCompletionRaceCondition() { for (int i = 0; i < 50; i++) { final ReplaySubject subject = ReplaySubject.create(); - final AtomicReference value1 = new AtomicReference(); - - subject.subscribe(new Consumer() { + final AtomicReference value1 = new AtomicReference<>(); - @Override - public void accept(String t1) { - try { - // simulate a slow observer - Thread.sleep(50); - } catch (InterruptedException e) { - e.printStackTrace(); - } - value1.set(t1); + subject.subscribe(t1 -> { + try { + // simulate a slow observer + Thread.sleep(50); + } catch (InterruptedException e) { + e.printStackTrace(); } - + value1.set(t1); }); - Thread t1 = new Thread(new Runnable() { - - @Override - public void run() { - subject.onNext("value"); - subject.onComplete(); - } + Thread t1 = new Thread(() -> { + subject.onNext("value"); + subject.onComplete(); }); SubjectObserverThread t2 = new SubjectObserverThread(subject); @@ -293,7 +264,7 @@ public void run() { public void testRaceForTerminalState() { final List expected = Arrays.asList(1); for (int i = 0; i < 100000; i++) { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.just(1).subscribeOn(Schedulers.computation()).cache().subscribe(ts); ts.awaitTerminalEvent(); ts.assertValueSequence(expected); @@ -304,7 +275,7 @@ public void testRaceForTerminalState() { private static class SubjectObserverThread extends Thread { private final ReplaySubject subject; - private final AtomicReference value = new AtomicReference(); + private final AtomicReference value = new AtomicReference<>(); public SubjectObserverThread(ReplaySubject subject) { this.subject = subject; @@ -335,19 +306,16 @@ public void testReplaySubjectEmissionSubscriptionRace() throws Exception { final CountDownLatch finish = new CountDownLatch(1); final CountDownLatch start = new CountDownLatch(1); - worker.schedule(new Runnable() { - @Override - public void run() { - try { - start.await(); - } catch (Exception e1) { - e1.printStackTrace(); - } - rs.onNext(1); + worker.schedule(() -> { + try { + start.await(); + } catch (Exception e1) { + e1.printStackTrace(); } + rs.onNext(1); }); - final AtomicReference o = new AtomicReference(); + final AtomicReference o = new AtomicReference<>(); rs.subscribeOn(s).observeOn(Schedulers.io()) .subscribe(new Observer() { @@ -381,12 +349,7 @@ public void onNext(Object t) { break; } else { Assert.assertEquals(1, o.get()); - worker.schedule(new Runnable() { - @Override - public void run() { - rs.onComplete(); - } - }); + worker.schedule(() -> rs.onComplete()); } } @@ -399,22 +362,19 @@ public void testConcurrentSizeAndHasAnyValue() throws InterruptedException { final ReplaySubject rs = ReplaySubject.create(); final CyclicBarrier cb = new CyclicBarrier(2); - Thread t = new Thread(new Runnable() { - @Override - public void run() { - try { - cb.await(); - } catch (InterruptedException e) { - return; - } catch (BrokenBarrierException e) { - return; - } - for (int i = 0; i < 1000000; i++) { - rs.onNext(i); - } - rs.onComplete(); - System.out.println("Replay fill Thread finished!"); + Thread t = new Thread(() -> { + try { + cb.await(); + } catch (InterruptedException e) { + return; + } catch (BrokenBarrierException e) { + return; + } + for (int i = 0; i < 1000000; i++) { + rs.onNext(i); } + rs.onComplete(); + System.out.println("Replay fill Thread finished!"); }); t.start(); try { diff --git a/src/test/java/io/reactivex/subjects/ReplaySubjectTest.java b/rxjava/src/test/java/io/reactivex/subjects/ReplaySubjectTest.java similarity index 97% rename from src/test/java/io/reactivex/subjects/ReplaySubjectTest.java rename to rxjava/src/test/java/io/reactivex/subjects/ReplaySubjectTest.java index c57ac99509..c8a1c7f848 100644 --- a/src/test/java/io/reactivex/subjects/ReplaySubjectTest.java +++ b/rxjava/src/test/java/io/reactivex/subjects/ReplaySubjectTest.java @@ -68,7 +68,7 @@ public void testCompletedStopsEmittingData() { Subscriber observerB = TestHelper.mockSubscriber(); Subscriber observerC = TestHelper.mockSubscriber(); Subscriber observerD = TestHelper.mockSubscriber(); - TestSubscriber ts = new TestSubscriber(observerA); + TestSubscriber ts = new TestSubscriber<>(observerA); channel.subscribe(ts); channel.subscribe(observerB); @@ -219,7 +219,7 @@ public void testUnsubscribeFirstSubscriber() { ReplaySubject subject = ReplaySubject.create(); Subscriber observer = TestHelper.mockSubscriber(); - TestSubscriber ts = new TestSubscriber(observer); + TestSubscriber ts = new TestSubscriber<>(observer); subject.subscribe(ts); subject.onNext("one"); @@ -250,7 +250,7 @@ private void assertObservedUntilTwo(Subscriber observer) { @Test(timeout = 2000) public void testNewSubscriberDoesntBlockExisting() throws InterruptedException { - final AtomicReference lastValueForSubscriber1 = new AtomicReference(); + final AtomicReference lastValueForSubscriber1 = new AtomicReference<>(); Subscriber observer1 = new Observer() { @Override @@ -271,7 +271,7 @@ public void onNext(String v) { }; - final AtomicReference lastValueForSubscriber2 = new AtomicReference(); + final AtomicReference lastValueForSubscriber2 = new AtomicReference<>(); final CountDownLatch oneReceived = new CountDownLatch(1); final CountDownLatch makeSlow = new CountDownLatch(1); final CountDownLatch completed = new CountDownLatch(1); @@ -367,13 +367,7 @@ public void testUnsubscriptionCase() { src.onNext(v); System.out.printf("Turn: %d%n", i); src.first() - .flatMap(new Function>() { - - @Override - public Observable apply(String t1) { - return Observable.just(t1 + ", " + t1); - } - }) + .flatMap(t1 -> Observable.just(t1 + ", " + t1)) .subscribe(new Observer() { @Override public void onNext(String t) { @@ -830,7 +824,7 @@ public void testBackpressureHonored() { rs.onNext(3); rs.onComplete(); - TestSubscriber ts = new TestSubscriber((Long)null); + TestSubscriber ts = new TestSubscriber<>((Long) null); rs.subscribe(ts); @@ -859,7 +853,7 @@ public void testBackpressureHonoredSizeBound() { rs.onNext(3); rs.onComplete(); - TestSubscriber ts = new TestSubscriber((Long)null); + TestSubscriber ts = new TestSubscriber<>((Long) null); rs.subscribe(ts); @@ -888,7 +882,7 @@ public void testBackpressureHonoredTimeBound() { rs.onNext(3); rs.onComplete(); - TestSubscriber ts = new TestSubscriber((Long)null); + TestSubscriber ts = new TestSubscriber<>((Long) null); rs.subscribe(ts); diff --git a/src/test/java/io/reactivex/subjects/SerializedSubjectTest.java b/rxjava/src/test/java/io/reactivex/subjects/SerializedSubjectTest.java similarity index 99% rename from src/test/java/io/reactivex/subjects/SerializedSubjectTest.java rename to rxjava/src/test/java/io/reactivex/subjects/SerializedSubjectTest.java index 9e45fadc8a..f0224b790b 100644 --- a/src/test/java/io/reactivex/subjects/SerializedSubjectTest.java +++ b/rxjava/src/test/java/io/reactivex/subjects/SerializedSubjectTest.java @@ -24,8 +24,8 @@ public class SerializedSubjectTest { @Test public void testBasic() { - SerializedSubject subject = new SerializedSubject(PublishSubject. create()); - TestSubscriber ts = new TestSubscriber(); + SerializedSubject subject = new SerializedSubject<>(PublishSubject.create()); + TestSubscriber ts = new TestSubscriber<>(); subject.subscribe(ts); subject.onNext("hello"); subject.onComplete(); diff --git a/src/test/java/io/reactivex/subjects/nbp/NbpAsyncSubjectTest.java b/rxjava/src/test/java/io/reactivex/subjects/nbp/NbpAsyncSubjectTest.java similarity index 94% rename from src/test/java/io/reactivex/subjects/nbp/NbpAsyncSubjectTest.java rename to rxjava/src/test/java/io/reactivex/subjects/nbp/NbpAsyncSubjectTest.java index c39c56cc3e..f0131f0d25 100644 --- a/src/test/java/io/reactivex/subjects/nbp/NbpAsyncSubjectTest.java +++ b/rxjava/src/test/java/io/reactivex/subjects/nbp/NbpAsyncSubjectTest.java @@ -146,7 +146,7 @@ public void testUnsubscribeBeforeCompleted() { NbpAsyncSubject subject = NbpAsyncSubject.create(); NbpSubscriber observer = TestHelper.mockNbpSubscriber(); - NbpTestSubscriber ts = new NbpTestSubscriber(observer); + NbpTestSubscriber ts = new NbpTestSubscriber<>(observer); subject.subscribe(ts); subject.onNext("one"); @@ -195,30 +195,21 @@ public void testSubscribeCompletionRaceCondition() { */ for (int i = 0; i < 50; i++) { final NbpAsyncSubject subject = NbpAsyncSubject.create(); - final AtomicReference value1 = new AtomicReference(); - - subject.subscribe(new Consumer() { - - @Override - public void accept(String t1) { - try { - // simulate a slow observer - Thread.sleep(50); - } catch (InterruptedException e) { - e.printStackTrace(); - } - value1.set(t1); + final AtomicReference value1 = new AtomicReference<>(); + + subject.subscribe(t1 -> { + try { + // simulate a slow observer + Thread.sleep(50); + } catch (InterruptedException e) { + e.printStackTrace(); } - + value1.set(t1); }); - Thread t1 = new Thread(new Runnable() { - - @Override - public void run() { - subject.onNext("value"); - subject.onComplete(); - } + Thread t1 = new Thread(() -> { + subject.onNext("value"); + subject.onComplete(); }); SubjectSubscriberThread t2 = new SubjectSubscriberThread(subject); @@ -253,7 +244,7 @@ public void run() { private static class SubjectSubscriberThread extends Thread { private final NbpAsyncSubject subject; - private final AtomicReference value = new AtomicReference(); + private final AtomicReference value = new AtomicReference<>(); public SubjectSubscriberThread(NbpAsyncSubject subject) { this.subject = subject; diff --git a/src/test/java/io/reactivex/subjects/nbp/NbpBehaviorSubjectTest.java b/rxjava/src/test/java/io/reactivex/subjects/nbp/NbpBehaviorSubjectTest.java similarity index 94% rename from src/test/java/io/reactivex/subjects/nbp/NbpBehaviorSubjectTest.java rename to rxjava/src/test/java/io/reactivex/subjects/nbp/NbpBehaviorSubjectTest.java index 5aa64e0b85..2c04871080 100644 --- a/src/test/java/io/reactivex/subjects/nbp/NbpBehaviorSubjectTest.java +++ b/rxjava/src/test/java/io/reactivex/subjects/nbp/NbpBehaviorSubjectTest.java @@ -128,7 +128,7 @@ public void testCompletedStopsEmittingData() { NbpSubscriber observerB = TestHelper.mockNbpSubscriber(); NbpSubscriber observerC = TestHelper.mockNbpSubscriber(); - NbpTestSubscriber ts = new NbpTestSubscriber(observerA); + NbpTestSubscriber ts = new NbpTestSubscriber<>(observerA); channel.subscribe(ts); channel.subscribe(observerB); @@ -246,13 +246,7 @@ public void testUnsubscriptionCase() { src.onNext(v); System.out.printf("Turn: %d%n", i); src.first() - .flatMap(new Function>() { - - @Override - public NbpObservable apply(String t1) { - return NbpObservable.just(t1 + ", " + t1); - } - }) + .flatMap(t1 -> NbpObservable.just(t1 + ", " + t1)) .subscribe(new NbpObserver() { @Override public void onNext(String t) { @@ -412,19 +406,16 @@ public void testEmissionSubscriptionRace() throws Exception { final CountDownLatch finish = new CountDownLatch(1); final CountDownLatch start = new CountDownLatch(1); - worker.schedule(new Runnable() { - @Override - public void run() { - try { - start.await(); - } catch (Exception e1) { - e1.printStackTrace(); - } - rs.onNext(1); + worker.schedule(() -> { + try { + start.await(); + } catch (Exception e1) { + e1.printStackTrace(); } + rs.onNext(1); }); - final AtomicReference o = new AtomicReference(); + final AtomicReference o = new AtomicReference<>(); rs.subscribeOn(s).observeOn(Schedulers.io()) .subscribe(new NbpObserver() { @@ -458,12 +449,7 @@ public void onNext(Object t) { break; } else { Assert.assertEquals(1, o.get()); - worker.schedule(new Runnable() { - @Override - public void run() { - rs.onComplete(); - } - }); + worker.schedule(rs::onComplete); } } } finally { @@ -500,7 +486,7 @@ public void testCurrentStateMethodsNormalEmptyStart() { @Test public void testCurrentStateMethodsNormalSomeStart() { - NbpBehaviorSubject as = NbpBehaviorSubject.createDefault((Object)1); + NbpBehaviorSubject as = NbpBehaviorSubject.createDefault(1); assertTrue(as.hasValue()); assertFalse(as.hasThrowable()); diff --git a/src/test/java/io/reactivex/subjects/nbp/NbpPublishSubjectTest.java b/rxjava/src/test/java/io/reactivex/subjects/nbp/NbpPublishSubjectTest.java similarity index 89% rename from src/test/java/io/reactivex/subjects/nbp/NbpPublishSubjectTest.java rename to rxjava/src/test/java/io/reactivex/subjects/nbp/NbpPublishSubjectTest.java index 69e0d4b2e8..cfe0002037 100644 --- a/src/test/java/io/reactivex/subjects/nbp/NbpPublishSubjectTest.java +++ b/rxjava/src/test/java/io/reactivex/subjects/nbp/NbpPublishSubjectTest.java @@ -63,7 +63,7 @@ public void testCompletedStopsEmittingData() { NbpSubscriber observerB = TestHelper.mockNbpSubscriber(); NbpSubscriber observerC = TestHelper.mockNbpSubscriber(); - NbpTestSubscriber ts = new NbpTestSubscriber(observerA); + NbpTestSubscriber ts = new NbpTestSubscriber<>(observerA); channel.subscribe(ts); channel.subscribe(observerB); @@ -172,7 +172,7 @@ public void testUnsubscribeFirstSubscriber() { NbpPublishSubject subject = NbpPublishSubject.create(); NbpSubscriber observer = TestHelper.mockNbpSubscriber(); - NbpTestSubscriber ts = new NbpTestSubscriber(observer); + NbpTestSubscriber ts = new NbpTestSubscriber<>(observer); subject.subscribe(ts); subject.onNext("one"); @@ -207,34 +207,19 @@ public void testNestedSubscribe() { final AtomicInteger countChildren = new AtomicInteger(); final AtomicInteger countTotal = new AtomicInteger(); - final ArrayList list = new ArrayList(); + final ArrayList list = new ArrayList<>(); - s.flatMap(new Function>() { - - @Override - public NbpObservable apply(final Integer v) { - countParent.incrementAndGet(); - - // then subscribe to subject again (it will not receive the previous value) - return s.map(new Function() { - - @Override - public String apply(Integer v2) { - countChildren.incrementAndGet(); - return "Parent: " + v + " Child: " + v2; - } - - }); - } - - }).subscribe(new Consumer() { - - @Override - public void accept(String v) { - countTotal.incrementAndGet(); - list.add(v); - } + s.flatMap(v -> { + countParent.incrementAndGet(); + // then subscribe to subject again (it will not receive the previous value) + return s.map(v2 -> { + countChildren.incrementAndGet(); + return "Parent: " + v + " Child: " + v2; + }); + }).subscribe(v -> { + countTotal.incrementAndGet(); + list.add(v); }); for (int i = 0; i < 10; i++) { @@ -258,7 +243,7 @@ public void testReSubscribe() { final NbpPublishSubject ps = NbpPublishSubject.create(); NbpSubscriber o1 = TestHelper.mockNbpSubscriber(); - NbpTestSubscriber ts = new NbpTestSubscriber(o1); + NbpTestSubscriber ts = new NbpTestSubscriber<>(o1); ps.subscribe(ts); // emit @@ -276,7 +261,7 @@ public void testReSubscribe() { ps.onNext(2); NbpSubscriber o2 = TestHelper.mockNbpSubscriber(); - NbpTestSubscriber ts2 = new NbpTestSubscriber(o2); + NbpTestSubscriber ts2 = new NbpTestSubscriber<>(o2); ps.subscribe(ts2); // emit @@ -302,13 +287,7 @@ public void testUnsubscriptionCase() { String v = "" + i; System.out.printf("Turn: %d%n", i); src.first() - .flatMap(new Function>() { - - @Override - public NbpObservable apply(String t1) { - return NbpObservable.just(t1 + ", " + t1); - } - }) + .flatMap(t1 -> NbpObservable.just(t1 + ", " + t1)) .subscribe(new NbpObserver() { @Override public void onNext(String t) { diff --git a/src/test/java/io/reactivex/subjects/nbp/NbpReplaySubjectBoundedConcurrencyTest.java b/rxjava/src/test/java/io/reactivex/subjects/nbp/NbpReplaySubjectBoundedConcurrencyTest.java similarity index 65% rename from src/test/java/io/reactivex/subjects/nbp/NbpReplaySubjectBoundedConcurrencyTest.java rename to rxjava/src/test/java/io/reactivex/subjects/nbp/NbpReplaySubjectBoundedConcurrencyTest.java index 287c19851f..a1d46099ff 100644 --- a/src/test/java/io/reactivex/subjects/nbp/NbpReplaySubjectBoundedConcurrencyTest.java +++ b/rxjava/src/test/java/io/reactivex/subjects/nbp/NbpReplaySubjectBoundedConcurrencyTest.java @@ -34,24 +34,20 @@ public class NbpReplaySubjectBoundedConcurrencyTest { @Test(timeout = 4000) public void testReplaySubjectConcurrentSubscribersDoingReplayDontBlockEachOther() throws InterruptedException { final NbpReplaySubject replay = NbpReplaySubject.createUnbounded(); - Thread source = new Thread(new Runnable() { + Thread source = new Thread(() -> { + NbpObservable.create(new NbpOnSubscribe() { - @Override - public void run() { - NbpObservable.create(new NbpOnSubscribe() { - - @Override - public void accept(NbpSubscriber o) { - o.onSubscribe(EmptyDisposable.INSTANCE); - System.out.println("********* Start Source Data ***********"); - for (long l = 1; l <= 10000; l++) { - o.onNext(l); - } - System.out.println("********* Finished Source Data ***********"); - o.onComplete(); + @Override + public void accept(NbpSubscriber o) { + o.onSubscribe(EmptyDisposable.INSTANCE); + System.out.println("********* Start Source Data ***********"); + for (long l = 1; l <= 10000; l++) { + o.onNext(l); } - }).subscribe(replay); - } + System.out.println("********* Finished Source Data ***********"); + o.onComplete(); + } + }).subscribe(replay); }); source.start(); @@ -60,76 +56,68 @@ public void accept(NbpSubscriber o) { // it's been played through once so now it will all be replays final CountDownLatch slowLatch = new CountDownLatch(1); - Thread slowThread = new Thread(new Runnable() { + Thread slowThread = new Thread(() -> { + NbpSubscriber slow = new NbpObserver() { - @Override - public void run() { - NbpSubscriber slow = new NbpObserver() { + @Override + public void onComplete() { + System.out.println("*** Slow Observer completed"); + slowLatch.countDown(); + } - @Override - public void onComplete() { - System.out.println("*** Slow Observer completed"); - slowLatch.countDown(); - } + @Override + public void onError(Throwable e) { + } - @Override - public void onError(Throwable e) { + @Override + public void onNext(Long args) { + if (args == 1) { + System.out.println("*** Slow Observer STARTED"); } - - @Override - public void onNext(Long args) { - if (args == 1) { - System.out.println("*** Slow Observer STARTED"); - } - try { - if (args % 10 == 0) { - Thread.sleep(1); - } - } catch (InterruptedException e) { - e.printStackTrace(); + try { + if (args % 10 == 0) { + Thread.sleep(1); } + } catch (InterruptedException e) { + e.printStackTrace(); } - }; - replay.subscribe(slow); - try { - slowLatch.await(); - } catch (InterruptedException e1) { - e1.printStackTrace(); } + }; + replay.subscribe(slow); + try { + slowLatch.await(); + } catch (InterruptedException e1) { + e1.printStackTrace(); } }); slowThread.start(); - Thread fastThread = new Thread(new Runnable() { - - @Override - public void run() { - final CountDownLatch fastLatch = new CountDownLatch(1); - NbpSubscriber fast = new NbpObserver() { + Thread fastThread = new Thread(() -> { + final CountDownLatch fastLatch = new CountDownLatch(1); + NbpSubscriber fast = new NbpObserver() { - @Override - public void onComplete() { - System.out.println("*** Fast Observer completed"); - fastLatch.countDown(); - } + @Override + public void onComplete() { + System.out.println("*** Fast Observer completed"); + fastLatch.countDown(); + } - @Override - public void onError(Throwable e) { - } + @Override + public void onError(Throwable e) { + } - @Override - public void onNext(Long args) { - if (args == 1) { - System.out.println("*** Fast Observer STARTED"); - } + @Override + public void onNext(Long args) { + if (args == 1) { + System.out.println("*** Fast Observer STARTED"); } - }; - replay.subscribe(fast); - try { - fastLatch.await(); - } catch (InterruptedException e1) { - e1.printStackTrace(); } + }; + replay.subscribe(fast); + try { + fastLatch.await(); + } catch (InterruptedException e1) { + e1.printStackTrace(); } }); fastThread.start(); @@ -144,29 +132,25 @@ public void onNext(Long args) { @Test public void testReplaySubjectConcurrentSubscriptions() throws InterruptedException { final NbpReplaySubject replay = NbpReplaySubject.createUnbounded(); - Thread source = new Thread(new Runnable() { + Thread source = new Thread(() -> { + NbpObservable.create(new NbpOnSubscribe() { - @Override - public void run() { - NbpObservable.create(new NbpOnSubscribe() { - - @Override - public void accept(NbpSubscriber o) { - o.onSubscribe(EmptyDisposable.INSTANCE); - System.out.println("********* Start Source Data ***********"); - for (long l = 1; l <= 10000; l++) { - o.onNext(l); - } - System.out.println("********* Finished Source Data ***********"); - o.onComplete(); + @Override + public void accept(NbpSubscriber o) { + o.onSubscribe(EmptyDisposable.INSTANCE); + System.out.println("********* Start Source Data ***********"); + for (long l = 1; l <= 10000; l++) { + o.onNext(l); } - }).subscribe(replay); - } + System.out.println("********* Finished Source Data ***********"); + o.onComplete(); + } + }).subscribe(replay); }); // used to collect results of each thread - final List> listOfListsOfValues = Collections.synchronizedList(new ArrayList>()); - final List threads = Collections.synchronizedList(new ArrayList()); + final List> listOfListsOfValues = Collections.synchronizedList(new ArrayList<>()); + final List threads = Collections.synchronizedList(new ArrayList<>()); for (int i = 1; i <= 200; i++) { final int count = i; @@ -179,14 +163,10 @@ public void accept(NbpSubscriber o) { // wait for source to finish then keep adding after it's done source.join(); } - Thread t = new Thread(new Runnable() { - - @Override - public void run() { - List values = replay.toList().toBlocking().last(); - listOfListsOfValues.add(values); - System.out.println("Finished thread: " + count); - } + Thread t = new Thread(() -> { + List values = replay.toList().toBlocking().last(); + listOfListsOfValues.add(values); + System.out.println("Finished thread: " + count); }); t.start(); System.out.println("Started thread: " + i); @@ -199,7 +179,7 @@ public void run() { } // assert all threads got the same results - List sums = new ArrayList(); + List sums = new ArrayList<>(); for (List values : listOfListsOfValues) { long v = 0; for (long l : values) { @@ -232,30 +212,21 @@ public void run() { public void testSubscribeCompletionRaceCondition() { for (int i = 0; i < 50; i++) { final NbpReplaySubject subject = NbpReplaySubject.createUnbounded(); - final AtomicReference value1 = new AtomicReference(); - - subject.subscribe(new Consumer() { + final AtomicReference value1 = new AtomicReference<>(); - @Override - public void accept(String t1) { - try { - // simulate a slow observer - Thread.sleep(50); - } catch (InterruptedException e) { - e.printStackTrace(); - } - value1.set(t1); + subject.subscribe(t1 -> { + try { + // simulate a slow observer + Thread.sleep(50); + } catch (InterruptedException e) { + e.printStackTrace(); } - + value1.set(t1); }); - Thread t1 = new Thread(new Runnable() { - - @Override - public void run() { - subject.onNext("value"); - subject.onComplete(); - } + Thread t1 = new Thread(() -> { + subject.onNext("value"); + subject.onComplete(); }); SubjectObserverThread t2 = new SubjectObserverThread(subject); @@ -294,7 +265,7 @@ public void run() { public void testRaceForTerminalState() { final List expected = Arrays.asList(1); for (int i = 0; i < 100000; i++) { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpObservable.just(1).subscribeOn(Schedulers.computation()).cache().subscribe(ts); ts.awaitTerminalEvent(); ts.assertValueSequence(expected); @@ -305,7 +276,7 @@ public void testRaceForTerminalState() { private static class SubjectObserverThread extends Thread { private final NbpReplaySubject subject; - private final AtomicReference value = new AtomicReference(); + private final AtomicReference value = new AtomicReference<>(); public SubjectObserverThread(NbpReplaySubject subject) { this.subject = subject; @@ -338,20 +309,17 @@ public void testReplaySubjectEmissionSubscriptionRace() throws Exception { // int j = i; - worker.schedule(new Runnable() { - @Override - public void run() { - try { - start.await(); - } catch (Exception e1) { - e1.printStackTrace(); - } -// System.out.println("> " + j); - rs.onNext(1); + worker.schedule(() -> { + try { + start.await(); + } catch (Exception e1) { + e1.printStackTrace(); } +// System.out.println("> " + j); + rs.onNext(1); }); - final AtomicReference o = new AtomicReference(); + final AtomicReference o = new AtomicReference<>(); rs // .doOnSubscribe(v -> System.out.println("!! " + j)) @@ -395,12 +363,7 @@ public void onNext(Object t) { break; } else { Assert.assertEquals(1, o.get()); - worker.schedule(new Runnable() { - @Override - public void run() { - rs.onComplete(); - } - }); + worker.schedule(() -> rs.onComplete()); } } } finally { @@ -412,22 +375,19 @@ public void testConcurrentSizeAndHasAnyValue() throws InterruptedException { final NbpReplaySubject rs = NbpReplaySubject.createUnbounded(); final CyclicBarrier cb = new CyclicBarrier(2); - Thread t = new Thread(new Runnable() { - @Override - public void run() { - try { - cb.await(); - } catch (InterruptedException e) { - return; - } catch (BrokenBarrierException e) { - return; - } - for (int i = 0; i < 1000000; i++) { - rs.onNext(i); - } - rs.onComplete(); - System.out.println("Replay fill Thread finished!"); + Thread t = new Thread(() -> { + try { + cb.await(); + } catch (InterruptedException e) { + return; + } catch (BrokenBarrierException e) { + return; + } + for (int i = 0; i < 1000000; i++) { + rs.onNext(i); } + rs.onComplete(); + System.out.println("Replay fill Thread finished!"); }); t.start(); try { @@ -466,22 +426,19 @@ public void testConcurrentSizeAndHasAnyValueBounded() throws InterruptedExceptio final NbpReplaySubject rs = NbpReplaySubject.createWithSize(3); final CyclicBarrier cb = new CyclicBarrier(2); - Thread t = new Thread(new Runnable() { - @Override - public void run() { - try { - cb.await(); - } catch (InterruptedException e) { - return; - } catch (BrokenBarrierException e) { - return; - } - for (int i = 0; i < 1000000; i++) { - rs.onNext(i); - } - rs.onComplete(); - System.out.println("Replay fill Thread finished!"); + Thread t = new Thread(() -> { + try { + cb.await(); + } catch (InterruptedException e) { + return; + } catch (BrokenBarrierException e) { + return; } + for (int i = 0; i < 1000000; i++) { + rs.onNext(i); + } + rs.onComplete(); + System.out.println("Replay fill Thread finished!"); }); t.start(); try { @@ -509,29 +466,26 @@ public void testConcurrentSizeAndHasAnyValueTimeBounded() throws InterruptedExce final NbpReplaySubject rs = NbpReplaySubject.createWithTime(1, TimeUnit.MILLISECONDS, Schedulers.computation()); final CyclicBarrier cb = new CyclicBarrier(2); - Thread t = new Thread(new Runnable() { - @Override - public void run() { - try { - cb.await(); - } catch (InterruptedException e) { - return; - } catch (BrokenBarrierException e) { - return; - } - for (int i = 0; i < 1000000; i++) { - rs.onNext(i); - if (i % 10000 == 0) { - try { - Thread.sleep(1); - } catch (InterruptedException e) { - return; - } + Thread t = new Thread(() -> { + try { + cb.await(); + } catch (InterruptedException e) { + return; + } catch (BrokenBarrierException e) { + return; + } + for (int i = 0; i < 1000000; i++) { + rs.onNext(i); + if (i % 10000 == 0) { + try { + Thread.sleep(1); + } catch (InterruptedException e) { + return; } } - rs.onComplete(); - System.out.println("Replay fill Thread finished!"); } + rs.onComplete(); + System.out.println("Replay fill Thread finished!"); }); t.start(); try { diff --git a/src/test/java/io/reactivex/subjects/nbp/NbpReplaySubjectConcurrencyTest.java b/rxjava/src/test/java/io/reactivex/subjects/nbp/NbpReplaySubjectConcurrencyTest.java similarity index 63% rename from src/test/java/io/reactivex/subjects/nbp/NbpReplaySubjectConcurrencyTest.java rename to rxjava/src/test/java/io/reactivex/subjects/nbp/NbpReplaySubjectConcurrencyTest.java index 150e4a9371..9d524317d0 100644 --- a/src/test/java/io/reactivex/subjects/nbp/NbpReplaySubjectConcurrencyTest.java +++ b/rxjava/src/test/java/io/reactivex/subjects/nbp/NbpReplaySubjectConcurrencyTest.java @@ -34,24 +34,16 @@ public class NbpReplaySubjectConcurrencyTest { @Test(timeout = 4000) public void testNbpReplaySubjectConcurrentSubscribersDoingReplayDontBlockEachOther() throws InterruptedException { final NbpReplaySubject replay = NbpReplaySubject.create(); - Thread source = new Thread(new Runnable() { - - @Override - public void run() { - NbpObservable.create(new NbpOnSubscribe() { - - @Override - public void accept(NbpSubscriber o) { - o.onSubscribe(EmptyDisposable.INSTANCE); - System.out.println("********* Start Source Data ***********"); - for (long l = 1; l <= 10000; l++) { - o.onNext(l); - } - System.out.println("********* Finished Source Data ***********"); - o.onComplete(); - } - }).subscribe(replay); - } + Thread source = new Thread(() -> { + NbpObservable.create(o -> { + o.onSubscribe(EmptyDisposable.INSTANCE); + System.out.println("********* Start Source Data ***********"); + for (long l = 1; l <= 10000; l++) { + o.onNext(l); + } + System.out.println("********* Finished Source Data ***********"); + o.onComplete(); + }).subscribe(replay); }); source.start(); @@ -60,76 +52,68 @@ public void accept(NbpSubscriber o) { // it's been played through once so now it will all be replays final CountDownLatch slowLatch = new CountDownLatch(1); - Thread slowThread = new Thread(new Runnable() { + Thread slowThread = new Thread(() -> { + NbpSubscriber slow = new NbpObserver() { - @Override - public void run() { - NbpSubscriber slow = new NbpObserver() { + @Override + public void onComplete() { + System.out.println("*** Slow Observer completed"); + slowLatch.countDown(); + } - @Override - public void onComplete() { - System.out.println("*** Slow Observer completed"); - slowLatch.countDown(); - } + @Override + public void onError(Throwable e) { + } - @Override - public void onError(Throwable e) { + @Override + public void onNext(Long args) { + if (args == 1) { + System.out.println("*** Slow Observer STARTED"); } - - @Override - public void onNext(Long args) { - if (args == 1) { - System.out.println("*** Slow Observer STARTED"); - } - try { - if (args % 10 == 0) { - Thread.sleep(1); - } - } catch (InterruptedException e) { - e.printStackTrace(); + try { + if (args % 10 == 0) { + Thread.sleep(1); } + } catch (InterruptedException e) { + e.printStackTrace(); } - }; - replay.subscribe(slow); - try { - slowLatch.await(); - } catch (InterruptedException e1) { - e1.printStackTrace(); } + }; + replay.subscribe(slow); + try { + slowLatch.await(); + } catch (InterruptedException e1) { + e1.printStackTrace(); } }); slowThread.start(); - Thread fastThread = new Thread(new Runnable() { - - @Override - public void run() { - final CountDownLatch fastLatch = new CountDownLatch(1); - NbpSubscriber fast = new NbpObserver() { + Thread fastThread = new Thread(() -> { + final CountDownLatch fastLatch = new CountDownLatch(1); + NbpSubscriber fast = new NbpObserver() { - @Override - public void onComplete() { - System.out.println("*** Fast Observer completed"); - fastLatch.countDown(); - } + @Override + public void onComplete() { + System.out.println("*** Fast Observer completed"); + fastLatch.countDown(); + } - @Override - public void onError(Throwable e) { - } + @Override + public void onError(Throwable e) { + } - @Override - public void onNext(Long args) { - if (args == 1) { - System.out.println("*** Fast Observer STARTED"); - } + @Override + public void onNext(Long args) { + if (args == 1) { + System.out.println("*** Fast Observer STARTED"); } - }; - replay.subscribe(fast); - try { - fastLatch.await(); - } catch (InterruptedException e1) { - e1.printStackTrace(); } + }; + replay.subscribe(fast); + try { + fastLatch.await(); + } catch (InterruptedException e1) { + e1.printStackTrace(); } }); fastThread.start(); @@ -144,29 +128,21 @@ public void onNext(Long args) { @Test public void testNbpReplaySubjectConcurrentSubscriptions() throws InterruptedException { final NbpReplaySubject replay = NbpReplaySubject.create(); - Thread source = new Thread(new Runnable() { - - @Override - public void run() { - NbpObservable.create(new NbpOnSubscribe() { - - @Override - public void accept(NbpSubscriber o) { - o.onSubscribe(EmptyDisposable.INSTANCE); - System.out.println("********* Start Source Data ***********"); - for (long l = 1; l <= 10000; l++) { - o.onNext(l); - } - System.out.println("********* Finished Source Data ***********"); - o.onComplete(); - } - }).subscribe(replay); - } + Thread source = new Thread(() -> { + NbpObservable.create(o -> { + o.onSubscribe(EmptyDisposable.INSTANCE); + System.out.println("********* Start Source Data ***********"); + for (long l = 1; l <= 10000; l++) { + o.onNext(l); + } + System.out.println("********* Finished Source Data ***********"); + o.onComplete(); + }).subscribe(replay); }); // used to collect results of each thread - final List> listOfListsOfValues = Collections.synchronizedList(new ArrayList>()); - final List threads = Collections.synchronizedList(new ArrayList()); + final List> listOfListsOfValues = Collections.synchronizedList(new ArrayList<>()); + final List threads = Collections.synchronizedList(new ArrayList<>()); for (int i = 1; i <= 200; i++) { final int count = i; @@ -179,14 +155,10 @@ public void accept(NbpSubscriber o) { // wait for source to finish then keep adding after it's done source.join(); } - Thread t = new Thread(new Runnable() { - - @Override - public void run() { - List values = replay.toList().toBlocking().last(); - listOfListsOfValues.add(values); - System.out.println("Finished thread: " + count); - } + Thread t = new Thread(() -> { + List values = replay.toList().toBlocking().last(); + listOfListsOfValues.add(values); + System.out.println("Finished thread: " + count); }); t.start(); System.out.println("Started thread: " + i); @@ -199,7 +171,7 @@ public void run() { } // assert all threads got the same results - List sums = new ArrayList(); + List sums = new ArrayList<>(); for (List values : listOfListsOfValues) { long v = 0; for (long l : values) { @@ -232,30 +204,21 @@ public void run() { public void testSubscribeCompletionRaceCondition() { for (int i = 0; i < 50; i++) { final NbpReplaySubject subject = NbpReplaySubject.create(); - final AtomicReference value1 = new AtomicReference(); - - subject.subscribe(new Consumer() { + final AtomicReference value1 = new AtomicReference<>(); - @Override - public void accept(String t1) { - try { - // simulate a slow observer - Thread.sleep(50); - } catch (InterruptedException e) { - e.printStackTrace(); - } - value1.set(t1); + subject.subscribe(t1 -> { + try { + // simulate a slow observer + Thread.sleep(50); + } catch (InterruptedException e) { + e.printStackTrace(); } - + value1.set(t1); }); - Thread t1 = new Thread(new Runnable() { - - @Override - public void run() { - subject.onNext("value"); - subject.onComplete(); - } + Thread t1 = new Thread(() -> { + subject.onNext("value"); + subject.onComplete(); }); SubjectObserverThread t2 = new SubjectObserverThread(subject); @@ -294,7 +257,7 @@ public void run() { public void testRaceForTerminalState() { final List expected = Arrays.asList(1); for (int i = 0; i < 100000; i++) { - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); NbpObservable.just(1).subscribeOn(Schedulers.computation()).cache().subscribe(ts); ts.awaitTerminalEvent(); ts.assertValueSequence(expected); @@ -305,7 +268,7 @@ public void testRaceForTerminalState() { private static class SubjectObserverThread extends Thread { private final NbpReplaySubject subject; - private final AtomicReference value = new AtomicReference(); + private final AtomicReference value = new AtomicReference<>(); public SubjectObserverThread(NbpReplaySubject subject) { this.subject = subject; @@ -336,19 +299,16 @@ public void testNbpReplaySubjectEmissionSubscriptionRace() throws Exception { final CountDownLatch finish = new CountDownLatch(1); final CountDownLatch start = new CountDownLatch(1); - worker.schedule(new Runnable() { - @Override - public void run() { - try { - start.await(); - } catch (Exception e1) { - e1.printStackTrace(); - } - rs.onNext(1); + worker.schedule(() -> { + try { + start.await(); + } catch (Exception e1) { + e1.printStackTrace(); } + rs.onNext(1); }); - final AtomicReference o = new AtomicReference(); + final AtomicReference o = new AtomicReference<>(); rs.subscribeOn(s).observeOn(Schedulers.io()) .subscribe(new NbpObserver() { @@ -382,12 +342,7 @@ public void onNext(Object t) { break; } else { Assert.assertEquals(1, o.get()); - worker.schedule(new Runnable() { - @Override - public void run() { - rs.onComplete(); - } - }); + worker.schedule(() -> rs.onComplete()); } } @@ -400,22 +355,19 @@ public void testConcurrentSizeAndHasAnyValue() throws InterruptedException { final NbpReplaySubject rs = NbpReplaySubject.create(); final CyclicBarrier cb = new CyclicBarrier(2); - Thread t = new Thread(new Runnable() { - @Override - public void run() { - try { - cb.await(); - } catch (InterruptedException e) { - return; - } catch (BrokenBarrierException e) { - return; - } - for (int i = 0; i < 1000000; i++) { - rs.onNext(i); - } - rs.onComplete(); - System.out.println("Replay fill Thread finished!"); + Thread t = new Thread(() -> { + try { + cb.await(); + } catch (InterruptedException e) { + return; + } catch (BrokenBarrierException e) { + return; + } + for (int i = 0; i < 1000000; i++) { + rs.onNext(i); } + rs.onComplete(); + System.out.println("Replay fill Thread finished!"); }); t.start(); try { diff --git a/src/test/java/io/reactivex/subjects/nbp/NbpReplaySubjectTest.java b/rxjava/src/test/java/io/reactivex/subjects/nbp/NbpReplaySubjectTest.java similarity index 98% rename from src/test/java/io/reactivex/subjects/nbp/NbpReplaySubjectTest.java rename to rxjava/src/test/java/io/reactivex/subjects/nbp/NbpReplaySubjectTest.java index 71f84fd97f..5a1a2fc264 100644 --- a/src/test/java/io/reactivex/subjects/nbp/NbpReplaySubjectTest.java +++ b/rxjava/src/test/java/io/reactivex/subjects/nbp/NbpReplaySubjectTest.java @@ -68,7 +68,7 @@ public void testCompletedStopsEmittingData() { NbpSubscriber observerB = TestHelper.mockNbpSubscriber(); NbpSubscriber observerC = TestHelper.mockNbpSubscriber(); NbpSubscriber observerD = TestHelper.mockNbpSubscriber(); - NbpTestSubscriber ts = new NbpTestSubscriber(observerA); + NbpTestSubscriber ts = new NbpTestSubscriber<>(observerA); channel.subscribe(ts); channel.subscribe(observerB); @@ -219,7 +219,7 @@ public void testUnsubscribeFirstSubscriber() { NbpReplaySubject subject = NbpReplaySubject.create(); NbpSubscriber observer = TestHelper.mockNbpSubscriber(); - NbpTestSubscriber ts = new NbpTestSubscriber(observer); + NbpTestSubscriber ts = new NbpTestSubscriber<>(observer); subject.subscribe(ts); subject.onNext("one"); @@ -250,7 +250,7 @@ private void assertObservedUntilTwo(NbpSubscriber observer) { @Test(timeout = 2000) public void testNewSubscriberDoesntBlockExisting() throws InterruptedException { - final AtomicReference lastValueForSubscriber1 = new AtomicReference(); + final AtomicReference lastValueForSubscriber1 = new AtomicReference<>(); NbpSubscriber observer1 = new NbpObserver() { @Override @@ -271,7 +271,7 @@ public void onNext(String v) { }; - final AtomicReference lastValueForSubscriber2 = new AtomicReference(); + final AtomicReference lastValueForSubscriber2 = new AtomicReference<>(); final CountDownLatch oneReceived = new CountDownLatch(1); final CountDownLatch makeSlow = new CountDownLatch(1); final CountDownLatch completed = new CountDownLatch(1); @@ -367,13 +367,7 @@ public void testUnsubscriptionCase() { src.onNext(v); System.out.printf("Turn: %d%n", i); src.first() - .flatMap(new Function>() { - - @Override - public NbpObservable apply(String t1) { - return NbpObservable.just(t1 + ", " + t1); - } - }) + .flatMap(t1 -> NbpObservable.just(t1 + ", " + t1)) .subscribe(new NbpObserver() { @Override public void onNext(String t) { diff --git a/src/test/java/io/reactivex/subjects/nbp/NbpSerializedSubjectTest.java b/rxjava/src/test/java/io/reactivex/subjects/nbp/NbpSerializedSubjectTest.java similarity index 99% rename from src/test/java/io/reactivex/subjects/nbp/NbpSerializedSubjectTest.java rename to rxjava/src/test/java/io/reactivex/subjects/nbp/NbpSerializedSubjectTest.java index a915349029..9869d31091 100644 --- a/src/test/java/io/reactivex/subjects/nbp/NbpSerializedSubjectTest.java +++ b/rxjava/src/test/java/io/reactivex/subjects/nbp/NbpSerializedSubjectTest.java @@ -24,8 +24,8 @@ public class NbpSerializedSubjectTest { @Test public void testBasic() { - NbpSerializedSubject subject = new NbpSerializedSubject(NbpPublishSubject. create()); - NbpTestSubscriber ts = new NbpTestSubscriber(); + NbpSerializedSubject subject = new NbpSerializedSubject<>(NbpPublishSubject.create()); + NbpTestSubscriber ts = new NbpTestSubscriber<>(); subject.subscribe(ts); subject.onNext("hello"); subject.onComplete(); diff --git a/src/test/java/io/reactivex/subscribers/ObserversTest.java b/rxjava/src/test/java/io/reactivex/subscribers/ObserversTest.java similarity index 76% rename from src/test/java/io/reactivex/subscribers/ObserversTest.java rename to rxjava/src/test/java/io/reactivex/subscribers/ObserversTest.java index 95b9051367..50d9dc482b 100644 --- a/src/test/java/io/reactivex/subscribers/ObserversTest.java +++ b/rxjava/src/test/java/io/reactivex/subscribers/ObserversTest.java @@ -77,10 +77,7 @@ public void testCreate1Null() { } @Test(expected = NullPointerException.class) public void testCreate2Null() { - Consumer throwAction = new Consumer() { - @Override - public void accept(Throwable e) { } - }; + Consumer throwAction = e -> { }; Observers.create(null, throwAction); } @Test(expected = NullPointerException.class) @@ -106,27 +103,14 @@ public void testCreate6Null() { @Test public void testCreate1Value() { final AtomicInteger value = new AtomicInteger(); - Consumer action = new Consumer() { - @Override - public void accept(Integer t) { - value.set(t); - } - }; - Observers.create(action).onNext(1); + Observers.create(value::set).onNext(1); assertEquals(1, value.get()); } @Test public void testCreate2Value() { final AtomicInteger value = new AtomicInteger(); - Consumer action = new Consumer() { - @Override - public void accept(Integer t) { - value.set(t); - } - }; - Consumer throwAction = Functions.emptyConsumer(); - Observers.create(action, throwAction).onNext(1); + Observers.create(value::set, Functions.emptyConsumer()).onNext(1); assertEquals(1, value.get()); } @@ -134,44 +118,25 @@ public void accept(Integer t) { @Test public void testCreate3Value() { final AtomicInteger value = new AtomicInteger(); - Consumer action = new Consumer() { - @Override - public void accept(Integer t) { - value.set(t); - } - }; - Consumer throwAction = Functions.emptyConsumer(); - Observers.create(action, throwAction, Functions.emptyRunnable()).onNext(1); + Observers.create(value::set, Functions.emptyConsumer(), Functions.emptyRunnable()).onNext(1); assertEquals(1, value.get()); } @Test public void testError2() { - final AtomicReference value = new AtomicReference(); - Consumer action = new Consumer() { - @Override - public void accept(Throwable t) { - value.set(t); - } - }; + final AtomicReference value = new AtomicReference<>(); TestException exception = new TestException(); - Observers.create(Functions.emptyConsumer(), action).onError(exception); + Observers.create(Functions.emptyConsumer(), value::set).onError(exception); assertEquals(exception, value.get()); } @Test public void testError3() { - final AtomicReference value = new AtomicReference(); - Consumer action = new Consumer() { - @Override - public void accept(Throwable t) { - value.set(t); - } - }; + final AtomicReference value = new AtomicReference<>(); TestException exception = new TestException(); - Observers.create(Functions.emptyConsumer(), action, Functions.emptyRunnable()).onError(exception); + Observers.create(Functions.emptyConsumer(), value::set, Functions.emptyRunnable()).onError(exception); assertEquals(exception, value.get()); } diff --git a/src/test/java/io/reactivex/subscribers/SafeObserverTest.java b/rxjava/src/test/java/io/reactivex/subscribers/SafeObserverTest.java similarity index 94% rename from src/test/java/io/reactivex/subscribers/SafeObserverTest.java rename to rxjava/src/test/java/io/reactivex/subscribers/SafeObserverTest.java index 3d36e9c3a6..0dae4ca29e 100644 --- a/src/test/java/io/reactivex/subscribers/SafeObserverTest.java +++ b/rxjava/src/test/java/io/reactivex/subscribers/SafeObserverTest.java @@ -30,7 +30,7 @@ public class SafeObserverTest { @Test public void onNextFailure() { - AtomicReference onError = new AtomicReference(); + AtomicReference onError = new AtomicReference<>(); try { OBSERVER_ONNEXT_FAIL(onError).onNext("one"); fail("expects exception to be thrown"); @@ -43,9 +43,9 @@ public void onNextFailure() { @Test public void onNextFailureSafe() { - AtomicReference onError = new AtomicReference(); + AtomicReference onError = new AtomicReference<>(); try { - SafeSubscriber safeSubscriber = new SafeSubscriber(OBSERVER_ONNEXT_FAIL(onError)); + SafeSubscriber safeSubscriber = new SafeSubscriber<>(OBSERVER_ONNEXT_FAIL(onError)); safeSubscriber.onSubscribe(EmptySubscription.INSTANCE); safeSubscriber.onNext("one"); assertNotNull(onError.get()); @@ -58,7 +58,7 @@ public void onNextFailureSafe() { @Test public void onCompletedFailure() { - AtomicReference onError = new AtomicReference(); + AtomicReference onError = new AtomicReference<>(); try { OBSERVER_ONCOMPLETED_FAIL(onError).onComplete(); fail("expects exception to be thrown"); @@ -84,7 +84,7 @@ public void onErrorFailure() { @Ignore("Subscribers can't throw") public void onErrorFailureSafe() { try { - new SafeSubscriber(OBSERVER_ONERROR_FAIL()).onError(new SafeObserverTestException("error!")); + new SafeSubscriber<>(OBSERVER_ONERROR_FAIL()).onError(new SafeObserverTestException("error!")); fail("expects exception to be thrown"); } catch (Exception e) { e.printStackTrace(); @@ -110,7 +110,7 @@ public void onErrorFailureSafe() { @Ignore("Subscribers can't throw") public void onErrorNotImplementedFailureSafe() { try { - new SafeSubscriber(OBSERVER_ONERROR_NOTIMPLEMENTED()).onError(new SafeObserverTestException("error!")); + new SafeSubscriber<>(OBSERVER_ONERROR_NOTIMPLEMENTED()).onError(new SafeObserverTestException("error!")); fail("expects exception to be thrown"); } catch (Exception e) { assertTrue(e instanceof OnErrorNotImplementedException); @@ -135,7 +135,7 @@ public void onNextOnErrorFailure() { @Ignore("Subscribers can't throw") public void onNextOnErrorFailureSafe() { try { - new SafeSubscriber(OBSERVER_ONNEXT_ONERROR_FAIL()).onNext("one"); + new SafeSubscriber<>(OBSERVER_ONNEXT_ONERROR_FAIL()).onNext("one"); fail("expects exception to be thrown"); } catch (Exception e) { e.printStackTrace(); @@ -175,7 +175,7 @@ public void request(long n) { } }); - new SafeSubscriber(o).onComplete(); + new SafeSubscriber<>(o).onComplete(); fail("expects exception to be thrown"); } catch (Exception e) { e.printStackTrace(); @@ -192,7 +192,7 @@ public void request(long n) { @Test @Ignore("Subscribers can't throw") public void onErrorSuccessWithUnsubscribeFailure() { - AtomicReference onError = new AtomicReference(); + AtomicReference onError = new AtomicReference<>(); Subscriber o = OBSERVER_SUCCESS(onError); try { o.onSubscribe(new Subscription() { @@ -208,7 +208,7 @@ public void request(long n) { } }); - new SafeSubscriber(o).onError(new SafeObserverTestException("failed")); + new SafeSubscriber<>(o).onError(new SafeObserverTestException("failed")); fail("we expect the unsubscribe failure to cause an exception to be thrown"); } catch (Exception e) { e.printStackTrace(); @@ -246,7 +246,7 @@ public void request(long n) { } }); - new SafeSubscriber(o).onError(new SafeObserverTestException("onError failure")); + new SafeSubscriber<>(o).onError(new SafeObserverTestException("onError failure")); fail("expects exception to be thrown"); } catch (Exception e) { e.printStackTrace(); @@ -295,7 +295,7 @@ public void request(long n) { } }); - new SafeSubscriber(o).onError(new SafeObserverTestException("error!")); + new SafeSubscriber<>(o).onError(new SafeObserverTestException("error!")); fail("expects exception to be thrown"); } catch (Exception e) { e.printStackTrace(); @@ -479,16 +479,18 @@ public SafeObserverTestException(String message) { @Test @Ignore("Subscribers can't throw") public void testOnCompletedThrows() { - final AtomicReference error = new AtomicReference(); - SafeSubscriber s = new SafeSubscriber(new Observer() { + final AtomicReference error = new AtomicReference<>(); + SafeSubscriber s = new SafeSubscriber<>(new Observer() { @Override public void onNext(Integer t) { - + } + @Override public void onError(Throwable e) { error.set(e); } + @Override public void onComplete() { throw new TestException(); @@ -516,7 +518,7 @@ public void onError(Throwable e) { public void onComplete() { } }; - SafeSubscriber s = new SafeSubscriber(actual); + SafeSubscriber s = new SafeSubscriber<>(actual); assertSame(actual, s.actual()); } diff --git a/src/test/java/io/reactivex/subscribers/SafeSubscriberTest.java b/rxjava/src/test/java/io/reactivex/subscribers/SafeSubscriberTest.java similarity index 93% rename from src/test/java/io/reactivex/subscribers/SafeSubscriberTest.java rename to rxjava/src/test/java/io/reactivex/subscribers/SafeSubscriberTest.java index 85b7ea4b36..45e770e058 100644 --- a/src/test/java/io/reactivex/subscribers/SafeSubscriberTest.java +++ b/rxjava/src/test/java/io/reactivex/subscribers/SafeSubscriberTest.java @@ -33,7 +33,7 @@ public void testOnNextAfterOnError() { Observable st = Observable.create(t); Subscriber w = TestHelper.mockSubscriber(); - st.subscribe(new SafeSubscriber(new TestSubscriber(w))); + st.subscribe(new SafeSubscriber<>(new TestSubscriber<>(w))); t.sendOnNext("one"); t.sendOnError(new RuntimeException("bad")); @@ -54,7 +54,7 @@ public void testOnCompletedAfterOnError() { Subscriber w = TestHelper.mockSubscriber(); - st.subscribe(new SafeSubscriber(new TestSubscriber(w))); + st.subscribe(new SafeSubscriber<>(new TestSubscriber<>(w))); t.sendOnNext("one"); t.sendOnError(new RuntimeException("bad")); @@ -74,7 +74,7 @@ public void testOnNextAfterOnCompleted() { Observable st = Observable.create(t); Subscriber w = TestHelper.mockSubscriber(); - st.subscribe(new SafeSubscriber(new TestSubscriber(w))); + st.subscribe(new SafeSubscriber<>(new TestSubscriber<>(w))); t.sendOnNext("one"); t.sendOnCompleted(); @@ -95,7 +95,7 @@ public void testOnErrorAfterOnCompleted() { Observable st = Observable.create(t); Subscriber w = TestHelper.mockSubscriber(); - st.subscribe(new SafeSubscriber(new TestSubscriber(w))); + st.subscribe(new SafeSubscriber<>(new TestSubscriber<>(w))); t.sendOnNext("one"); t.sendOnCompleted(); diff --git a/src/test/java/io/reactivex/subscribers/SafeSubscriberWithPluginTest.java b/rxjava/src/test/java/io/reactivex/subscribers/SafeSubscriberWithPluginTest.java similarity index 85% rename from src/test/java/io/reactivex/subscribers/SafeSubscriberWithPluginTest.java rename to rxjava/src/test/java/io/reactivex/subscribers/SafeSubscriberWithPluginTest.java index db308867c2..f25583a585 100644 --- a/src/test/java/io/reactivex/subscribers/SafeSubscriberWithPluginTest.java +++ b/rxjava/src/test/java/io/reactivex/subscribers/SafeSubscriberWithPluginTest.java @@ -52,7 +52,7 @@ public void onComplete() { throw new TestException(); } }; - SafeSubscriber safe = new SafeSubscriber(ts); + SafeSubscriber safe = new SafeSubscriber<>(ts); try { safe.onComplete(); Assert.fail(); @@ -70,7 +70,7 @@ public void onComplete() { throw new OnErrorNotImplementedException(new TestException()); } }; - SafeSubscriber safe = new SafeSubscriber(ts); + SafeSubscriber safe = new SafeSubscriber<>(ts); try { safe.onComplete(); @@ -85,11 +85,8 @@ public void onComplete() { @Test(expected = OnCompleteFailedException.class) @Ignore("Subscribers can't throw") public void testPluginException() { - RxJavaPlugins.setErrorHandler(new Consumer() { - @Override - public void accept(Throwable e) { - throw new RuntimeException(); - } + RxJavaPlugins.setErrorHandler(e -> { + throw new RuntimeException(); }); TestSubscriber ts = new TestSubscriber() { @@ -98,7 +95,7 @@ public void onComplete() { throw new TestException(); } }; - SafeSubscriber safe = new SafeSubscriber(ts); + SafeSubscriber safe = new SafeSubscriber<>(ts); safe.onComplete(); } @@ -116,8 +113,8 @@ public void accept(Throwable e) { } }); - TestSubscriber ts = new TestSubscriber(); - SafeSubscriber safe = new SafeSubscriber(ts); + TestSubscriber ts = new TestSubscriber<>(); + SafeSubscriber safe = new SafeSubscriber<>(ts); safe.onSubscribe(new SubscriptionCancelThrows()); safe.onError(new TestException()); @@ -142,7 +139,7 @@ public void onError(Throwable e) { throw new OnErrorNotImplementedException(e); } }; - SafeSubscriber safe = new SafeSubscriber(ts); + SafeSubscriber safe = new SafeSubscriber<>(ts); safe.onSubscribe(new SubscriptionCancelThrows()); safe.onError(new TestException()); @@ -167,7 +164,7 @@ public void onError(Throwable e) { throw new RuntimeException(e); } }; - SafeSubscriber safe = new SafeSubscriber(ts); + SafeSubscriber safe = new SafeSubscriber<>(ts); safe.onError(new TestException()); } @@ -190,7 +187,7 @@ public void onError(Throwable e) { throw new RuntimeException(e); } }; - SafeSubscriber safe = new SafeSubscriber(ts); + SafeSubscriber safe = new SafeSubscriber<>(ts); safe.onSubscribe(new SubscriptionCancelThrows()); safe.onError(new TestException()); @@ -214,7 +211,7 @@ public void onError(Throwable e) { throw new RuntimeException(e); } }; - SafeSubscriber safe = new SafeSubscriber(ts); + SafeSubscriber safe = new SafeSubscriber<>(ts); safe.onSubscribe(new SubscriptionCancelThrows()); safe.onError(new TestException()); @@ -224,12 +221,7 @@ public void onError(Throwable e) { @Ignore("Subscribers can't throw") public void testPluginErrorHandlerReceivesExceptionWhenUnsubscribeAfterCompletionThrows() { final AtomicInteger calls = new AtomicInteger(); - RxJavaPlugins.setErrorHandler(new Consumer() { - @Override - public void accept(Throwable e) { - calls.incrementAndGet(); - } - }); + RxJavaPlugins.setErrorHandler(e -> calls.incrementAndGet()); final AtomicInteger errors = new AtomicInteger(); TestSubscriber ts = new TestSubscriber() { @@ -239,7 +231,7 @@ public void onError(Throwable e) { } }; final RuntimeException ex = new RuntimeException(); - SafeSubscriber safe = new SafeSubscriber(ts); + SafeSubscriber safe = new SafeSubscriber<>(ts); safe.onSubscribe(new Subscription() { @Override public void cancel() { @@ -265,12 +257,7 @@ public void request(long n) { @Ignore("Subscribers can't throw") public void testPluginErrorHandlerReceivesExceptionFromFailingUnsubscribeAfterCompletionThrows() { final AtomicInteger calls = new AtomicInteger(); - RxJavaPlugins.setErrorHandler(new Consumer() { - @Override - public void accept(Throwable e) { - calls.incrementAndGet(); - } - }); + RxJavaPlugins.setErrorHandler(e -> calls.incrementAndGet()); final AtomicInteger errors = new AtomicInteger(); TestSubscriber ts = new TestSubscriber() { @@ -285,7 +272,7 @@ public void onError(Throwable e) { errors.incrementAndGet(); } }; - SafeSubscriber safe = new SafeSubscriber(ts); + SafeSubscriber safe = new SafeSubscriber<>(ts); safe.onSubscribe(new SubscriptionCancelThrows()); try { diff --git a/src/test/java/io/reactivex/subscribers/SerializedObserverTest.java b/rxjava/src/test/java/io/reactivex/subscribers/SerializedObserverTest.java similarity index 88% rename from src/test/java/io/reactivex/subscribers/SerializedObserverTest.java rename to rxjava/src/test/java/io/reactivex/subscribers/SerializedObserverTest.java index b24f057c15..cb3be59306 100644 --- a/src/test/java/io/reactivex/subscribers/SerializedObserverTest.java +++ b/rxjava/src/test/java/io/reactivex/subscribers/SerializedObserverTest.java @@ -39,7 +39,7 @@ public void before() { } private Subscriber serializedSubscriber(Subscriber o) { - return new SerializedSubscriber(o); + return new SerializedSubscriber<>(o); } @Test @@ -160,7 +160,7 @@ public void runOutOfOrderConcurrencyTest() { try { TestConcurrencySubscriber tw = new TestConcurrencySubscriber(); // we need Synchronized + SafeSubscriber to handle synchronization plus life-cycle - Subscriber w = serializedSubscriber(new SafeSubscriber(tw)); + Subscriber w = serializedSubscriber(new SafeSubscriber<>(tw)); Future f1 = tp.submit(new OnNextThread(w, 12000)); Future f2 = tp.submit(new OnNextThread(w, 5000)); @@ -210,7 +210,7 @@ public void runConcurrencyTest() { try { TestConcurrencySubscriber tw = new TestConcurrencySubscriber(); // we need Synchronized + SafeSubscriber to handle synchronization plus life-cycle - Subscriber w = serializedSubscriber(new SafeSubscriber(tw)); + Subscriber w = serializedSubscriber(new SafeSubscriber<>(tw)); w.onSubscribe(EmptySubscription.INSTANCE); Future f1 = tp.submit(new OnNextThread(w, 12000)); @@ -267,7 +267,7 @@ public void testNotificationDelay() throws InterruptedException { final CountDownLatch latch = new CountDownLatch(1); final CountDownLatch running = new CountDownLatch(2); - TestSubscriber to = new TestSubscriber(new Observer() { + TestSubscriber to = new TestSubscriber<>(new Observer() { @Override public void onComplete() { @@ -348,7 +348,7 @@ public void onNext(String t) { @Test public void testThreadStarvation() throws InterruptedException { - TestSubscriber to = new TestSubscriber(new Observer() { + TestSubscriber to = new TestSubscriber<>(new Observer() { @Override public void onComplete() { @@ -523,7 +523,7 @@ private static class TestConcurrencySubscriber extends Observer { /** * used to store the order and number of events received */ - private final LinkedBlockingQueue events = new LinkedBlockingQueue(); + private final LinkedBlockingQueue events = new LinkedBlockingQueue<>(); private final int waitTime; @SuppressWarnings("unused") @@ -624,22 +624,17 @@ public TestSingleThreadedObservable(final String... values) { public void subscribe(final Subscriber observer) { observer.onSubscribe(EmptySubscription.INSTANCE); System.out.println("TestSingleThreadedObservable subscribed to ..."); - t = new Thread(new Runnable() { - - @Override - public void run() { - try { - System.out.println("running TestSingleThreadedObservable thread"); - for (String s : values) { - System.out.println("TestSingleThreadedObservable onNext: " + s); - observer.onNext(s); - } - observer.onComplete(); - } catch (Throwable e) { - throw new RuntimeException(e); + t = new Thread(() -> { + try { + System.out.println("running TestSingleThreadedObservable thread"); + for (String s : values) { + System.out.println("TestSingleThreadedObservable onNext: " + s); + observer.onNext(s); } + observer.onComplete(); + } catch (Throwable e) { + throw new RuntimeException(e); } - }); System.out.println("starting TestSingleThreadedObservable thread"); t.start(); @@ -677,65 +672,57 @@ public void subscribe(final Subscriber observer) { observer.onSubscribe(EmptySubscription.INSTANCE); final NullPointerException npe = new NullPointerException(); System.out.println("TestMultiThreadedObservable subscribed to ..."); - t = new Thread(new Runnable() { - - @Override - public void run() { - try { - System.out.println("running TestMultiThreadedObservable thread"); - int j = 0; - for (final String s : values) { - final int fj = ++j; - threadPool.execute(new Runnable() { - - @Override - public void run() { - threadsRunning.incrementAndGet(); - try { - // perform onNext call - System.out.println("TestMultiThreadedObservable onNext: " + s + " on thread " + Thread.currentThread().getName()); - if (s == null) { - // force an error - throw npe; - } else { - // allow the exception to queue up - int sleep = (fj % 3) * 10; - if (sleep != 0) { - Thread.sleep(sleep); - } - } - observer.onNext(s); - // capture 'maxThreads' - int concurrentThreads = threadsRunning.get(); - int maxThreads = maxConcurrentThreads.get(); - if (concurrentThreads > maxThreads) { - maxConcurrentThreads.compareAndSet(maxThreads, concurrentThreads); - } - } catch (Throwable e) { - observer.onError(e); - } finally { - threadsRunning.decrementAndGet(); + t = new Thread(() -> { + try { + System.out.println("running TestMultiThreadedObservable thread"); + int j = 0; + for (final String s : values) { + final int fj = ++j; + threadPool.execute(() -> { + threadsRunning.incrementAndGet(); + try { + // perform onNext call + System.out.println("TestMultiThreadedObservable onNext: " + s + " on thread " + Thread.currentThread().getName()); + if (s == null) { + // force an error + throw npe; + } else { + // allow the exception to queue up + int sleep = (fj % 3) * 10; + if (sleep != 0) { + Thread.sleep(sleep); } } - }); - } - // we are done spawning threads - threadPool.shutdown(); - } catch (Throwable e) { - throw new RuntimeException(e); + observer.onNext(s); + // capture 'maxThreads' + int concurrentThreads = threadsRunning.get(); + int maxThreads = maxConcurrentThreads.get(); + if (concurrentThreads > maxThreads) { + maxConcurrentThreads.compareAndSet(maxThreads, concurrentThreads); + } + } catch (Throwable e) { + observer.onError(e); + } finally { + threadsRunning.decrementAndGet(); + } + }); } + // we are done spawning threads + threadPool.shutdown(); + } catch (Throwable e) { + throw new RuntimeException(e); + } - // wait until all threads are done, then mark it as COMPLETED - try { - // wait for all the threads to finish - if (!threadPool.awaitTermination(5, TimeUnit.SECONDS)) { - System.out.println("Threadpool did not terminate in time."); - } - } catch (InterruptedException e) { - throw new RuntimeException(e); + // wait until all threads are done, then mark it as COMPLETED + try { + // wait for all the threads to finish + if (!threadPool.awaitTermination(5, TimeUnit.SECONDS)) { + System.out.println("Threadpool did not terminate in time."); } - observer.onComplete(); + } catch (InterruptedException e) { + throw new RuntimeException(e); } + observer.onComplete(); }); System.out.println("starting TestMultiThreadedObservable thread"); t.start(); @@ -818,7 +805,7 @@ protected void captureMaxThreads() { @Test @Ignore("Null values not permitted") public void testSerializeNull() { - final AtomicReference> serial = new AtomicReference>(); + final AtomicReference> serial = new AtomicReference<>(); TestSubscriber to = new TestSubscriber() { @Override public void onNext(Integer t) { @@ -829,7 +816,7 @@ public void onNext(Integer t) { } }; - SerializedSubscriber sobs = new SerializedSubscriber(to); + SerializedSubscriber sobs = new SerializedSubscriber<>(to); serial.set(sobs); sobs.onNext(0); @@ -847,7 +834,7 @@ public void onNext(Integer t) { } }; - SerializedSubscriber sobs = new SerializedSubscriber(to); + SerializedSubscriber sobs = new SerializedSubscriber<>(to); try { sobs.onNext(0); @@ -861,7 +848,7 @@ public void onNext(Integer t) { @Test @Ignore("Null values no longer permitted") public void testSerializeReentrantNullAndComplete() { - final AtomicReference> serial = new AtomicReference>(); + final AtomicReference> serial = new AtomicReference<>(); TestSubscriber to = new TestSubscriber() { @Override public void onNext(Integer t) { @@ -870,7 +857,7 @@ public void onNext(Integer t) { } }; - SerializedSubscriber sobs = new SerializedSubscriber(to); + SerializedSubscriber sobs = new SerializedSubscriber<>(to); serial.set(sobs); try { @@ -886,7 +873,7 @@ public void onNext(Integer t) { @Test @Ignore("Subscribers can't throw") public void testSerializeReentrantNullAndError() { - final AtomicReference> serial = new AtomicReference>(); + final AtomicReference> serial = new AtomicReference<>(); TestSubscriber to = new TestSubscriber() { @Override public void onNext(Integer t) { @@ -895,7 +882,7 @@ public void onNext(Integer t) { } }; - SerializedSubscriber sobs = new SerializedSubscriber(to); + SerializedSubscriber sobs = new SerializedSubscriber<>(to); serial.set(sobs); try { @@ -911,7 +898,7 @@ public void onNext(Integer t) { @Test @Ignore("Null values no longer permitted") public void testSerializeDrainPhaseThrows() { - final AtomicReference> serial = new AtomicReference>(); + final AtomicReference> serial = new AtomicReference<>(); TestSubscriber to = new TestSubscriber() { @Override public void onNext(Integer t) { @@ -925,7 +912,7 @@ public void onNext(Integer t) { } }; - SerializedSubscriber sobs = new SerializedSubscriber(to); + SerializedSubscriber sobs = new SerializedSubscriber<>(to); serial.set(sobs); sobs.onNext(0); @@ -936,7 +923,7 @@ public void onNext(Integer t) { @Test public void testErrorReentry() { - final AtomicReference> serial = new AtomicReference>(); + final AtomicReference> serial = new AtomicReference<>(); TestSubscriber ts = new TestSubscriber() { @Override @@ -946,7 +933,7 @@ public void onNext(Integer v) { super.onNext(v); } }; - SerializedSubscriber sobs = new SerializedSubscriber(ts); + SerializedSubscriber sobs = new SerializedSubscriber<>(ts); sobs.onSubscribe(EmptySubscription.INSTANCE); serial.set(sobs); @@ -957,7 +944,7 @@ public void onNext(Integer v) { } @Test public void testCompleteReentry() { - final AtomicReference> serial = new AtomicReference>(); + final AtomicReference> serial = new AtomicReference<>(); TestSubscriber ts = new TestSubscriber() { @Override @@ -967,7 +954,7 @@ public void onNext(Integer v) { super.onNext(v); } }; - SerializedSubscriber sobs = new SerializedSubscriber(ts); + SerializedSubscriber sobs = new SerializedSubscriber<>(ts); sobs.onSubscribe(EmptySubscription.INSTANCE); serial.set(sobs); diff --git a/src/test/java/io/reactivex/subscribers/SubscribersTest.java b/rxjava/src/test/java/io/reactivex/subscribers/SubscribersTest.java similarity index 57% rename from src/test/java/io/reactivex/subscribers/SubscribersTest.java rename to rxjava/src/test/java/io/reactivex/subscribers/SubscribersTest.java index d941b775a3..4d0981911c 100644 --- a/src/test/java/io/reactivex/subscribers/SubscribersTest.java +++ b/rxjava/src/test/java/io/reactivex/subscribers/SubscribersTest.java @@ -61,10 +61,7 @@ public void testEmptyOnErrorNotImplemented() { @Ignore("Subscribers can't throw OnErrorNotImplementedException") public void testCreate1OnErrorNotImplemented() { try { - Subscribers.create(new Consumer() { - @Override - public void accept(Object v) { } - }).onError(new TestException()); + Subscribers.create(v -> { }).onError(new TestException()); fail("OnErrorNotImplementedException not thrown!"); } catch (OnErrorNotImplementedException ex) { if (!(ex.getCause() instanceof TestException)) { @@ -78,56 +75,33 @@ public void testCreate1Null() { } @Test(expected = NullPointerException.class) public void testCreate2Null() { - Consumer throwAction = new Consumer() { - @Override - public void accept(Throwable e) { } - }; + Consumer throwAction = e -> { }; Subscribers.create(null, throwAction); } @Test(expected = NullPointerException.class) public void testCreate3Null() { - Subscribers.create(new Consumer() { - @Override - public void accept(Object e) { } - }, null); + Subscribers.create(e -> { }, null); } @Test(expected = NullPointerException.class) public void testCreate4Null() { - Consumer throwAction = new Consumer() { - @Override - public void accept(Throwable e) { } - }; + Consumer throwAction = e -> { }; Subscribers.create(null, throwAction, Functions.emptyRunnable()); } @Test(expected = NullPointerException.class) public void testCreate5Null() { - Subscribers.create(new Consumer() { - @Override - public void accept(Object e) { } - }, null, Functions.emptyRunnable()); + Subscribers.create(e -> { }, null, Functions.emptyRunnable()); } @Test(expected = NullPointerException.class) public void testCreate6Null() { - Consumer throwAction = new Consumer() { - @Override - public void accept(Throwable e) { } - }; - Subscribers.create(new Consumer() { - @Override - public void accept(Object e) { } - }, throwAction, null); + Consumer throwAction = e -> { }; + Subscribers.create(e -> { }, throwAction, null); } @Test public void testCreate1Value() { final AtomicInteger value = new AtomicInteger(); - Consumer action = new Consumer() { - @Override - public void accept(Integer t) { - value.set(t); - } - }; + Consumer action = t -> value.set(t); Subscribers.create(action).onNext(1); assertEquals(1, value.get()); @@ -135,16 +109,8 @@ public void accept(Integer t) { @Test public void testCreate2Value() { final AtomicInteger value = new AtomicInteger(); - Consumer action = new Consumer() { - @Override - public void accept(Integer t) { - value.set(t); - } - }; - Consumer throwAction = new Consumer() { - @Override - public void accept(Throwable e) { } - }; + Consumer action = value::set; + Consumer throwAction = e -> { }; Subscribers.create(action, throwAction).onNext(1); assertEquals(1, value.get()); @@ -153,16 +119,8 @@ public void accept(Throwable e) { } @Test public void testCreate3Value() { final AtomicInteger value = new AtomicInteger(); - Consumer action = new Consumer() { - @Override - public void accept(Integer t) { - value.set(t); - } - }; - Consumer throwAction = new Consumer() { - @Override - public void accept(Throwable e) { } - }; + Consumer action = value::set; + Consumer throwAction = e -> { }; Subscribers.create(action, throwAction, Functions.emptyRunnable()).onNext(1); assertEquals(1, value.get()); @@ -170,36 +128,20 @@ public void accept(Throwable e) { } @Test public void testError2() { - final AtomicReference value = new AtomicReference(); - Consumer action = new Consumer() { - @Override - public void accept(Throwable t) { - value.set(t); - } - }; + final AtomicReference value = new AtomicReference<>(); + Consumer action = t -> value.set(t); TestException exception = new TestException(); - Subscribers.create(new Consumer() { - @Override - public void accept(Object e) { } - }, action).onError(exception); + Subscribers.create(e -> { }, action).onError(exception); assertEquals(exception, value.get()); } @Test public void testError3() { - final AtomicReference value = new AtomicReference(); - Consumer action = new Consumer() { - @Override - public void accept(Throwable t) { - value.set(t); - } - }; + final AtomicReference value = new AtomicReference<>(); + Consumer action = value::set; TestException exception = new TestException(); - Subscribers.create(new Consumer() { - @Override - public void accept(Object e) { } - }, action, Functions.emptyRunnable()).onError(exception); + Subscribers.create(e -> { }, action, Functions.emptyRunnable()).onError(exception); assertEquals(exception, value.get()); } @@ -208,31 +150,16 @@ public void accept(Object e) { } public void testCompleted() { Runnable action = mock(Runnable.class); - Consumer throwAction = new Consumer() { - @Override - public void accept(Throwable e) { } - }; - Subscribers.create(new Consumer() { - @Override - public void accept(Object e) { } - }, throwAction, action).onComplete(); + Consumer throwAction = e -> { }; + Subscribers.create(e -> { }, throwAction, action).onComplete(); verify(action).run(); } @Test public void testEmptyCompleted() { - Subscribers.create(new Consumer() { - @Override - public void accept(Object e) { } - }).onComplete(); + Subscribers.create(e -> { }).onComplete(); - Consumer throwAction = new Consumer() { - @Override - public void accept(Throwable e) { } - }; - Subscribers.create(new Consumer() { - @Override - public void accept(Object e) { } - }, throwAction).onComplete(); + Consumer throwAction = e -> { }; + Subscribers.create(e -> { }, throwAction).onComplete(); } } \ No newline at end of file diff --git a/src/test/java/io/reactivex/subscribers/TestObserverTest.java b/rxjava/src/test/java/io/reactivex/subscribers/TestObserverTest.java similarity index 88% rename from src/test/java/io/reactivex/subscribers/TestObserverTest.java rename to rxjava/src/test/java/io/reactivex/subscribers/TestObserverTest.java index 7299f82938..453421e0f2 100644 --- a/src/test/java/io/reactivex/subscribers/TestObserverTest.java +++ b/rxjava/src/test/java/io/reactivex/subscribers/TestObserverTest.java @@ -38,7 +38,7 @@ public class TestObserverTest { @Test public void testAssert() { Observable oi = Observable.fromIterable(Arrays.asList(1, 2)); - TestSubscriber o = new TestSubscriber(); + TestSubscriber o = new TestSubscriber<>(); oi.subscribe(o); o.assertValues(1, 2); @@ -49,7 +49,7 @@ public void testAssert() { @Test public void testAssertNotMatchCount() { Observable oi = Observable.fromIterable(Arrays.asList(1, 2)); - TestSubscriber o = new TestSubscriber(); + TestSubscriber o = new TestSubscriber<>(); oi.subscribe(o); thrown.expect(AssertionError.class); @@ -64,7 +64,7 @@ public void testAssertNotMatchCount() { @Test public void testAssertNotMatchValue() { Observable oi = Observable.fromIterable(Arrays.asList(1, 2)); - TestSubscriber o = new TestSubscriber(); + TestSubscriber o = new TestSubscriber<>(); oi.subscribe(o); thrown.expect(AssertionError.class); @@ -79,7 +79,7 @@ public void testAssertNotMatchValue() { @Test public void testAssertTerminalEventNotReceived() { PublishSubject p = PublishSubject.create(); - TestSubscriber o = new TestSubscriber(); + TestSubscriber o = new TestSubscriber<>(); p.subscribe(o); p.onNext(1); @@ -100,7 +100,7 @@ public void testWrappingMock() { Subscriber mockObserver = TestHelper.mockSubscriber(); - oi.subscribe(new TestSubscriber(mockObserver)); + oi.subscribe(new TestSubscriber<>(mockObserver)); InOrder inOrder = inOrder(mockObserver); inOrder.verify(mockObserver, times(1)).onNext(1); @@ -113,7 +113,7 @@ public void testWrappingMock() { public void testWrappingMockWhenUnsubscribeInvolved() { Observable oi = Observable.fromIterable(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9)).take(2); Subscriber mockObserver = TestHelper.mockSubscriber(); - oi.subscribe(new TestSubscriber(mockObserver)); + oi.subscribe(new TestSubscriber<>(mockObserver)); InOrder inOrder = inOrder(mockObserver); inOrder.verify(mockObserver, times(1)).onNext(1); @@ -124,12 +124,12 @@ public void testWrappingMockWhenUnsubscribeInvolved() { @Test public void testErrorSwallowed() { - Observable.error(new RuntimeException()).subscribe(new TestSubscriber()); + Observable.error(new RuntimeException()).subscribe(new TestSubscriber<>()); } @Test public void testGetEvents() { - TestSubscriber to = new TestSubscriber(); + TestSubscriber to = new TestSubscriber<>(); to.onSubscribe(EmptySubscription.INSTANCE); to.onNext(1); to.onNext(2); @@ -144,7 +144,7 @@ public void testGetEvents() { Collections.singletonList(Notification.complete())), to.getEvents()); TestException ex = new TestException(); - TestSubscriber to2 = new TestSubscriber(); + TestSubscriber to2 = new TestSubscriber<>(); to2.onSubscribe(EmptySubscription.INSTANCE); to2.onNext(1); to2.onNext(2); @@ -164,7 +164,7 @@ public void testGetEvents() { @Test public void testNullExpected() { - TestSubscriber to = new TestSubscriber(); + TestSubscriber to = new TestSubscriber<>(); to.onNext(1); try { @@ -178,7 +178,7 @@ public void testNullExpected() { @Test public void testNullActual() { - TestSubscriber to = new TestSubscriber(); + TestSubscriber to = new TestSubscriber<>(); to.onNext(null); try { @@ -192,7 +192,7 @@ public void testNullActual() { @Test public void testTerminalErrorOnce() { - TestSubscriber to = new TestSubscriber(); + TestSubscriber to = new TestSubscriber<>(); to.onError(new TestException()); to.onError(new TestException()); @@ -206,7 +206,7 @@ public void testTerminalErrorOnce() { } @Test public void testTerminalCompletedOnce() { - TestSubscriber to = new TestSubscriber(); + TestSubscriber to = new TestSubscriber<>(); to.onComplete(); to.onComplete(); @@ -221,7 +221,7 @@ public void testTerminalCompletedOnce() { @Test public void testTerminalOneKind() { - TestSubscriber to = new TestSubscriber(); + TestSubscriber to = new TestSubscriber<>(); to.onError(new TestException()); to.onComplete(); diff --git a/src/test/java/io/reactivex/subscribers/TestSubscriberTest.java b/rxjava/src/test/java/io/reactivex/subscribers/TestSubscriberTest.java similarity index 80% rename from src/test/java/io/reactivex/subscribers/TestSubscriberTest.java rename to rxjava/src/test/java/io/reactivex/subscribers/TestSubscriberTest.java index 47a705384a..9d88e45841 100644 --- a/src/test/java/io/reactivex/subscribers/TestSubscriberTest.java +++ b/rxjava/src/test/java/io/reactivex/subscribers/TestSubscriberTest.java @@ -41,7 +41,7 @@ public class TestSubscriberTest { @Test public void testAssert() { Observable oi = Observable.fromIterable(Arrays.asList(1, 2)); - TestSubscriber o = new TestSubscriber(); + TestSubscriber o = new TestSubscriber<>(); oi.subscribe(o); o.assertValues(1, 2); @@ -52,7 +52,7 @@ public void testAssert() { @Test public void testAssertNotMatchCount() { Observable oi = Observable.fromIterable(Arrays.asList(1, 2)); - TestSubscriber o = new TestSubscriber(); + TestSubscriber o = new TestSubscriber<>(); oi.subscribe(o); thrown.expect(AssertionError.class); @@ -67,7 +67,7 @@ public void testAssertNotMatchCount() { @Test public void testAssertNotMatchValue() { Observable oi = Observable.fromIterable(Arrays.asList(1, 2)); - TestSubscriber o = new TestSubscriber(); + TestSubscriber o = new TestSubscriber<>(); oi.subscribe(o); thrown.expect(AssertionError.class); @@ -83,7 +83,7 @@ public void testAssertNotMatchValue() { @Test public void testAssertTerminalEventNotReceived() { PublishSubject p = PublishSubject.create(); - TestSubscriber o = new TestSubscriber(); + TestSubscriber o = new TestSubscriber<>(); p.subscribe(o); p.onNext(1); @@ -103,7 +103,7 @@ public void testWrappingMock() { Observable oi = Observable.fromIterable(Arrays.asList(1, 2)); Subscriber mockObserver = TestHelper.mockSubscriber(); - oi.subscribe(new TestSubscriber(mockObserver)); + oi.subscribe(new TestSubscriber<>(mockObserver)); InOrder inOrder = inOrder(mockObserver); inOrder.verify(mockObserver, times(1)).onNext(1); @@ -116,7 +116,7 @@ public void testWrappingMock() { public void testWrappingMockWhenUnsubscribeInvolved() { Observable oi = Observable.fromIterable(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9)).take(2); Subscriber mockObserver = TestHelper.mockSubscriber(); - oi.subscribe(new TestSubscriber(mockObserver)); + oi.subscribe(new TestSubscriber<>(mockObserver)); InOrder inOrder = inOrder(mockObserver); inOrder.verify(mockObserver, times(1)).onNext(1); @@ -128,14 +128,14 @@ public void testWrappingMockWhenUnsubscribeInvolved() { @Test public void testAssertError() { RuntimeException e = new RuntimeException("Oops"); - TestSubscriber subscriber = new TestSubscriber(); + TestSubscriber subscriber = new TestSubscriber<>(); Observable.error(e).subscribe(subscriber); subscriber.assertError(e); } @Test public void testAwaitTerminalEventWithDuration() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); Observable.just(1).subscribe(ts); ts.awaitTerminalEvent(1, TimeUnit.SECONDS); ts.assertTerminated(); @@ -143,16 +143,11 @@ public void testAwaitTerminalEventWithDuration() { @Test public void testAwaitTerminalEventWithDurationAndUnsubscribeOnTimeout() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); final AtomicBoolean unsub = new AtomicBoolean(false); Observable.just(1) // - .doOnCancel(new Runnable() { - @Override - public void run() { - unsub.set(true); - } - }) + .doOnCancel(() -> unsub.set(true)) // .delay(1000, TimeUnit.MILLISECONDS).subscribe(ts); ts.awaitTerminalEvent(100, TimeUnit.MILLISECONDS); @@ -162,28 +157,28 @@ public void run() { @Test(expected = NullPointerException.class) public void testNullDelegate1() { - TestSubscriber ts = new TestSubscriber((Observer)null); + TestSubscriber ts = new TestSubscriber<>((Observer) null); ts.onComplete(); } @Test(expected = NullPointerException.class) public void testNullDelegate2() { - TestSubscriber ts = new TestSubscriber((Subscriber)null); + TestSubscriber ts = new TestSubscriber<>((Subscriber) null); ts.onComplete(); } @Test(expected = NullPointerException.class) public void testNullDelegate3() { - TestSubscriber ts = new TestSubscriber((Subscriber)null, null); + TestSubscriber ts = new TestSubscriber<>(null, null); ts.onComplete(); } @Test public void testDelegate1() { - TestSubscriber to = new TestSubscriber(); + TestSubscriber to = new TestSubscriber<>(); to.onSubscribe(EmptySubscription.INSTANCE); - TestSubscriber ts = new TestSubscriber(to); + TestSubscriber ts = new TestSubscriber<>(to); ts.onComplete(); to.assertTerminated(); @@ -191,8 +186,8 @@ public void testDelegate1() { @Test public void testDelegate2() { - TestSubscriber ts1 = new TestSubscriber(); - TestSubscriber ts2 = new TestSubscriber(ts1); + TestSubscriber ts1 = new TestSubscriber<>(); + TestSubscriber ts2 = new TestSubscriber<>(ts1); ts2.onComplete(); ts1.assertComplete(); @@ -200,21 +195,21 @@ public void testDelegate2() { @Test public void testDelegate3() { - TestSubscriber ts1 = new TestSubscriber(); - TestSubscriber ts2 = new TestSubscriber(ts1, null); + TestSubscriber ts1 = new TestSubscriber<>(); + TestSubscriber ts2 = new TestSubscriber<>(ts1, null); ts2.onComplete(); ts1.assertComplete(); } @Test public void testUnsubscribed() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); assertFalse(ts.isCancelled()); } @Test public void testNoErrors() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); ts.onError(new TestException()); try { ts.assertNoErrors(); @@ -227,7 +222,7 @@ public void testNoErrors() { @Test public void testNotCompleted() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); try { ts.assertComplete(); } catch (AssertionError ex) { @@ -239,7 +234,7 @@ public void testNotCompleted() { @Test public void testMultipleCompletions() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); ts.onComplete(); ts.onComplete(); try { @@ -253,7 +248,7 @@ public void testMultipleCompletions() { @Test public void testCompleted() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); ts.onComplete(); try { ts.assertNotComplete(); @@ -266,7 +261,7 @@ public void testCompleted() { @Test public void testMultipleCompletions2() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); ts.onComplete(); ts.onComplete(); try { @@ -280,7 +275,7 @@ public void testMultipleCompletions2() { @Test public void testMultipleErrors() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); ts.onSubscribe(EmptySubscription.INSTANCE); ts.onError(new TestException()); ts.onError(new TestException()); @@ -304,7 +299,7 @@ public void testMultipleErrors() { @Test public void testMultipleErrors2() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); ts.onSubscribe(EmptySubscription.INSTANCE); ts.onError(new TestException()); ts.onError(new TestException()); @@ -325,7 +320,7 @@ public void testMultipleErrors2() { @Test public void testMultipleErrors3() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); ts.onSubscribe(EmptySubscription.INSTANCE); ts.onError(new TestException()); ts.onError(new TestException()); @@ -346,7 +341,7 @@ public void testMultipleErrors3() { @Test public void testDifferentError() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); ts.onError(new TestException()); try { ts.assertError(new TestException()); @@ -359,7 +354,7 @@ public void testDifferentError() { @Test public void testDifferentError2() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); ts.onError(new RuntimeException()); try { ts.assertError(new TestException()); @@ -372,7 +367,7 @@ public void testDifferentError2() { @Test public void testDifferentError3() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); ts.onError(new RuntimeException()); try { ts.assertError(TestException.class); @@ -385,7 +380,7 @@ public void testDifferentError3() { @Test public void testNoError() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); try { ts.assertError(TestException.class); } catch (AssertionError ex) { @@ -397,7 +392,7 @@ public void testNoError() { @Test public void testNoError2() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); try { ts.assertError(new TestException()); } catch (AssertionError ex) { @@ -409,17 +404,12 @@ public void testNoError2() { @Test public void testInterruptTerminalEventAwait() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); final Thread t0 = Thread.currentThread(); Worker w = Schedulers.computation().createWorker(); try { - w.schedule(new Runnable() { - @Override - public void run() { - t0.interrupt(); - } - }, 200, TimeUnit.MILLISECONDS); + w.schedule(t0::interrupt, 200, TimeUnit.MILLISECONDS); try { if (ts.awaitTerminalEvent()) { @@ -437,17 +427,12 @@ public void run() { @Test public void testInterruptTerminalEventAwaitTimed() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); final Thread t0 = Thread.currentThread(); Worker w = Schedulers.computation().createWorker(); try { - w.schedule(new Runnable() { - @Override - public void run() { - t0.interrupt(); - } - }, 200, TimeUnit.MILLISECONDS); + w.schedule(t0::interrupt, 200, TimeUnit.MILLISECONDS); try { if (ts.awaitTerminalEvent(5, TimeUnit.SECONDS)) { @@ -466,17 +451,12 @@ public void run() { @Test public void testInterruptTerminalEventAwaitAndUnsubscribe() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); final Thread t0 = Thread.currentThread(); Worker w = Schedulers.computation().createWorker(); try { - w.schedule(new Runnable() { - @Override - public void run() { - t0.interrupt(); - } - }, 200, TimeUnit.MILLISECONDS); + w.schedule(t0::interrupt, 200, TimeUnit.MILLISECONDS); ts.awaitTerminalEvent(5, TimeUnit.SECONDS); ts.dispose(); @@ -490,7 +470,7 @@ public void run() { @Test public void testNoTerminalEventBut1Completed() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); ts.onComplete(); @@ -504,7 +484,7 @@ public void testNoTerminalEventBut1Completed() { @Test public void testNoTerminalEventBut1Error() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); ts.onError(new TestException()); @@ -518,7 +498,7 @@ public void testNoTerminalEventBut1Error() { @Test public void testNoTerminalEventBut1Error1Completed() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); ts.onComplete(); ts.onError(new TestException()); @@ -533,7 +513,7 @@ public void testNoTerminalEventBut1Error1Completed() { @Test public void testNoTerminalEventBut2Errors() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); ts.onSubscribe(EmptySubscription.INSTANCE); ts.onError(new TestException()); @@ -555,7 +535,7 @@ public void testNoTerminalEventBut2Errors() { @Test public void testNoValues() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); ts.onNext(1); try { @@ -568,7 +548,7 @@ public void testNoValues() { @Test public void testValueCount() { - TestSubscriber ts = new TestSubscriber(); + TestSubscriber ts = new TestSubscriber<>(); ts.onNext(1); ts.onNext(2); @@ -588,7 +568,7 @@ public void onComplete() { throw new TestException(); } }; - TestSubscriber ts = new TestSubscriber(to); + TestSubscriber ts = new TestSubscriber<>(to); try { ts.onComplete(); @@ -607,7 +587,7 @@ public void onError(Throwable e) { throw new TestException(); } }; - TestSubscriber ts = new TestSubscriber(to); + TestSubscriber ts = new TestSubscriber<>(to); try { ts.onError(new RuntimeException()); diff --git a/settings.gradle b/settings.gradle index c5620daef9..a32ffd0bfa 100644 --- a/settings.gradle +++ b/settings.gradle @@ -1 +1,3 @@ -rootProject.name='rxjava' +rootProject.name='RxJava' +include 'rxjava' +include 'rxjava-java6' \ No newline at end of file diff --git a/src/main/java/io/reactivex/internal/functions/Functions.java b/src/main/java/io/reactivex/internal/functions/Functions.java deleted file mode 100644 index 2f67b26d74..0000000000 --- a/src/main/java/io/reactivex/internal/functions/Functions.java +++ /dev/null @@ -1,253 +0,0 @@ -/** - * Copyright 2016 Netflix, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in - * compliance with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is - * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See - * the License for the specific language governing permissions and limitations under the License. - */ -package io.reactivex.internal.functions; - -import java.util.Comparator; - -import io.reactivex.functions.*; - -/** - * Utility methods to convert the Function3..Function9 instances to Function of Object array. - */ -public enum Functions { - ; - - @SuppressWarnings("unchecked") - public static Function toFunction(final BiFunction biFunction) { - Objects.requireNonNull(biFunction, "biFunction is null"); - return new Function() { - @Override - public R apply(Object[] a) { - if (a.length != 2) { - throw new IllegalArgumentException("Array of size 2 expected but got " + a.length); - } - return ((BiFunction)biFunction).apply(a[0], a[1]); - } - }; - } - - public static Function toFunction(final Function3 f) { - Objects.requireNonNull(f, "f is null"); - return new Function() { - @SuppressWarnings("unchecked") - @Override - public R apply(Object[] a) { - if (a.length != 3) { - throw new IllegalArgumentException("Array of size 3 expected but got " + a.length); - } - return f.apply((T1)a[0], (T2)a[1], (T3)a[2]); - } - }; - } - - public static Function toFunction(final Function4 f) { - Objects.requireNonNull(f, "f is null"); - return new Function() { - @SuppressWarnings("unchecked") - @Override - public R apply(Object[] a) { - if (a.length != 4) { - throw new IllegalArgumentException("Array of size 4 expected but got " + a.length); - } - return f.apply((T1)a[0], (T2)a[1], (T3)a[2], (T4)a[3]); - } - }; - } - - public static Function toFunction(final Function5 f) { - Objects.requireNonNull(f, "f is null"); - return new Function() { - @SuppressWarnings("unchecked") - @Override - public R apply(Object[] a) { - if (a.length != 5) { - throw new IllegalArgumentException("Array of size 5 expected but got " + a.length); - } - return f.apply((T1)a[0], (T2)a[1], (T3)a[2], (T4)a[3], (T5)a[4]); - } - }; - } - - public static Function toFunction( - final Function6 f) { - Objects.requireNonNull(f, "f is null"); - return new Function() { - @SuppressWarnings("unchecked") - @Override - public R apply(Object[] a) { - if (a.length != 6) { - throw new IllegalArgumentException("Array of size 6 expected but got " + a.length); - } - return f.apply((T1)a[0], (T2)a[1], (T3)a[2], (T4)a[3], (T5)a[4], (T6)a[5]); - } - }; - } - - public static Function toFunction( - final Function7 f) { - Objects.requireNonNull(f, "f is null"); - return new Function() { - @SuppressWarnings("unchecked") - @Override - public R apply(Object[] a) { - if (a.length != 7) { - throw new IllegalArgumentException("Array of size 7 expected but got " + a.length); - } - return f.apply((T1)a[0], (T2)a[1], (T3)a[2], (T4)a[3], (T5)a[4], (T6)a[5], (T7)a[6]); - } - }; - } - - public static Function toFunction( - final Function8 f) { - Objects.requireNonNull(f, "f is null"); - return new Function() { - @SuppressWarnings("unchecked") - @Override - public R apply(Object[] a) { - if (a.length != 8) { - throw new IllegalArgumentException("Array of size 8 expected but got " + a.length); - } - return f.apply((T1)a[0], (T2)a[1], (T3)a[2], (T4)a[3], (T5)a[4], (T6)a[5], (T7)a[6], (T8)a[7]); - } - }; - } - - public static Function toFunction( - final Function9 f) { - Objects.requireNonNull(f, "f is null"); - return new Function() { - @SuppressWarnings("unchecked") - @Override - public R apply(Object[] a) { - if (a.length != 9) { - throw new IllegalArgumentException("Array of size 9 expected but got " + a.length); - } - return f.apply((T1)a[0], (T2)a[1], (T3)a[2], (T4)a[3], (T5)a[4], (T6)a[5], (T7)a[6], (T8)a[7], (T9)a[8]); - } - }; - } - - /** A singleton identity function. */ - static final Function IDENTITY = new Function() { - @Override - public Object apply(Object v) { - return v; - } - }; - - /** - * Returns an identity function that simply returns its argument. - * @param the input and output value type - * @return the identity function - */ - @SuppressWarnings("unchecked") - public static Function identity() { - return (Function)IDENTITY; - } - - static final Runnable EMPTY = new Runnable() { - @Override - public void run() { } - }; - - /** - * Returns an empty runnable that does nothing. - * @return an empty runnable that does nothing - */ - public static Runnable emptyRunnable() { - return EMPTY; - } - - static final Consumer EMPTY_CONSUMER = new Consumer() { - @Override - public void accept(Object v) { } - }; - - /** - * Returns an empty consumer that does nothing. - * @param the consumed value type, the value is ignored - * @return an empty consumer that does nothing. - */ - @SuppressWarnings("unchecked") - public static Consumer emptyConsumer() { - return (Consumer)EMPTY_CONSUMER; - } - - static final LongConsumer EMPTY_LONGCONSUMER = new LongConsumer() { - @Override - public void accept(long v) { } - }; - - /** - * Returns an empty long consumer that does nothing. - * @return an empty long consumer that does nothing. - */ - public static LongConsumer emptyLongConsumer() { - return EMPTY_LONGCONSUMER; - } - - static final Predicate ALWAYS_TRUE = new Predicate() { - @Override - public boolean test(Object o) { - return true; - } - }; - - static final Predicate ALWAYS_FALSE = new Predicate() { - @Override - public boolean test(Object o) { - return true; - } - }; - - static final Supplier NULL_SUPPLIER = new Supplier() { - @Override - public Object get() { - return null; - } - }; - - static final Comparator NATURAL_COMPARATOR = new Comparator() { - @SuppressWarnings({ "unchecked", "rawtypes" }) - @Override - public int compare(Object a, Object b) { - return ((Comparable)a).compareTo(b); - } - }; - - @SuppressWarnings("unchecked") - public static Predicate alwaysTrue() { - return (Predicate)ALWAYS_TRUE; - } - - @SuppressWarnings("unchecked") - public static Predicate alwaysFalse() { - return (Predicate)ALWAYS_FALSE; - } - - @SuppressWarnings("unchecked") - public static Supplier nullSupplier() { - return (Supplier)NULL_SUPPLIER; - } - - /** - * Returns a natural order comparator which casts the parameters to Comparable. - * @param the value type - * @return a natural order comparator which casts the parameters to Comparable - */ - @SuppressWarnings("unchecked") - public static Comparator naturalOrder() { - return (Comparator)NATURAL_COMPARATOR; - } -} diff --git a/src/test/java/io/reactivex/CombineLatestTests.java b/src/test/java/io/reactivex/CombineLatestTests.java deleted file mode 100644 index a33d3b6ed9..0000000000 --- a/src/test/java/io/reactivex/CombineLatestTests.java +++ /dev/null @@ -1,87 +0,0 @@ -/** - * Copyright 2016 Netflix, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package io.reactivex; - -import static io.reactivex.Observable.combineLatest; -import static org.junit.Assert.assertNull; - -import org.junit.*; - -import io.reactivex.Observable; -import io.reactivex.CovarianceTest.*; -import io.reactivex.functions.*; -import io.reactivex.subjects.BehaviorSubject; - -public class CombineLatestTests { - /** - * This won't compile if super/extends isn't done correctly on generics - */ - @Test - public void testCovarianceOfCombineLatest() { - Observable horrors = Observable.just(new HorrorMovie()); - Observable ratings = Observable.just(new CoolRating()); - - Observable. combineLatest(horrors, ratings, combine).toBlocking().forEach(action); - Observable. combineLatest(horrors, ratings, combine).toBlocking().forEach(action); - Observable. combineLatest(horrors, ratings, combine).toBlocking().forEach(extendedAction); - Observable. combineLatest(horrors, ratings, combine).toBlocking().forEach(action); - Observable. combineLatest(horrors, ratings, combine).toBlocking().forEach(action); - - Observable. combineLatest(horrors, ratings, combine); - } - - BiFunction combine = new BiFunction() { - @Override - public ExtendedResult apply(Media m, Rating r) { - return new ExtendedResult(); - } - }; - - Consumer action = new Consumer() { - @Override - public void accept(Result t1) { - System.out.println("Result: " + t1); - } - }; - - Consumer extendedAction = new Consumer() { - @Override - public void accept(ExtendedResult t1) { - System.out.println("Result: " + t1); - } - }; - - @Ignore - @Test - public void testNullEmitting() throws Exception { - // FIXME this is no longer allowed - Observable nullObservable = BehaviorSubject.createDefault((Boolean) null); - Observable nonNullObservable = BehaviorSubject.createDefault(true); - Observable combined = - combineLatest(nullObservable, nonNullObservable, new BiFunction() { - @Override - public Boolean apply(Boolean bool1, Boolean bool2) { - return bool1 == null ? null : bool2; - } - }); - combined.subscribe(new Consumer() { - @Override - public void accept(Boolean aBoolean) { - assertNull(aBoolean); - } - }); - } -} \ No newline at end of file diff --git a/src/test/java/io/reactivex/CovarianceTest.java b/src/test/java/io/reactivex/CovarianceTest.java deleted file mode 100644 index 3f5ddc4df4..0000000000 --- a/src/test/java/io/reactivex/CovarianceTest.java +++ /dev/null @@ -1,256 +0,0 @@ -/** - * Copyright 2016 Netflix, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package io.reactivex; - -import static org.junit.Assert.assertEquals; - -import java.util.*; - -import org.junit.Test; -import org.reactivestreams.Publisher; - -import io.reactivex.Observable; -import io.reactivex.Observable.Transformer; -import io.reactivex.functions.*; -import io.reactivex.observables.GroupedObservable; -import io.reactivex.subscribers.TestSubscriber; - -/** - * Test super/extends of generics. - * - * See https://github.com/Netflix/RxJava/pull/331 - */ -public class CovarianceTest { - - /** - * This won't compile if super/extends isn't done correctly on generics - */ - @Test - public void testCovarianceOfFrom() { - Observable. just(new HorrorMovie()); - Observable. fromIterable(new ArrayList()); - // Observable.from(new Movie()); // may not compile - } - - @Test - public void testSortedList() { - Comparator SORT_FUNCTION = new Comparator() { - @Override - public int compare(Media t1, Media t2) { - return 1; - } - }; - - // this one would work without the covariance generics - Observable o = Observable.just(new Movie(), new TVSeason(), new Album()); - o.toSortedList(SORT_FUNCTION); - - // this one would NOT work without the covariance generics - Observable o2 = Observable.just(new Movie(), new ActionMovie(), new HorrorMovie()); - o2.toSortedList(SORT_FUNCTION); - } - - @Test - public void testGroupByCompose() { - Observable movies = Observable.just(new HorrorMovie(), new ActionMovie(), new Movie()); - TestSubscriber ts = new TestSubscriber(); - - movies - .groupBy(new Function() { - @Override - public Object apply(Movie v) { - return v.getClass(); - } - }) - .doOnNext(new Consumer>() { - @Override - public void accept(GroupedObservable g) { - System.out.println(g.key()); - } - }) - .flatMap(new Function, Publisher>() { - @Override - public Publisher apply(GroupedObservable g) { - return g - .doOnNext(new Consumer() { - @Override - public void accept(Movie v) { - System.out.println(v); - } - }) - .compose(new Transformer() { - @Override - public Publisher apply(Observable m) { - return m.concatWith(Observable.just(new ActionMovie())); - } - } - ) - .map(new Function() { - @Override - public String apply(Object v) { - return v.toString(); - } - }); - } - }) - .subscribe(ts); - ts.assertTerminated(); - ts.assertNoErrors(); - // System.out.println(ts.getOnNextEvents()); - assertEquals(6, ts.valueCount()); - } - - @SuppressWarnings("unused") - @Test - public void testCovarianceOfCompose() { - Observable movie = Observable.just(new HorrorMovie()); - Observable movie2 = movie.compose(new Transformer() { - @Override - public Publisher apply(Observable t) { - return Observable.just(new Movie()); - } - }); - } - - @SuppressWarnings("unused") - @Test - public void testCovarianceOfCompose2() { - Observable movie = Observable. just(new HorrorMovie()); - Observable movie2 = movie.compose(new Transformer() { - @Override - public Publisher apply(Observable t) { - return Observable.just(new HorrorMovie()); - } - }); - } - - @SuppressWarnings("unused") - @Test - public void testCovarianceOfCompose3() { - Observable movie = Observable.just(new HorrorMovie()); - Observable movie2 = movie.compose(new Transformer() { - @Override - public Publisher apply(Observable t) { - return Observable.just(new HorrorMovie()).map(new Function() { - @Override - public HorrorMovie apply(HorrorMovie v) { - return v; - } - }); - } - } - ); - } - - @SuppressWarnings("unused") - @Test - public void testCovarianceOfCompose4() { - Observable movie = Observable.just(new HorrorMovie()); - Observable movie2 = movie.compose(new Transformer() { - @Override - public Publisher apply(Observable t1) { - return t1.map(new Function() { - @Override - public HorrorMovie apply(HorrorMovie v) { - return v; - } - }); - } - }); - } - - @Test - public void testComposeWithDeltaLogic() { - List list1 = Arrays.asList(new Movie(), new HorrorMovie(), new ActionMovie()); - List list2 = Arrays.asList(new ActionMovie(), new Movie(), new HorrorMovie(), new ActionMovie()); - Observable> movies = Observable.just(list1, list2); - movies.compose(deltaTransformer); - } - - static Function>, Observable> calculateDelta = new Function>, Observable>() { - @Override - public Observable apply(List> listOfLists) { - if (listOfLists.size() == 1) { - return Observable.fromIterable(listOfLists.get(0)); - } else { - // diff the two - List newList = listOfLists.get(1); - List oldList = new ArrayList(listOfLists.get(0)); - - Set delta = new LinkedHashSet(); - delta.addAll(newList); - // remove all that match in old - delta.removeAll(oldList); - - // filter oldList to those that aren't in the newList - oldList.removeAll(newList); - - // for all left in the oldList we'll create DROP events - for (@SuppressWarnings("unused") Movie old : oldList) { - delta.add(new Movie()); - } - - return Observable.fromIterable(delta); - } - } - }; - - static Transformer, Movie> deltaTransformer = new Transformer, Movie>() { - @Override - public Publisher apply(Observable> movieList) { - return movieList - .startWith(new ArrayList()) - .buffer(2, 1) - .skip(1) - .flatMap(calculateDelta); - } - }; - - /* - * Most tests are moved into their applicable classes such as [Operator]Tests.java - */ - - static class Media { - } - - static class Movie extends Media { - } - - static class HorrorMovie extends Movie { - } - - static class ActionMovie extends Movie { - } - - static class Album extends Media { - } - - static class TVSeason extends Media { - } - - static class Rating { - } - - static class CoolRating extends Rating { - } - - static class Result { - } - - static class ExtendedResult extends Result { - } -} diff --git a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorGroupByTest.java b/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorGroupByTest.java deleted file mode 100644 index bcbfb4878b..0000000000 --- a/src/test/java/io/reactivex/internal/operators/nbp/NbpOperatorGroupByTest.java +++ /dev/null @@ -1,1446 +0,0 @@ -/** - * Copyright 2016 Netflix, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in - * compliance with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software distributed under the License is - * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See - * the License for the specific language governing permissions and limitations under the License. - */ - -package io.reactivex.internal.operators.nbp; - -import static org.junit.Assert.*; -import static org.mockito.Matchers.*; -import static org.mockito.Mockito.*; - -import java.util.*; -import java.util.concurrent.*; -import java.util.concurrent.atomic.*; - -import org.junit.Test; -import org.mockito.Matchers; - -import io.reactivex.*; -import io.reactivex.NbpObservable.*; -import io.reactivex.disposables.*; -import io.reactivex.exceptions.TestException; -import io.reactivex.functions.*; -import io.reactivex.internal.disposables.EmptyDisposable; -import io.reactivex.observables.nbp.NbpGroupedObservable; -import io.reactivex.schedulers.Schedulers; -import io.reactivex.subscribers.nbp.NbpTestSubscriber; -import io.reactivex.Optional; - -public class NbpOperatorGroupByTest { - - final Function length = new Function() { - @Override - public Integer apply(String s) { - return s.length(); - } - }; - - @Test - public void testGroupBy() { - NbpObservable source = NbpObservable.just("one", "two", "three", "four", "five", "six"); - NbpObservable> grouped = source.groupBy(length); - - Map> map = toMap(grouped); - - assertEquals(3, map.size()); - assertArrayEquals(Arrays.asList("one", "two", "six").toArray(), map.get(3).toArray()); - assertArrayEquals(Arrays.asList("four", "five").toArray(), map.get(4).toArray()); - assertArrayEquals(Arrays.asList("three").toArray(), map.get(5).toArray()); - } - - @Test - public void testGroupByWithElementSelector() { - NbpObservable source = NbpObservable.just("one", "two", "three", "four", "five", "six"); - NbpObservable> grouped = source.groupBy(length, length); - - Map> map = toMap(grouped); - - assertEquals(3, map.size()); - assertArrayEquals(Arrays.asList(3, 3, 3).toArray(), map.get(3).toArray()); - assertArrayEquals(Arrays.asList(4, 4).toArray(), map.get(4).toArray()); - assertArrayEquals(Arrays.asList(5).toArray(), map.get(5).toArray()); - } - - @Test - public void testGroupByWithElementSelector2() { - NbpObservable source = NbpObservable.just("one", "two", "three", "four", "five", "six"); - NbpObservable> grouped = source.groupBy(length, length); - - Map> map = toMap(grouped); - - assertEquals(3, map.size()); - assertArrayEquals(Arrays.asList(3, 3, 3).toArray(), map.get(3).toArray()); - assertArrayEquals(Arrays.asList(4, 4).toArray(), map.get(4).toArray()); - assertArrayEquals(Arrays.asList(5).toArray(), map.get(5).toArray()); - } - - @Test - public void testEmpty() { - NbpObservable source = NbpObservable.empty(); - NbpObservable> grouped = source.groupBy(length); - - Map> map = toMap(grouped); - - assertTrue(map.isEmpty()); - } - - @Test - public void testError() { - NbpObservable sourceStrings = NbpObservable.just("one", "two", "three", "four", "five", "six"); - NbpObservable errorSource = NbpObservable.error(new RuntimeException("forced failure")); - NbpObservable source = NbpObservable.concat(sourceStrings, errorSource); - - NbpObservable> grouped = source.groupBy(length); - - final AtomicInteger groupCounter = new AtomicInteger(); - final AtomicInteger eventCounter = new AtomicInteger(); - final AtomicReference error = new AtomicReference(); - - grouped.flatMap(new Function, NbpObservable>() { - - @Override - public NbpObservable apply(final NbpGroupedObservable o) { - groupCounter.incrementAndGet(); - return o.map(new Function() { - - @Override - public String apply(String v) { - return "Event => key: " + o.getKey() + " value: " + v; - } - }); - } - }).subscribe(new NbpObserver() { - - @Override - public void onComplete() { - - } - - @Override - public void onError(Throwable e) { - e.printStackTrace(); - error.set(e); - } - - @Override - public void onNext(String v) { - eventCounter.incrementAndGet(); - System.out.println(v); - - } - }); - - assertEquals(3, groupCounter.get()); - assertEquals(6, eventCounter.get()); - assertNotNull(error.get()); - } - - private static Map> toMap(NbpObservable> NbpObservable) { - - final ConcurrentHashMap> result = new ConcurrentHashMap>(); - - NbpObservable.toBlocking().forEach(new Consumer>() { - - @Override - public void accept(final NbpGroupedObservable o) { - result.put(o.getKey(), new ConcurrentLinkedQueue()); - o.subscribe(new Consumer() { - - @Override - public void accept(V v) { - result.get(o.getKey()).add(v); - } - - }); - } - }); - - return result; - } - - /** - * Assert that only a single subscription to a stream occurs and that all events are received. - * - * @throws Throwable - */ - @Test - public void testGroupedEventStream() throws Throwable { - - final AtomicInteger eventCounter = new AtomicInteger(); - final AtomicInteger subscribeCounter = new AtomicInteger(); - final AtomicInteger groupCounter = new AtomicInteger(); - final CountDownLatch latch = new CountDownLatch(1); - final int count = 100; - final int groupCount = 2; - - NbpObservable es = NbpObservable.create(new NbpOnSubscribe() { - - @Override - public void accept(final NbpSubscriber NbpObserver) { - NbpObserver.onSubscribe(EmptyDisposable.INSTANCE); - System.out.println("*** Subscribing to EventStream ***"); - subscribeCounter.incrementAndGet(); - new Thread(new Runnable() { - - @Override - public void run() { - for (int i = 0; i < count; i++) { - Event e = new Event(); - e.source = i % groupCount; - e.message = "Event-" + i; - NbpObserver.onNext(e); - } - NbpObserver.onComplete(); - } - - }).start(); - } - - }); - - es.groupBy(new Function() { - - @Override - public Integer apply(Event e) { - return e.source; - } - }).flatMap(new Function, NbpObservable>() { - - @Override - public NbpObservable apply(NbpGroupedObservable eventGroupedObservable) { - System.out.println("NbpGroupedObservable Key: " + eventGroupedObservable.getKey()); - groupCounter.incrementAndGet(); - - return eventGroupedObservable.map(new Function() { - - @Override - public String apply(Event event) { - return "Source: " + event.source + " Message: " + event.message; - } - }); - - } - }).subscribe(new NbpObserver() { - - @Override - public void onComplete() { - latch.countDown(); - } - - @Override - public void onError(Throwable e) { - e.printStackTrace(); - latch.countDown(); - } - - @Override - public void onNext(String outputMessage) { - System.out.println(outputMessage); - eventCounter.incrementAndGet(); - } - }); - - latch.await(5000, TimeUnit.MILLISECONDS); - assertEquals(1, subscribeCounter.get()); - assertEquals(groupCount, groupCounter.get()); - assertEquals(count, eventCounter.get()); - - } - - /* - * We will only take 1 group with 20 events from it and then unsubscribe. - */ - @Test - public void testUnsubscribeOnNestedTakeAndSyncInfiniteStream() throws InterruptedException { - final AtomicInteger subscribeCounter = new AtomicInteger(); - final AtomicInteger sentEventCounter = new AtomicInteger(); - doTestUnsubscribeOnNestedTakeAndAsyncInfiniteStream(SYNC_INFINITE_OBSERVABLE_OF_EVENT(2, subscribeCounter, sentEventCounter), subscribeCounter); - Thread.sleep(500); - assertEquals(39, sentEventCounter.get()); - } - - /* - * We will only take 1 group with 20 events from it and then unsubscribe. - */ - @Test - public void testUnsubscribeOnNestedTakeAndAsyncInfiniteStream() throws InterruptedException { - final AtomicInteger subscribeCounter = new AtomicInteger(); - final AtomicInteger sentEventCounter = new AtomicInteger(); - doTestUnsubscribeOnNestedTakeAndAsyncInfiniteStream(ASYNC_INFINITE_OBSERVABLE_OF_EVENT(2, subscribeCounter, sentEventCounter), subscribeCounter); - Thread.sleep(500); - assertEquals(39, sentEventCounter.get()); - } - - private void doTestUnsubscribeOnNestedTakeAndAsyncInfiniteStream(NbpObservable es, AtomicInteger subscribeCounter) throws InterruptedException { - final AtomicInteger eventCounter = new AtomicInteger(); - final AtomicInteger groupCounter = new AtomicInteger(); - final CountDownLatch latch = new CountDownLatch(1); - - es.groupBy(new Function() { - - @Override - public Integer apply(Event e) { - return e.source; - } - }) - .take(1) // we want only the first group - .flatMap(new Function, NbpObservable>() { - - @Override - public NbpObservable apply(NbpGroupedObservable eventGroupedObservable) { - System.out.println("testUnsubscribe => NbpGroupedObservable Key: " + eventGroupedObservable.getKey()); - groupCounter.incrementAndGet(); - - return eventGroupedObservable - .take(20) // limit to only 20 events on this group - .map(new Function() { - - @Override - public String apply(Event event) { - return "testUnsubscribe => Source: " + event.source + " Message: " + event.message; - } - }); - - } - }).subscribe(new NbpObserver() { - - @Override - public void onComplete() { - latch.countDown(); - } - - @Override - public void onError(Throwable e) { - e.printStackTrace(); - latch.countDown(); - } - - @Override - public void onNext(String outputMessage) { - System.out.println(outputMessage); - eventCounter.incrementAndGet(); - } - }); - - if (!latch.await(2000, TimeUnit.MILLISECONDS)) { - fail("timed out so likely did not unsubscribe correctly"); - } - assertEquals(1, subscribeCounter.get()); - assertEquals(1, groupCounter.get()); - assertEquals(20, eventCounter.get()); - // sentEvents will go until 'eventCounter' hits 20 and then unsubscribes - // which means it will also send (but ignore) the 19/20 events for the other group - // It will not however send all 100 events. - } - - @Test - public void testUnsubscribeViaTakeOnGroupThenMergeAndTake() { - final AtomicInteger subscribeCounter = new AtomicInteger(); - final AtomicInteger sentEventCounter = new AtomicInteger(); - final AtomicInteger eventCounter = new AtomicInteger(); - - SYNC_INFINITE_OBSERVABLE_OF_EVENT(4, subscribeCounter, sentEventCounter) - .groupBy(new Function() { - - @Override - public Integer apply(Event e) { - return e.source; - } - }) - // take 2 of the 4 groups - .take(2) - .flatMap(new Function, NbpObservable>() { - - @Override - public NbpObservable apply(NbpGroupedObservable eventGroupedObservable) { - return eventGroupedObservable - .map(new Function() { - - @Override - public String apply(Event event) { - return "testUnsubscribe => Source: " + event.source + " Message: " + event.message; - } - }); - - } - }) - .take(30).subscribe(new Consumer() { - - @Override - public void accept(String s) { - eventCounter.incrementAndGet(); - System.out.println("=> " + s); - } - - }); - - assertEquals(30, eventCounter.get()); - // we should send 28 additional events that are filtered out as they are in the groups we skip - assertEquals(58, sentEventCounter.get()); - } - - @Test - public void testUnsubscribeViaTakeOnGroupThenTakeOnInner() { - final AtomicInteger subscribeCounter = new AtomicInteger(); - final AtomicInteger sentEventCounter = new AtomicInteger(); - final AtomicInteger eventCounter = new AtomicInteger(); - - SYNC_INFINITE_OBSERVABLE_OF_EVENT(4, subscribeCounter, sentEventCounter) - .groupBy(new Function() { - - @Override - public Integer apply(Event e) { - return e.source; - } - }) - // take 2 of the 4 groups - .take(2) - .flatMap(new Function, NbpObservable>() { - - @Override - public NbpObservable apply(NbpGroupedObservable eventGroupedObservable) { - int numToTake = 0; - if (eventGroupedObservable.getKey() == 1) { - numToTake = 10; - } else if (eventGroupedObservable.getKey() == 2) { - numToTake = 5; - } - return eventGroupedObservable - .take(numToTake) - .map(new Function() { - - @Override - public String apply(Event event) { - return "testUnsubscribe => Source: " + event.source + " Message: " + event.message; - } - }); - - } - }) - .subscribe(new Consumer() { - - @Override - public void accept(String s) { - eventCounter.incrementAndGet(); - System.out.println("=> " + s); - } - - }); - - assertEquals(15, eventCounter.get()); - // we should send 22 additional events that are filtered out as they are skipped while taking the 15 we want - assertEquals(37, sentEventCounter.get()); - } - - @Test - public void testStaggeredCompletion() throws InterruptedException { - final AtomicInteger eventCounter = new AtomicInteger(); - final CountDownLatch latch = new CountDownLatch(1); - NbpObservable.range(0, 100) - .groupBy(new Function() { - - @Override - public Integer apply(Integer i) { - return i % 2; - } - }) - .flatMap(new Function, NbpObservable>() { - - @Override - public NbpObservable apply(NbpGroupedObservable group) { - if (group.getKey() == 0) { - return group.delay(100, TimeUnit.MILLISECONDS).map(new Function() { - @Override - public Integer apply(Integer t) { - return t * 10; - } - - }); - } else { - return group; - } - } - }) - .subscribe(new NbpObserver() { - - @Override - public void onComplete() { - System.out.println("=> onCompleted"); - latch.countDown(); - } - - @Override - public void onError(Throwable e) { - e.printStackTrace(); - latch.countDown(); - } - - @Override - public void onNext(Integer s) { - eventCounter.incrementAndGet(); - System.out.println("=> " + s); - } - }); - - if (!latch.await(3000, TimeUnit.MILLISECONDS)) { - fail("timed out"); - } - - assertEquals(100, eventCounter.get()); - } - - @Test(timeout = 1000) - public void testCompletionIfInnerNotSubscribed() throws InterruptedException { - final CountDownLatch latch = new CountDownLatch(1); - final AtomicInteger eventCounter = new AtomicInteger(); - NbpObservable.range(0, 100) - .groupBy(new Function() { - - @Override - public Integer apply(Integer i) { - return i % 2; - } - }) - .subscribe(new NbpObserver>() { - - @Override - public void onComplete() { - latch.countDown(); - } - - @Override - public void onError(Throwable e) { - e.printStackTrace(); - latch.countDown(); - } - - @Override - public void onNext(NbpGroupedObservable s) { - eventCounter.incrementAndGet(); - System.out.println("=> " + s); - } - }); - if (!latch.await(500, TimeUnit.MILLISECONDS)) { - fail("timed out - never got completion"); - } - assertEquals(2, eventCounter.get()); - } - - @Test - public void testIgnoringGroups() { - final AtomicInteger subscribeCounter = new AtomicInteger(); - final AtomicInteger sentEventCounter = new AtomicInteger(); - final AtomicInteger eventCounter = new AtomicInteger(); - - SYNC_INFINITE_OBSERVABLE_OF_EVENT(4, subscribeCounter, sentEventCounter) - .groupBy(new Function() { - - @Override - public Integer apply(Event e) { - return e.source; - } - }) - .flatMap(new Function, NbpObservable>() { - - @Override - public NbpObservable apply(NbpGroupedObservable eventGroupedObservable) { - NbpObservable eventStream = eventGroupedObservable; - if (eventGroupedObservable.getKey() >= 2) { - // filter these - eventStream = eventGroupedObservable.filter(new Predicate() { - @Override - public boolean test(Event t1) { - return false; - } - }); - } - - return eventStream - .map(new Function() { - - @Override - public String apply(Event event) { - return "testUnsubscribe => Source: " + event.source + " Message: " + event.message; - } - }); - - } - }) - .take(30).subscribe(new Consumer() { - - @Override - public void accept(String s) { - eventCounter.incrementAndGet(); - System.out.println("=> " + s); - } - - }); - - assertEquals(30, eventCounter.get()); - // we should send 30 additional events that are filtered out as they are in the groups we skip - assertEquals(60, sentEventCounter.get()); - } - - @Test - public void testFirstGroupsCompleteAndParentSlowToThenEmitFinalGroupsAndThenComplete() throws InterruptedException { - final CountDownLatch first = new CountDownLatch(2); // there are two groups to first complete - final ArrayList results = new ArrayList(); - NbpObservable.create(new NbpOnSubscribe() { - - @Override - public void accept(NbpSubscriber sub) { - sub.onSubscribe(EmptyDisposable.INSTANCE); - sub.onNext(1); - sub.onNext(2); - sub.onNext(1); - sub.onNext(2); - try { - first.await(); - } catch (InterruptedException e) { - sub.onError(e); - return; - } - sub.onNext(3); - sub.onNext(3); - sub.onComplete(); - } - - }).groupBy(new Function() { - - @Override - public Integer apply(Integer t) { - return t; - } - - }).flatMap(new Function, NbpObservable>() { - - @Override - public NbpObservable apply(final NbpGroupedObservable group) { - if (group.getKey() < 3) { - return group.map(new Function() { - - @Override - public String apply(Integer t1) { - return "first groups: " + t1; - } - - }) - // must take(2) so an onCompleted + unsubscribe happens on these first 2 groups - .take(2).doOnComplete(new Runnable() { - - @Override - public void run() { - first.countDown(); - } - - }); - } else { - return group.map(new Function() { - - @Override - public String apply(Integer t1) { - return "last group: " + t1; - } - - }); - } - } - - }).toBlocking().forEach(new Consumer() { - - @Override - public void accept(String s) { - results.add(s); - } - - }); - - System.out.println("Results: " + results); - assertEquals(6, results.size()); - } - - @Test - public void testFirstGroupsCompleteAndParentSlowToThenEmitFinalGroupsWhichThenSubscribesOnAndDelaysAndThenCompletes() throws InterruptedException { - System.err.println("----------------------------------------------------------------------------------------------"); - final CountDownLatch first = new CountDownLatch(2); // there are two groups to first complete - final ArrayList results = new ArrayList(); - NbpObservable.create(new NbpOnSubscribe() { - - @Override - public void accept(NbpSubscriber sub) { - sub.onSubscribe(EmptyDisposable.INSTANCE); - sub.onNext(1); - sub.onNext(2); - sub.onNext(1); - sub.onNext(2); - try { - first.await(); - } catch (InterruptedException e) { - sub.onError(e); - return; - } - sub.onNext(3); - sub.onNext(3); - sub.onComplete(); - } - - }).groupBy(new Function() { - - @Override - public Integer apply(Integer t) { - return t; - } - - }).flatMap(new Function, NbpObservable>() { - - @Override - public NbpObservable apply(final NbpGroupedObservable group) { - if (group.getKey() < 3) { - return group.map(new Function() { - - @Override - public String apply(Integer t1) { - return "first groups: " + t1; - } - - }) - // must take(2) so an onCompleted + unsubscribe happens on these first 2 groups - .take(2).doOnComplete(new Runnable() { - - @Override - public void run() { - first.countDown(); - } - - }); - } else { - return group.subscribeOn(Schedulers.newThread()).delay(400, TimeUnit.MILLISECONDS).map(new Function() { - - @Override - public String apply(Integer t1) { - return "last group: " + t1; - } - - }).doOnEach(new Consumer>>() { - - @Override - public void accept(Try> t1) { - System.err.println("subscribeOn notification => " + t1); - } - - }); - } - } - - }).doOnEach(new Consumer>>() { - - @Override - public void accept(Try> t1) { - System.err.println("outer notification => " + t1); - } - - }).toBlocking().forEach(new Consumer() { - - @Override - public void accept(String s) { - results.add(s); - } - - }); - - System.out.println("Results: " + results); - assertEquals(6, results.size()); - } - - @Test - public void testFirstGroupsCompleteAndParentSlowToThenEmitFinalGroupsWhichThenObservesOnAndDelaysAndThenCompletes() throws InterruptedException { - final CountDownLatch first = new CountDownLatch(2); // there are two groups to first complete - final ArrayList results = new ArrayList(); - NbpObservable.create(new NbpOnSubscribe() { - - @Override - public void accept(NbpSubscriber sub) { - sub.onSubscribe(EmptyDisposable.INSTANCE); - sub.onNext(1); - sub.onNext(2); - sub.onNext(1); - sub.onNext(2); - try { - first.await(); - } catch (InterruptedException e) { - sub.onError(e); - return; - } - sub.onNext(3); - sub.onNext(3); - sub.onComplete(); - } - - }).groupBy(new Function() { - - @Override - public Integer apply(Integer t) { - return t; - } - - }).flatMap(new Function, NbpObservable>() { - - @Override - public NbpObservable apply(final NbpGroupedObservable group) { - if (group.getKey() < 3) { - return group.map(new Function() { - - @Override - public String apply(Integer t1) { - return "first groups: " + t1; - } - - }) - // must take(2) so an onCompleted + unsubscribe happens on these first 2 groups - .take(2).doOnComplete(new Runnable() { - - @Override - public void run() { - first.countDown(); - } - - }); - } else { - return group.observeOn(Schedulers.newThread()).delay(400, TimeUnit.MILLISECONDS).map(new Function() { - - @Override - public String apply(Integer t1) { - return "last group: " + t1; - } - - }); - } - } - - }).toBlocking().forEach(new Consumer() { - - @Override - public void accept(String s) { - results.add(s); - } - - }); - - System.out.println("Results: " + results); - assertEquals(6, results.size()); - } - - @Test - public void testGroupsWithNestedSubscribeOn() throws InterruptedException { - final ArrayList results = new ArrayList(); - NbpObservable.create(new NbpOnSubscribe() { - - @Override - public void accept(NbpSubscriber sub) { - sub.onSubscribe(EmptyDisposable.INSTANCE); - sub.onNext(1); - sub.onNext(2); - sub.onNext(1); - sub.onNext(2); - sub.onComplete(); - } - - }).groupBy(new Function() { - - @Override - public Integer apply(Integer t) { - return t; - } - - }).flatMap(new Function, NbpObservable>() { - - @Override - public NbpObservable apply(final NbpGroupedObservable group) { - return group.subscribeOn(Schedulers.newThread()).map(new Function() { - - @Override - public String apply(Integer t1) { - System.out.println("Received: " + t1 + " on group : " + group.getKey()); - return "first groups: " + t1; - } - - }); - } - - }).doOnEach(new Consumer>>() { - - @Override - public void accept(Try> t1) { - System.out.println("notification => " + t1); - } - - }).toBlocking().forEach(new Consumer() { - - @Override - public void accept(String s) { - results.add(s); - } - - }); - - System.out.println("Results: " + results); - assertEquals(4, results.size()); - } - - @Test - public void testGroupsWithNestedObserveOn() throws InterruptedException { - final ArrayList results = new ArrayList(); - NbpObservable.create(new NbpOnSubscribe() { - - @Override - public void accept(NbpSubscriber sub) { - sub.onSubscribe(EmptyDisposable.INSTANCE); - sub.onNext(1); - sub.onNext(2); - sub.onNext(1); - sub.onNext(2); - sub.onComplete(); - } - - }).groupBy(new Function() { - - @Override - public Integer apply(Integer t) { - return t; - } - - }).flatMap(new Function, NbpObservable>() { - - @Override - public NbpObservable apply(final NbpGroupedObservable group) { - return group.observeOn(Schedulers.newThread()).delay(400, TimeUnit.MILLISECONDS).map(new Function() { - - @Override - public String apply(Integer t1) { - return "first groups: " + t1; - } - - }); - } - - }).toBlocking().forEach(new Consumer() { - - @Override - public void accept(String s) { - results.add(s); - } - - }); - - System.out.println("Results: " + results); - assertEquals(4, results.size()); - } - - private static class Event { - int source; - String message; - - @Override - public String toString() { - return "Event => source: " + source + " message: " + message; - } - } - - NbpObservable ASYNC_INFINITE_OBSERVABLE_OF_EVENT(final int numGroups, final AtomicInteger subscribeCounter, final AtomicInteger sentEventCounter) { - return SYNC_INFINITE_OBSERVABLE_OF_EVENT(numGroups, subscribeCounter, sentEventCounter).subscribeOn(Schedulers.newThread()); - }; - - NbpObservable SYNC_INFINITE_OBSERVABLE_OF_EVENT(final int numGroups, final AtomicInteger subscribeCounter, final AtomicInteger sentEventCounter) { - return NbpObservable.create(new NbpOnSubscribe() { - - @Override - public void accept(final NbpSubscriber op) { - BooleanDisposable bs = new BooleanDisposable(); - op.onSubscribe(bs); - subscribeCounter.incrementAndGet(); - int i = 0; - while (!bs.isDisposed()) { - i++; - Event e = new Event(); - e.source = i % numGroups; - e.message = "Event-" + i; - op.onNext(e); - sentEventCounter.incrementAndGet(); - } - op.onComplete(); - } - - }); - }; - - @Test - public void testGroupByOnAsynchronousSourceAcceptsMultipleSubscriptions() throws InterruptedException { - - // choose an asynchronous source - NbpObservable source = NbpObservable.interval(10, TimeUnit.MILLISECONDS).take(1); - - // apply groupBy to the source - NbpObservable> stream = source.groupBy(IS_EVEN); - - // create two observers - @SuppressWarnings("unchecked") - NbpObserver> o1 = mock(NbpObserver.class); - @SuppressWarnings("unchecked") - NbpObserver> o2 = mock(NbpObserver.class); - - // subscribe with the observers - stream.subscribe(o1); - stream.subscribe(o2); - - // check that subscriptions were successful - verify(o1, never()).onError(Matchers. any()); - verify(o2, never()).onError(Matchers. any()); - } - - private static Function IS_EVEN = new Function() { - - @Override - public Boolean apply(Long n) { - return n % 2 == 0; - } - }; - - private static Function IS_EVEN2 = new Function() { - - @Override - public Boolean apply(Integer n) { - return n % 2 == 0; - } - }; - - @Test - public void testGroupByBackpressure() throws InterruptedException { - - NbpTestSubscriber ts = new NbpTestSubscriber(); - - NbpObservable.range(1, 4000) - .groupBy(IS_EVEN2) - .flatMap(new Function, NbpObservable>() { - - @Override - public NbpObservable apply(final NbpGroupedObservable g) { - return g.observeOn(Schedulers.computation()).map(new Function() { - - @Override - public String apply(Integer l) { - if (g.getKey()) { - try { - Thread.sleep(1); - } catch (InterruptedException e) { - } - return l + " is even."; - } else { - return l + " is odd."; - } - } - - }); - } - - }).subscribe(ts); - ts.awaitTerminalEvent(); - ts.assertNoErrors(); - } - - Function just(final R value) { - return new Function() { - @Override - public R apply(T t1) { - return value; - } - }; - } - - Function fail(T dummy) { - return new Function() { - @Override - public T apply(Integer t1) { - throw new RuntimeException("Forced failure"); - } - }; - } - - Function fail2(R dummy2) { - return new Function() { - @Override - public R apply(T t1) { - throw new RuntimeException("Forced failure"); - } - }; - } - - Function dbl = new Function() { - @Override - public Integer apply(Integer t1) { - return t1 * 2; - } - }; - Function identity = new Function() { - @Override - public Integer apply(Integer v) { - return v; - } - }; - - @Test - public void normalBehavior() { - NbpObservable source = NbpObservable.fromIterable(Arrays.asList( - " foo", - " FoO ", - "baR ", - "foO ", - " Baz ", - " qux ", - " bar", - " BAR ", - "FOO ", - "baz ", - " bAZ ", - " fOo " - )); - - /** - * foo FoO foO FOO fOo - * baR bar BAR - * Baz baz bAZ - * qux - * - */ - Function keysel = new Function() { - @Override - public String apply(String t1) { - return t1.trim().toLowerCase(); - } - }; - Function valuesel = new Function() { - @Override - public String apply(String t1) { - return t1 + t1; - } - }; - - NbpObservable m = source.groupBy(keysel, valuesel) - .flatMap(new Function, NbpObservable>() { - @Override - public NbpObservable apply(final NbpGroupedObservable g) { - System.out.println("-----------> NEXT: " + g.getKey()); - return g.take(2).map(new Function() { - - int count = 0; - - @Override - public String apply(String v) { - System.out.println(v); - return g.getKey() + "-" + count++; - } - - }); - } - }); - - NbpTestSubscriber ts = new NbpTestSubscriber(); - m.subscribe(ts); - ts.awaitTerminalEvent(); - System.out.println("ts .get " + ts.values()); - ts.assertNoErrors(); - assertEquals(ts.values(), - Arrays.asList("foo-0", "foo-1", "bar-0", "foo-0", "baz-0", "qux-0", "bar-1", "bar-0", "foo-1", "baz-1", "baz-0", "foo-0")); - - } - - @Test - public void keySelectorThrows() { - NbpObservable source = NbpObservable.just(0, 1, 2, 3, 4, 5, 6); - - NbpObservable m = source.groupBy(fail(0), dbl).flatMap(FLATTEN_INTEGER); - - NbpTestSubscriber ts = new NbpTestSubscriber(); - m.subscribe(ts); - ts.awaitTerminalEvent(); - assertEquals(1, ts.errorCount()); - ts.assertNoValues(); - } - - @Test - public void valueSelectorThrows() { - NbpObservable source = NbpObservable.just(0, 1, 2, 3, 4, 5, 6); - - NbpObservable m = source.groupBy(identity, fail(0)).flatMap(FLATTEN_INTEGER); - NbpTestSubscriber ts = new NbpTestSubscriber(); - m.subscribe(ts); - ts.awaitTerminalEvent(); - assertEquals(1, ts.errorCount()); - ts.assertNoValues(); - - } - - @Test - public void innerEscapeCompleted() { - NbpObservable source = NbpObservable.just(0); - - NbpObservable m = source.groupBy(identity, dbl).flatMap(FLATTEN_INTEGER); - - NbpTestSubscriber ts = new NbpTestSubscriber(); - m.subscribe(ts); - ts.awaitTerminalEvent(); - ts.assertNoErrors(); - System.out.println(ts.values()); - } - - /** - * Assert we get an IllegalStateException if trying to subscribe to an inner NbpGroupedObservable more than once - */ - @Test - public void testExceptionIfSubscribeToChildMoreThanOnce() { - NbpObservable source = NbpObservable.just(0); - - final AtomicReference> inner = new AtomicReference>(); - - NbpObservable> m = source.groupBy(identity, dbl); - - m.subscribe(new Consumer>() { - @Override - public void accept(NbpGroupedObservable t1) { - inner.set(t1); - } - }); - - inner.get().subscribe(); - - @SuppressWarnings("unchecked") - NbpObserver o2 = mock(NbpObserver.class); - - inner.get().subscribe(o2); - - verify(o2, never()).onComplete(); - verify(o2, never()).onNext(anyInt()); - verify(o2).onError(any(IllegalStateException.class)); - } - - @Test - public void testError2() { - NbpObservable source = NbpObservable.concat(NbpObservable.just(0), - NbpObservable. error(new TestException("Forced failure"))); - - NbpObservable m = source.groupBy(identity, dbl).flatMap(FLATTEN_INTEGER); - - NbpTestSubscriber ts = new NbpTestSubscriber(); - m.subscribe(ts); - ts.awaitTerminalEvent(); - assertEquals(1, ts.errorCount()); - ts.assertValueCount(1); - } - - @Test - public void testgroupByBackpressure() throws InterruptedException { - NbpTestSubscriber ts = new NbpTestSubscriber(); - - NbpObservable.range(1, 4000).groupBy(IS_EVEN2).flatMap(new Function, NbpObservable>() { - - @Override - public NbpObservable apply(final NbpGroupedObservable g) { - return g.doOnComplete(new Runnable() { - - @Override - public void run() { - System.out.println("//////////////////// COMPLETED-A"); - } - - }).observeOn(Schedulers.computation()).map(new Function() { - - int c = 0; - - @Override - public String apply(Integer l) { - if (g.getKey()) { - if (c++ < 400) { - try { - Thread.sleep(1); - } catch (InterruptedException e) { - } - } - return l + " is even."; - } else { - return l + " is odd."; - } - } - - }).doOnComplete(new Runnable() { - - @Override - public void run() { - System.out.println("//////////////////// COMPLETED-B"); - } - - }); - } - - }).doOnEach(new Consumer>>() { - - @Override - public void accept(Try> t1) { - System.out.println("NEXT: " + t1); - } - - }).subscribe(ts); - ts.awaitTerminalEvent(); - ts.assertNoErrors(); - } - - @Test - public void testgroupByBackpressure2() throws InterruptedException { - - NbpTestSubscriber ts = new NbpTestSubscriber(); - - NbpObservable.range(1, 4000).groupBy(IS_EVEN2).flatMap(new Function, NbpObservable>() { - - @Override - public NbpObservable apply(final NbpGroupedObservable g) { - return g.take(2).observeOn(Schedulers.computation()).map(new Function() { - - @Override - public String apply(Integer l) { - if (g.getKey()) { - try { - Thread.sleep(1); - } catch (InterruptedException e) { - } - return l + " is even."; - } else { - return l + " is odd."; - } - } - - }); - } - - }).subscribe(ts); - ts.awaitTerminalEvent(); - ts.assertNoErrors(); - } - - static Function, NbpObservable> FLATTEN_INTEGER = new Function, NbpObservable>() { - - @Override - public NbpObservable apply(NbpGroupedObservable t) { - return t; - } - - }; - - @Test - public void testGroupByWithNullKey() { - final String[] key = new String[]{"uninitialized"}; - final List values = new ArrayList(); - NbpObservable.just("a", "b", "c").groupBy(new Function() { - - @Override - public String apply(String value) { - return null; - } - }).subscribe(new Consumer>() { - - @Override - public void accept(NbpGroupedObservable NbpGroupedObservable) { - key[0] = NbpGroupedObservable.getKey(); - NbpGroupedObservable.subscribe(new Consumer() { - - @Override - public void accept(String s) { - values.add(s); - } - }); - } - }); - assertEquals(null, key[0]); - assertEquals(Arrays.asList("a", "b", "c"), values); - } - - @Test - public void testGroupByUnsubscribe() { - final Disposable s = mock(Disposable.class); - NbpObservable o = NbpObservable.create( - new NbpOnSubscribe() { - @Override - public void accept(NbpSubscriber NbpSubscriber) { - NbpSubscriber.onSubscribe(s); - } - } - ); - NbpTestSubscriber ts = new NbpTestSubscriber(); - - o.groupBy(new Function() { - - @Override - public Integer apply(Integer integer) { - return null; - } - }).subscribe(ts); - - ts.dispose(); - - verify(s).dispose(); - } - - @Test - public void testGroupByShouldPropagateError() { - final Throwable e = new RuntimeException("Oops"); - final NbpTestSubscriber inner1 = new NbpTestSubscriber(); - final NbpTestSubscriber inner2 = new NbpTestSubscriber(); - - final NbpTestSubscriber> outer - = new NbpTestSubscriber>(new NbpObserver>() { - - @Override - public void onComplete() { - } - - @Override - public void onError(Throwable e) { - } - - @Override - public void onNext(NbpGroupedObservable o) { - if (o.getKey() == 0) { - o.subscribe(inner1); - } else { - o.subscribe(inner2); - } - } - }); - NbpObservable.create( - new NbpOnSubscribe() { - @Override - public void accept(NbpSubscriber NbpSubscriber) { - NbpSubscriber.onSubscribe(EmptyDisposable.INSTANCE); - NbpSubscriber.onNext(0); - NbpSubscriber.onNext(1); - NbpSubscriber.onError(e); - } - } - ).groupBy(new Function() { - - @Override - public Integer apply(Integer i) { - return i % 2; - } - }).subscribe(outer); - assertEquals(Arrays.asList(e), outer.errors()); - assertEquals(Arrays.asList(e), inner1.errors()); - assertEquals(Arrays.asList(e), inner2.errors()); - } -} \ No newline at end of file diff --git a/src/test/java/io/reactivex/nbp/NbpCovarianceTest.java b/src/test/java/io/reactivex/nbp/NbpCovarianceTest.java deleted file mode 100644 index a3c96343ce..0000000000 --- a/src/test/java/io/reactivex/nbp/NbpCovarianceTest.java +++ /dev/null @@ -1,254 +0,0 @@ -/** - * Copyright 2016 Netflix, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package io.reactivex.nbp; - -import static org.junit.Assert.assertEquals; - -import java.util.*; - -import org.junit.Test; - -import io.reactivex.NbpObservable; -import io.reactivex.NbpObservable.NbpTransformer; -import io.reactivex.functions.*; -import io.reactivex.observables.nbp.NbpGroupedObservable; -import io.reactivex.subscribers.nbp.NbpTestSubscriber; - -/** - * Test super/extends of generics. - * - * See https://github.com/Netflix/RxJava/pull/331 - */ -public class NbpCovarianceTest { - - /** - * This won't compile if super/extends isn't done correctly on generics - */ - @Test - public void testCovarianceOfFrom() { - NbpObservable. just(new HorrorMovie()); - NbpObservable. fromIterable(new ArrayList()); - // NbpObservable.from(new Movie()); // may not compile - } - - @Test - public void testSortedList() { - Comparator SORT_FUNCTION = new Comparator() { - @Override - public int compare(Media t1, Media t2) { - return 1; - } - }; - - // this one would work without the covariance generics - NbpObservable o = NbpObservable.just(new Movie(), new TVSeason(), new Album()); - o.toSortedList(SORT_FUNCTION); - - // this one would NOT work without the covariance generics - NbpObservable o2 = NbpObservable.just(new Movie(), new ActionMovie(), new HorrorMovie()); - o2.toSortedList(SORT_FUNCTION); - } - - @Test - public void testGroupByCompose() { - NbpObservable movies = NbpObservable.just(new HorrorMovie(), new ActionMovie(), new Movie()); - NbpTestSubscriber ts = new NbpTestSubscriber(); - movies - .groupBy(new Function() { - @Override - public Object apply(Movie v) { - return v.getClass(); - } - }) - .doOnNext(new Consumer>() { - @Override - public void accept(NbpGroupedObservable g) { - System.out.println(g.key()); - } - }) - .flatMap(new Function, NbpObservable>() { - @Override - public NbpObservable apply(NbpGroupedObservable g) { - return g - .doOnNext(new Consumer() { - @Override - public void accept(Movie pv) { - System.out.println(pv); - } - }) - .compose(new Function, NbpObservable>() { - @Override - public NbpObservable apply(NbpObservable m) { - return m.concatWith(NbpObservable.just(new ActionMovie())); - } - } - ) - .map(new Function() { - @Override - public String apply(Movie v) { - return v.toString(); - } - }); - } - }) - .subscribe(ts); - ts.assertTerminated(); - ts.assertNoErrors(); - // System.out.println(ts.getOnNextEvents()); - assertEquals(6, ts.valueCount()); - } - - @SuppressWarnings("unused") - @Test - public void testCovarianceOfCompose() { - NbpObservable movie = NbpObservable.just(new HorrorMovie()); - NbpObservable movie2 = movie.compose(new Function, NbpObservable>() { - @Override - public NbpObservable apply(NbpObservable t) { - return NbpObservable.just(new Movie()); - } - }); - } - - @SuppressWarnings("unused") - @Test - public void testCovarianceOfCompose2() { - NbpObservable movie = NbpObservable. just(new HorrorMovie()); - NbpObservable movie2 = movie.compose(new Function, NbpObservable>() { - @Override - public NbpObservable apply(NbpObservable t) { - return NbpObservable.just(new HorrorMovie()); - } - }); - } - - @SuppressWarnings("unused") - @Test - public void testCovarianceOfCompose3() { - NbpObservable movie = NbpObservable.just(new HorrorMovie()); - NbpObservable movie2 = movie.compose(new Function, NbpObservable>() { - @Override - public NbpObservable apply(NbpObservable t) { - return NbpObservable.just(new HorrorMovie()).map(new Function() { - @Override - public HorrorMovie apply(HorrorMovie v) { - return v; - } - }); - } - } - ); - } - - @SuppressWarnings("unused") - @Test - public void testCovarianceOfCompose4() { - NbpObservable movie = NbpObservable.just(new HorrorMovie()); - NbpObservable movie2 = movie.compose(new Function, NbpObservable>() { - @Override - public NbpObservable apply(NbpObservable t1) { - return t1.map(new Function() { - @Override - public HorrorMovie apply(HorrorMovie v) { - return v; - } - }); - } - }); - } - - @Test - public void testComposeWithDeltaLogic() { - List list1 = Arrays.asList(new Movie(), new HorrorMovie(), new ActionMovie()); - List list2 = Arrays.asList(new ActionMovie(), new Movie(), new HorrorMovie(), new ActionMovie()); - NbpObservable> movies = NbpObservable.just(list1, list2); - movies.compose(deltaTransformer); - } - - static Function>, NbpObservable> calculateDelta = new Function>, NbpObservable>() { - @Override - public NbpObservable apply(List> listOfLists) { - if (listOfLists.size() == 1) { - return NbpObservable.fromIterable(listOfLists.get(0)); - } else { - // diff the two - List newList = listOfLists.get(1); - List oldList = new ArrayList(listOfLists.get(0)); - - Set delta = new LinkedHashSet(); - delta.addAll(newList); - // remove all that match in old - delta.removeAll(oldList); - - // filter oldList to those that aren't in the newList - oldList.removeAll(newList); - - // for all left in the oldList we'll create DROP events - for (@SuppressWarnings("unused") Movie old : oldList) { - delta.add(new Movie()); - } - - return NbpObservable.fromIterable(delta); - } - } - }; - - static NbpTransformer, Movie> deltaTransformer = new NbpTransformer, Movie>() { - @Override - public NbpObservable apply(NbpObservable> movieList) { - return movieList - .startWith(new ArrayList()) - .buffer(2, 1) - .skip(1) - .flatMap(calculateDelta); - } - }; - - /* - * Most tests are moved into their applicable classes such as [Operator]Tests.java - */ - - static class Media { - } - - static class Movie extends Media { - } - - static class HorrorMovie extends Movie { - } - - static class ActionMovie extends Movie { - } - - static class Album extends Media { - } - - static class TVSeason extends Media { - } - - static class Rating { - } - - static class CoolRating extends Rating { - } - - static class Result { - } - - static class ExtendedResult extends Result { - } -}