from testmachine import TestMachine from random import Random # This is the object that we use to define the kind of test case we want to # generate. machine = TestMachine() # testmachine.common defines a number of standard operations on different types # of variables. We're going to use some of those rather than implementing our # own. from testmachine.common import basic_operations, arithmetic_operations # We only have one type of variable. We'll call that floats, but this is just # an arbitrary name. We could call it steve if we wanted to. # We generate our basic floats as random numbers between 0 and 1. machine.generate(Random.random, "floats") # These are basic stack manipulation operations. They aren't very exciting, but # they expand the likelihood of producing interesting programs. Most machines # will use these. basic_operations(machine, "floats") # floats can be combined with the normal arithmetic operations arithmetic_operations(machine, "floats") # We want to demonstrate that floating point addition is not associative. This # check will read three variables off our stack of floats and see if adding t # them up in different orders produces the same value. def associative_add(x, y, z): return x + (y + z) == (x + y) + z
return ( (len(self.child0) <= len(self.child1) + 1) and (len(self.child1) <= len(self.child0) + 1) ) # Business as usual machine = TestMachine() # Because we might as well basic_operations(machine, "trees") # We can always generate leaf nodes. We ignore the Random argument we're given # because all Leaves are created equal. machine.generate(lambda _: Leaf(), "trees") # Given two trees, we can join them together into a new tree machine.operation( argspec=("trees", "trees"), target="trees", function = lambda x, y: x.join(y), pattern="%s.join(%s)" ) # Assert that our trees are balanced. machine.check( test=lambda x: x.balanced(), argspec=("trees",), # The pattern argument controls the output formatting when emitting an