how to test object methods (exercise) - scala

Question

As part of an exercise I am writing an API to generate random numbers.
This is the code that I have and I would like to test the notNegativeInt function.
How can I do that?
(here the full solution https://github.com/fpinscala/fpinscala/blob/master/answers/src/main/scala/fpinscala/state/State.scala )
import java.util.Random
object chapter6 {
println("Welcome to the Scala worksheet") //> Welcome to the Scala worksheet
trait RNG {
def nextInt: (Int, RNG) // Should generate a random `Int`. We'll later define other functions in terms of `nextInt`.
}
object RNG {
// NB - this was called SimpleRNG in the book text
case class Simple(seed: Long) extends RNG {
def nextInt: (Int, RNG) = {
val newSeed = (seed * 0x5DEECE66DL + 0xBL) & 0xFFFFFFFFFFFFL // `&` is bitwise AND. We use the current seed to generate a new seed.
val nextRNG = Simple(newSeed) // The next state, which is an `RNG` instance created from the new seed.
val n = (newSeed >>> 16).toInt // `>>>` is right binary shift with zero fill. The value `n` is our new pseudo-random integer.
(n, nextRNG) // The return value is a tuple containing both a pseudo-random integer and the next `RNG` state.
}
}
// We need to be quite careful not to skew the generator.
// Since `Int.Minvalue` is 1 smaller than `-(Int.MaxValue)`,
// it suffices to increment the negative numbers by 1 and make them positive.
// This maps Int.MinValue to Int.MaxValue and -1 to 0.
def nonNegativeInt(rng: RNG): (Int, RNG) = {
val (i, r) = rng.nextInt
(if (i < 0) -(i + 1) else i, r)
}
}
}

Answer 1

If you want to test only the nonNegativeInt method, you could provide a mock implementation of RNG that provides the values you want to test when nextInt is called.
For example, there are 2 possible branches in the nonNegativeInt, so you should provide a RNG instance that gives a negative number and another one that provides a positive number.
class MyRNG(val num:Int) extends RNG {
self: RNG =>
def nextInt: (Int, RNG) = (num, this)
}
With this RNG mock you could test your nonNegativeInt method, creating a MyRNG with the desired value you want to test against.
For this particular case, you can also omit the self reference:
class MyRNG(val num:Int) extends RNG {
def nextInt: (Int, RNG) = (num, this)
}