Merge branch 'master' into replay-multicast

Conflicts:
	language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala
	language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Observable.scala
	language-adaptors/rxjava-scala/src/test/scala/rx/lang/scala/CompletenessTest.scala

Author: zsxwing

CHANGES.md

@@ -1,5 +1,13 @@
 # RxJava Releases #
 
+### Version 0.18.3 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.netflix.rxjava%22%20AND%20v%3A%220.18.3%22)) ###
+
+* [Pull 1161] (https://github.com/Netflix/RxJava/pull/1161) Removed use of deprecated API from tests & operators
+* [Pull 1162] (https://github.com/Netflix/RxJava/pull/1162) fix to remove drift from schedulePeriodic
+* [Pull 1159] (https://github.com/Netflix/RxJava/pull/1159) Rxscala improvement
+* [Pull 1164] (https://github.com/Netflix/RxJava/pull/1164) JMH Perf Tests for Schedulers.computation
+* [Pull 1158] (https://github.com/Netflix/RxJava/pull/1158) Scheduler correctness improvements.
+
 ### Version 0.18.2 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.netflix.rxjava%22%20AND%20v%3A%220.18.2%22)) ###
 
 

language-adaptors/rxjava-scala/src/examples/scala/rx/lang/scala/examples/RxScalaDemo.scala

@@ -16,6 +16,8 @@
 package rx.lang.scala.examples
 
 import java.io.IOException
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
 
 import scala.concurrent.duration.Duration
 import scala.concurrent.duration.DurationInt
@@ -142,6 +144,12 @@ class RxScalaDemo extends JUnitSuite {
     o.buffer(5).subscribe((l: Seq[Int]) => println(l.mkString("[", ", ", "]")))
   }
 
+  @Test def bufferExample() {
+    val o = Observable.from(1 to 18).zip(Observable.interval(100 millis)).map(_._1)
+    val boundary = Observable.interval(500 millis)
+    o.buffer(boundary).toBlockingObservable.foreach((l: Seq[Int]) => println(l.mkString("[", ", ", "]")))
+  }
+
   @Test def windowExample() {
     (for ((o, i) <- Observable.from(1 to 18).window(5).zipWithIndex; n <- o)
       yield s"Observable#$i emits $n"
@@ -682,6 +690,21 @@ class RxScalaDemo extends JUnitSuite {
     println(result)
   }
 
+  @Test def delayExample3(): Unit = {
+    val o = List(100, 500, 200).toObservable.delay(
+      (i: Int) => Observable.items(i).delay(i millis)
+    )
+    o.toBlockingObservable.foreach(println(_))
+  }
+
+  @Test def delayExample4(): Unit = {
+    val o = List(100, 500, 200).toObservable.delay(
+      () => Observable.interval(500 millis).take(1),
+      (i: Int) => Observable.items(i).delay(i millis)
+    )
+    o.toBlockingObservable.foreach(println(_))
+  }
+
   @Test def delaySubscriptionExample(): Unit = {
     val o = List(100L, 200L, 300L).toObservable.delaySubscription(2 seconds)
     val result = o.toBlockingObservable.toList
@@ -844,4 +867,96 @@ class RxScalaDemo extends JUnitSuite {
     val o = List(1, 2).toObservable :+ 3 :+ 4
     assertEquals(List(1, 2, 3, 4), o.toBlockingObservable.toList)
   }
+
+  @Test def sequenceEqualExampe(): Unit = {
+    val o1 = List(1, 2, 3).toObservable
+    val o2 = List(1, 2, 3).toObservable
+    val o3 = List(1, 2).toObservable
+    val o4 = List(1.0, 2.0, 3.0).toObservable
+    assertTrue(o1.sequenceEqual(o2).toBlockingObservable.single)
+    assertFalse(o1.sequenceEqual(o3).toBlockingObservable.single)
+    assertTrue(o1.sequenceEqual(o4).toBlockingObservable.single)
+  }
+
+  @Test def takeExample(): Unit = {
+    val o = (1 to 20).toObservable
+      .zip(Observable.interval(300 millis))
+      .map(_._1)
+      .take(2 seconds)
+    println(o.toBlockingObservable.toList)
+  }
+
+  @Test def takeRightExample(): Unit = {
+    val o = (1 to 6).toObservable.takeRight(3)
+    assertEquals(List(4, 5, 6), o.toBlockingObservable.toList)
+  }
+
+  @Test def takeRightExample2(): Unit = {
+    val o = (1 to 10).toObservable
+      .zip(Observable.interval(100 millis))
+      .map(_._1)
+      .takeRight(300 millis)
+    println(o.toBlockingObservable.toList)
+  }
+
+  @Test def takeRightExample3(): Unit = {
+    val o = (1 to 10).toObservable
+      .zip(Observable.interval(100 millis))
+      .map(_._1)
+      .takeRight(2, 300 millis)
+    println(o.toBlockingObservable.toList)
+  }
+
+  @Test def timeIntervalExample(): Unit = {
+    val o = (1 to 10).toObservable
+      .zip(Observable.interval(100 millis))
+      .map(_._1)
+      .timeInterval
+    println(o.toBlockingObservable.toList)
+  }
+
+  @Test def schedulerExample1(): Unit = {
+    val latch = new CountDownLatch(1)
+    val worker = IOScheduler().createWorker
+    worker.schedule {
+      println("Hello from Scheduler")
+      latch.countDown()
+    }
+    latch.await(5, TimeUnit.SECONDS)
+  }
+
+  @Test def schedulerExample2(): Unit = {
+    val latch = new CountDownLatch(1)
+    val worker = IOScheduler().createWorker
+    worker.schedule(1 seconds) {
+      println("Hello from Scheduler after 1 second")
+      latch.countDown()
+    }
+    latch.await(5, TimeUnit.SECONDS)
+  }
+
+  @Test def schedulerExample3(): Unit = {
+    val worker = IOScheduler().createWorker
+    var no = 1
+    val subscription = worker.schedulePeriodically(initialDelay = 1 seconds, period = 100 millis) {
+      println(s"Hello(${no}) from Scheduler")
+      no += 1
+    }
+    TimeUnit.SECONDS.sleep(2)
+    subscription.unsubscribe()
+  }
+
+  @Test def schedulerExample4(): Unit = {
+    val worker = IOScheduler().createWorker
+    var no = 1
+    def hello: Unit = {
+      println(s"Hello(${no}) from Scheduler")
+      no += 1
+      worker.schedule(100 millis)(hello)
+    }
+    val subscription = worker.schedule(1 seconds)(hello)
+    TimeUnit.SECONDS.sleep(2)
+    subscription.unsubscribe()
+  }
+
 }

language-adaptors/rxjava-scala/src/main/scala/rx/lang/scala/Notification.scala

@@ -137,7 +137,7 @@ object Notification {
      * @param notification
      *                     The [[rx.lang.scala.Notification]] to be deconstructed
      * @return
-     *         The [[java.lang.Throwable]] value contained in this notification.
+     *         The `java.lang.Throwable` value contained in this notification.
      */
     def unapply[U](notification: Notification[U]): Option[Throwable] = notification match {
       case onError: OnError[U] => Some(onError.error)