Need help with rantly?
Click the “chat” button below for chat support from the developer who created it, or find similar developers for support.

About the developer

210 Stars 19 Forks MIT License 111 Commits 1 Opened issues


Ruby Imperative Random Data Generator and Quickcheck

Services available


Need anything else?

Contributors list


h1. Repository move (Beginning 2015-07-07)

The official rantly repository has moved from "hayeah/rantly": to "abargnesi/rantly": The creator of rantly is "Howard Yeh": "Anthony Bargnesi": is the current maintainer.

New development will occur in "abargnesi/rantly":

The transition plan is as follows:

  • [x] Investigate and move open issues from "hayeah/rantly": to "abargnesi/rantly":
  • [x] Evaluate and likely merge pull requests into hayeah/rantly. Push these changes to "abargnesi/rantly":
  • [x] Move over any closed issues that have relevant discourse.
  • [ ] Fix open issues.
  • [x] Push new gem version after testing functionality.
  • [ ] Continue new development; Changes will be pushed back upstream to "hayeah/rantly": over the course of the next month.
  • [x] Added CHANGELOG markdown file. Includes what was added between 0.3.1 (2011-12-15) and 0.3.2 (2015-09-16).

h1. Imperative Random Data Generator and Quickcheck

You can use Rantly to generate random test data, and use its Test::Unit extension for property-based testing.

Rantly is basically a recursive descent interpreter, each of its method returns a random value of some type (string, integer, float, etc.).

Its implementation has no alien mathematics inside. Completely side-effect-free-free.

h1. Install

$ gem install rantly

$ irb -rrantly
> Rantly { [integer,float] } # same as Rantly.value { integer }
=> [20991307, 0.025756845811823]
> Rantly { [integer,float]}
=> [-376856492, 0.452245765751706]
> Rantly(5) { integer } # same as { integer }
=> [-1843396915550491870, -1683855015308353854, -2291347782549033959, -951461511269053584, 483265231542292652]

h1. Data Generation

h2. Getting Random Data Values

  call the generator n times, and collect values
  call a random block n times
  call a random block once, and get its value.

To collect an array of random data,

# we want 5 random integers
> Rantly(5) { integer }
=> [-380638946, -29645239, 344840868, 308052180, -154360970]

To iterate over random data,

> Rantly.each(5) { puts integer }
=> nil

To get one value of random data,

> Rantly { integer }
=> 278101042

The optional argument @[email protected] is used with generator guard. By default, if you want to generate n items, the generator tries at most n * 10 times.

This almost always succeeds,

> Rantly(5) { i = integer; guard i > 0; i }
=> [511765059, 250554234, 305947804, 127809156, 285960387]

This always fails,

> Rantly(10) { guard integer.is_a?(Float) }
Rantly::TooManyTries: Exceed gen limit 100: 101 failed guards)

h2. Random Generating Methods

The API is similiar to QuickCheck, but not exactly the same. In particular @[email protected] picks a random element from an array, and @[email protected] picks a integer from an interval.

h3. Simple Randomness

  random positive or negative integer. Fixnum only.
  random integer between lo and hi.
  random float
  true or false
  No-op. returns value.
  Pick one value from among vals.

h3. Meta Randomness

A rant generator is just a mini interpreter. It's often useful to go meta,

  If gen is a Symbol, just do a method call with send.
  If gen is an Array, the first element of the array is the method name, the rest are args.
  If gen is a Proc, instance_eval it with the generator.

> Rantly { call(:integer) }
=> -240998958

> Rantly { call([:range,0,10]) }
=> 2

> Rantly { call( { [integer] })}
=> [522807620]

The @[email protected] method is useful to implement other abstractions (See next subsection).

  Pick a random arg among args, and Rantly#call it.

50-50 chance getting an integer or float,

> Rantly { branch :integer, :float }
=> 0.0489446702931332
> Rantly { branch :integer, :float }
=> 494934533

h3. Frequencies

  Takes a list of 2-tuples, the first of which is the weight, and the second a Rantly#callable value, and returns a random value picked from the pairs. Follows the distribution pattern specified by the weights.

Twice as likely to get a float than integer. Never gets a ranged integer.

> Rantly { freq [1,:integer], [2,:float], [0,:range,0,10] }

If the "pair" is not an array, but just a symbol, @[email protected] assumes that the weight is 1.

