PropCheck "list of minimum two elements"-generator

I’m trying to write property based tests for a Reverse Polish Notation calculator.

I’ve implemented the RPN such that it will return an error tuple if you try to push a operator to the stack when the stack has less than two numbers.

defmodule ReversePolishNotation do
  @moduledoc """
  Documentation for ReversePolishNotation.

  def push(list, number) when number |> is_number do
    {:ok, [number | list]}

  @operators [:+, :/, :-, :*]
  def push([x, y | list], op) when op in @operators do
    result = apply(Kernel, op, [x, y])
    {:ok, [result | list]}

  def push(list, input) do
    {:error, list, {:unexpected_input, input}}


Now I want to test the happy path of pushing an operator to a stack (list) of numbers, where the list has at least two numbers in it.

since number() |> list() |> non_empty() will shrink to a one element list it does not work for me.

so I tried to to use the such_that macro to generate lists of numbers with length(l) > 1 but that ends with {:error, :cant_generate}

My test and generator

  property "can push operator to a list with minimum 2 numbers" do
    forall {list, operator} <- {list_min_two(), operator()} do
      {:ok, _new_list} = RPN.push(list, operator)

  # Generators

  def operator() do
    oneof([:+, :-, :/, :*])

  def list_min_two() do
    such_that l <- non_empty(list(number())), when: length(l) > 1

Maybe @alfert has some insight?

I have only used StreamData before, but I PropCheck is probably similar. I see two possibilities for the generator:

  1. Reject cases that are shorter than two-elements as ‘improperly generated values that we do not want to use’
  2. Generate a a = non_empty(list(number())) and a separate b = number(), which you then combine (using a map or bind operation to turn them into [a | b] if PropCheck has something like that, I did not find it right away, or otherwise just inside your tests).

Thanks for the reply!

such_that l <- non_empty(list(number())), when: length(l) > 1

I was trying to achieve your first point with the above code.
The such_that macro should discard generated values when the anonymous function returns false.

I thought about combining generators in the way you suggest in point 2. But I have not found out how. I’ll dig a bit more into that :+1:

1 Like

I thought I tried this yesterday but I Solved i with [ number() | list_of_numbers ]

where list_of_numbers = non_empty(list(number()))

I also filtered 0 out to avoid division by zero errors, but that’s another story.

1 Like

Sorry for my long delay. I cannot reproduce your problem with the such_that operator. I did the following:

iex> use PropCheck
iex> produce(such_that l <- non_empty(list(number())), when: length(l) > 1)
 [-10, -12.498990234832617, 26.565811750847487, -0.8553774801624835,  -11.727179060408071, 11, 6, -6, 0, -18]}

iex> sample_shrink(such_that l <- non_empty(list(number())), when: length(l) > 1)

This would be the expected behaviour. Using the produce and sample_shrink helps to find bugs in the generators.

But your approach using

iex> sample_shrink([number() | non_empty(list(number))])

works equally well: a list of generators is also a generator and will not shrink towards the empty list. The combination of generators works on the generator and not on the data level, therefore both generators must be present when shrinking.

Hope that explains the approach.

In your case, I would go for several generators:

def non_zero_number, do: such_that n <- number(), where: n != 0
def list_min_two(elem_gen), do: 
   such_that l <- non_empty(list(elem_gen() )), when: length(l) > 1
def safe_numbers, do: list_min_two(non_zero_number())
def numbers, do: list_min_two(number())

But I assume your approach is similar.

If this still fails, then please file a bug report on GitHub! In the best case, we have a documentation issue.


Thanks a lot for the answer. Your examples in iex works fine. Don’t know why the function didn’t work…

you may want to use some cheats that let you properly ensure that you never generate useless sequences, using let macros. You can do something like let l <- list(elem()), do: [elem(), elem() | l] which will give a 2-or-more elements list no matter what happens, without needing retried generators in a such_that macro.


Cool. Thanks @fred!

For posterity