val genSizeAndRange = for {
size __ Gen.choose(1,1000)
range __ Gen.choose(size+1, size+5000)
} yield (size, range)

val genSizeAndRange = for {
size

val genSizeAndRange = for {
size

Since the chance that you implication condition is fulfilled when ScalaCheck generates sizes and ranges at random, you will easily get into the situation where to many tests are discarded. The simplest way to solve the problem is to implement a small generator that only generates sizes and ranges of your taste:

val genSizeAndRange = for {
size

For simplicity, I hardcoded the upper limits of size and range here, but you could also have used the Gen.sized combinator to let ScalaCheck decide how large numbers to generate.

Now we can write the specification like this:

specify(”generate”, Prop.forAll(genSizeAndRange) {
case (size,range) => generate(size, range).size == size
})

As for Arbitrary[Generator], in this case there is no really need for it, since your generator class is so simple (all Generator instances look the same). Anyway, here is how you would do it:

implicit val arbGenerator = Arbitrary(Gen.value(new Generator))

Now you can write properties like this one:

specify(”generate”, (g: Generator) => forAll(genSizeAndRange) {
case (size,range) => g.generate(size, range).size == size
})

Hope this helps to get you started!

I’m currently trying to wrap my head around Scala and the ideas and concepts of ScalaCheck. Currently I’m trying to write properties for a simple generator class. The method I’m trying to test is this:

/**
	 * Generates a sorted list of numbers in the given range, without
	 * duplicates.
	 *
	 * @param size
	 *            How many numbers to generate
	 * @param range
	 *            The range of numbers to generate, from 1 to the given value,
	 *            both inclusive
	 * @return A random list of numbers for the given size and range, sorted
	 *         ascending
	 */
	public List generate(int size, int range) {
		List result = new ArrayList();
		for (int i = 0; i < size; i++) {
			int next;
			do {
				next = generateOneOutOf(range);
			} while (result.contains(next));
			result.add(next);
		}
		return result;
	}

The properties I’d like to state: For any value of size, the resulting list must have that size. For any value of range, the resulting list must have values inside that range, not outside of it. The preconditions are size > 0 and range > size (not in the JavaDoc, got to fix that - ScalaCheck already helped to show that).

What I managed to get running so far is this:

def generate(size: Int, range: Int): java.util.List[Integer] = {
    new Generator().generate(size, range)
  }

  specify("generate", (size: Int, range: Int) => (size > 0 && range > size) ==> (generate(size, range).size == size) )

This doesn’t quite work out as too many tests get discarded, ala “gave up after only 59 passed tests. 500 tests were discarded.”.

I couldn’t figure out how to implement Arbitrary[Generator], nor how to use eg. Gen.choose to define the preconditions outside the property.

Some ideas to get started are very welcome!