# 50-50 between integer and float
> Rantly { freq :integer, :float }

If a "pair" is an Array, but the first element is not an Integer, @[email protected] assumes that it's a Rantly method-call with arguments, and the weight is one.

# 50-50 chance generating integer limited by 10, or by 20.
> Rantly { freq [:integer,10], [:integer 20] }

h3. Sized Structure

A Rantly generator keeps track of how large a datastructure it should generate with its @[email protected] attribute.

 returns the current size
 sets the size for the duration of recursive call of block. Block is instance_eval with the generator.

Rantly provides two methods that depends on the size

  returns a sized array consisted of elements by Rantly#calling random branches.
  returns a sized random string, consisted of only chars from a char_class.
  returns a sized random hash. The generator block should generate tuples of keys and values (arrays that have two elements, the first one is used as key, and the second as value).

The avaiable char classes for strings are:


# sized 10 array of integers
> Rantly { array(10) { integer }}
=> [417733046, -375385433, 0.967812380000118, 26478621, 0.888588160450082, 250944144, 305584916, -151858342, 0.308123867823313, 0.316824642414253]

If you set the size once, it applies to all subsequent recursive structures. Here's a sized 10 array of sized 10 strings,

> Rantly { sized(10) { array {string}} }
=> ["1c}C/,9I#}", "hpA/UWPJ\\j", "H'~ERtI`|]", "%OUaW\\%uQZ", "Z2QdY=G~G!", "HojnxGDT3", "]a:L[B>bhb", "_Kl=&{tH^

Or a sized 10 array of sized 5 strings,

> Rantly {array(10){sized(5) {string}}}
=> ["S\"jf ", "d\\F-$", "-_8pa", "IN0iF", "SxRV$", ".{kQ7", "6>;fo", "}.D8)", "P(tS'", "y0v/v"]

Generate a hash that has 5 elements,

> Rantly { dict { [string,integer] }}
 "-Mp '."=>653206579583741142,
 "= :/\\,"=>433790301059833691}

The @[email protected] generator retries if a key is duplicated. If it fails to generate a unique key after too many tries, it gives up by raising an error:

> Rantly { dict { ["a",integer] }}
Rantly::TooManyTries: Exceed gen limit 60: 60 failed guards)

h1. Property Testing

Rantly extends Test::Unit and MiniTest::Test (5.0)/MiniTest::Unit::TestCase (< 5.0) for property testing. The extensions are in their own modules. So you need to require them explicitly:

require 'rantly/testunit_extensions' # for 'test/unit'
require 'rantly/minitest_extensions' # for 'minitest'
require 'rantly/rspec_extensions'    # for RSpec

They define:

  The block is used to generate random data with a generator. The method returns a Rantly::Property instance, that has the method 'check'.

Property assertions within Test::Unit could be done like this,

# checks that integer only generates fixnum.
property_of {
}.check { |i|
  assert(i.is_a?(Integer), "integer property did not return Integer type")

Property assertions within Minitest could be done like this,

# checks that integer only generates fixnum.
property_of {
}.check { |i|
  assert_kind_of Integer, i, "integer property did not return Integer type"

Property assertions within RSpec could be done like this,

# checks that integer only generates fixnum.
it "integer property only returns Integer type" do
   property_of {
   }.check { |i|
     expect(i).to be_a(Integer)

The check block takes the generated data as its argument. One idiom I find useful is to include a parameter of the random data for the check argument. For example, if I want to check that Rantly#array generates the right sized array, I could say,

property_of {
  len = integer
}.check { |(len,arr)|
  assert_equal len, arr.length

If you wish to have quiet output from Rantly, set environmental variable:

RANTLYVERBOSE=1 # verbose and default if env is not set
This will silence the puts, print, and pretty_print statements in property.rb.

h1. Shrinking

Shrinking reduces the value of common types to some terminal lower bound. These functions are added to the Ruby types Integer, String, Array, and Hash.

For example a String is shrinkable until it is empty (e.g. ""),

"foo".shrink               # => "fo"
"foo".shrink.shrink        # => "f"
"foo".shrink.shrink.shrink # => ""
"".shrinkable?             # => false

Shrinking allows Property#check to find the minimum value that still fails the condition.

Enable shrinking with

require 'rantly/shrinks'

That's about it. Enjoy :)

h1. Copyright

Copyright (c) 2009 Howard Yeh. See LICENSE for details.

We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.