def test(): from simpletest import _assert seq = [469, 218, 968, 186, 246, 624, 460, 91, 2, 90, 1015] sorted_seq = sorted(seq) _assert(seq == sorted_seq, False) radixsort(seq) _assert(seq == sorted_seq, True)
def test(): from simpletest import _assert seq = [-9, 1, 3, 6, 99, 909] bubblesort(seq) _assert(seq, [-9, 1, 3, 6, 99, 909]) seq = [] bubblesort(seq) _assert(seq, [])
def test(): from simpletest import _assert, _assert_raises gm = CarCompany() detroit_factory = gm.create_factory() _assert(detroit_factory.next(), "wrrrooommm... a brand new car rolled out!") _assert(detroit_factory.next(), "wrrrooommm... a brand new car rolled out!") gm.has_money = False # No money, no cars _assert_raises(StopIteration, detroit_factory.next) gm.has_money = True # There's money but the factory collapsed. _assert_raises(StopIteration, detroit_factory.next)
def test(): from simpletest import _assert s1 = Spam(1, 2) s2 = Spam(1, 2) s3 = Spam(2, 3) f1 = Foo(1, 2) f2 = Foo(1, 2) f3 = Foo(2, 3) _assert(s1 is s2, True) _assert(s2 is s3, False) _assert(f1 is s2, False) _assert(f1 is f2, True) _assert(f2 is f3, False)
def test(): from simpletest import _assert duck = Duck() turkey = Turkey() turkey_adapter = TurkeyAdapter(turkey) test_duck(duck) test_duck(turkey_adapter) _assert(duck.quack(), "Quack") _assert(duck.fly(), "I'm flying") _assert(turkey_adapter.quack(), "Gobble, gobble") _assert(turkey_adapter.fly(), "I'm flying a short distance")
def test(): from simpletest import _assert, _assert_raises a, b, c, d, e, f = 'abcdef' graph = {} _assert(topsort(graph), []) graph = { a: set([]), } _assert(topsort(graph), [a]) graph = { a: set([d, b]), b: set([d, c]), c: set([d]), d: set([]), e: set([d]), f: set([d, e]), } _assert(topsort(graph), [d, c, b, a, e, f]) graph = { a: set([b]), b: set([a]), } _assert_raises(Exception, topsort, graph)
def test(): from simpletest import _assert grid = Grid(10, 10) expect = [(0, 1), (0, 9), (1, 0), (1, 1), (1, 9), (9, 0), (9, 1), (9, 9)] _assert(grid.neighbors((0, 0)), set(expect)) expect = [(0, 0), (0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1), (2, 2)] _assert(grid.neighbors((1, 1)), set(expect)) expect = [(0, 0), (0, 8), (0, 9), (8, 0), (8, 8), (8, 9), (9, 0), (9, 8)] _assert(grid.neighbors((9, 9)), set(expect)) expect = [(5, 0), (5, 1), (5, 2), (6, 0), (6, 2), (7, 0), (7, 1), (7, 2)] _assert(grid.neighbors((6, 1)), set(expect)) static_block = [(0, 10), (1, 10), (0, 11), (1, 11)] oscilator = [(9, 0), (9, 1), (9, 2)] glider = [(2, 3), (2, 4), (2, 5), (1, 5), (0, 4)] play(Grid(20, 20), static_block + oscilator + glider)
def test(): from simpletest import _assert a = A() b = A() _assert(a is b, True) _assert(a.x, 'X') a.x = 'Y' _assert(b.x, 'Y')
def test(): from simpletest import _assert _assert(split_len('A', 2), ['A']) _assert(split_len('ABC', 2), ['AB', 'C']) _assert(split_len('ABCASDF', 2), ['AB', 'CA', 'SD', 'F']) _assert(split_len('', 2), []) _assert(split_len([1, 2, 3, 4], 2), [[1, 2], [3, 4]]) _assert(split_len('ABC', 1), ['A', 'B', 'C'])
def test(): from simpletest import _assert _assert(fib_counted(0), 0) _assert(fib_counted(1), 1) _assert(fib_counted(2), 1) _assert(fib_counted(3), 2) _assert(fib_counted(4), 3) _assert(fib_counted(42), 267914296) _assert(fib(0), 0) _assert(fib(1), 1) _assert(fib(2), 1) _assert(fib(3), 2) _assert(fib(4), 3) _assert(fib(42), 267914296)
def test(): from simpletest import _assert expected = ['Mary', ' ', 'had', ' ', 'a', ' ', 'little', ' ', 'lamb'] _assert(splitter.findall('Mary had a little lamb'),expected) _assert(splitter.findall(' '), [' ']) _assert(splitter.findall(''), [])
def test(): ht = HashTable() ht['a'] = 1 _assert(ht['a'], 1) _assert(ht['no_such_entry'], None) del ht['a'] _assert(ht['a'], None) _assert(ht._buckets, [[] for i in range(64)]) _assert(ht._find_bucket('mary'), 59) _assert(ht._find_bucket('had'), 43) _assert(ht._find_bucket('aaa'), 33) _assert(ht._find_bucket('little'), 54) _assert(ht._find_bucket('lamb'), 42)
def test(): from simpletest import _assert _assert(add(LinkedList([]), LinkedList([])), LinkedList([0])) _assert(add(LinkedList([1]), LinkedList([])), LinkedList([1])) _assert(add(LinkedList([0]), LinkedList([1])), LinkedList([1])) _assert(add(LinkedList([1]), LinkedList([1])), LinkedList([2])) _assert(add(LinkedList([9]), LinkedList([1])), LinkedList([0, 1])) _assert(add(LinkedList([9, 9]), LinkedList([3, 8, 9])), LinkedList([2, 8, 0, 1]))
def test(): _assert(get_tree(depth=-1), None) _assert(get_tree(depth=0), None) _assert(isinstance(get_tree(depth=1), Node), True) _assert(get_tree(depth=1).left, None) _assert(get_tree(depth=1).right, None) _assert(isinstance(get_tree(depth=2), Node), True) _assert(isinstance(get_tree(depth=2).left, Node), True) _assert(isinstance(get_tree(depth=2).right, Node), True) _assert(get_tree(depth=2).left.left, None) _assert(get_tree(depth=2).left.right, None) _assert(get_tree(depth=2).right.left, None) _assert(get_tree(depth=2).right.right, None)
def test(): from simpletest import _assert _assert(switch.get('a', fun_default)(), 'A') _assert(switch.get('b', fun_default)(), 'B') _assert(switch.get('c', fun_default)(), 'C') _assert(switch.get('nonexistent', fun_default)(), 'default')
def test(): from simpletest import _assert, _assert_raises llist = LinkedList() _assert(llist.head, None) _assert(llist.tail, None) llist.append('a') _assert(llist.index('a'), 0) _assert(llist.head.value, 'a') _assert(llist.tail.value, 'a') llist.append('b') _assert(llist.index('b'), 1) _assert(llist.head.value, 'a') _assert(llist.tail.value, 'b') llist.append('c') _assert(llist.index('c'), 2) _assert(llist.head.value, 'a') _assert(llist.tail.value, 'c') node = llist.pop() _assert_raises(ValueError, llist.index, 'c') _assert(llist.head.value, 'a') _assert(llist.tail.value, 'b') _assert(node.value, 'c') node = llist.pop() _assert(llist.head.value, 'a') _assert(llist.tail.value, 'a') _assert(node.value, 'b') node = llist.pop() _assert(llist.head, None) _assert(llist.tail, None) _assert(node.value, 'a') _assert_raises(IndexError, llist.pop) llist.append('a') llist.append('b') llist.append('c') for value, expected_value in zip(llist, 'abc'): _assert(value, expected_value) _assert(llist[0], 'a') _assert(llist[1], 'b') _assert(llist[2], 'c') node = llist.remove('b') _assert(node.value, 'b') node = llist.remove('c') node = llist.remove('a') _assert(llist.head, None) _assert(llist.tail, None) _assert_raises(IndexError, llist.__getitem__, 0) _assert_raises(IndexError, llist.__getitem__, 1) _assert_raises(TypeError, llist.__getitem__, 'expect int') simple_list = [1, 2, 3] llist = LinkedList([1, 2, 3]) for value, expected_value in zip(llist, simple_list): _assert(value, expected_value) _assert(LinkedList(), LinkedList()) _assert(LinkedList([]), LinkedList()) _assert(LinkedList([1]), LinkedList([1])) _assert(LinkedList([None]), LinkedList([None])) _assert(LinkedList([None]) == LinkedList([]), False) _assert(LinkedList([1, 2]) == LinkedList([1, None]), False) _assert(LinkedList([None]) == LinkedList([None, None]), False)
def test(): from simpletest import _assert _assert(get_digit(123, 0), 3) _assert(get_digit(123, 1), 2) _assert(get_digit(123, 2), 1) _assert(get_digit(123, 3), 0) _assert(get_digit(5, 0, 2), 1) _assert(get_digit(5, 1, 2), 0) _assert(get_digit(5, 2, 2), 1) _assert(get_digit(5, 3, 2), 0)
def test(): from simpletest import _assert a = A('name A') p = Prototype() p.register('a', a) b = p.clone('a') _assert(a.f(), b.f()) _assert(id(a) == id(b), False) _assert(a.name, 'name A') _assert(b.name, 'name A') p.unregister('a') _assert(p._objects, {}) p.unregister('a') _assert(p._objects, {})
def test(): _assert(binsearch([5, 23, 312, 358, 373, 502, 670, 834, 946, 973], 5), 0) _assert(binsearch([1, 2, 3], 4), -1) _assert(binsearch([1, 2, 3], 0), -1) _assert(binsearch([1, 2, 3], -1), -1) _assert(binsearch([1, 2, 3], 3), 2) _assert(binsearch([-1, 1, 2, 3], -1), 0)
def test(): from simpletest import _assert n = 3 towers = [] for i in range(3): towers.append(Tower(i)) for k in reversed(xrange(n)): print "Adding ring " + str(k) towers[0].add(k) _assert(towers[0].rings, [2, 1, 0]) _assert(towers[1].rings, []) _assert(towers[2].rings, []) move_rings(n-1, towers[0], towers[2], towers[1]) _assert(towers[0].rings, []) _assert(towers[1].rings, []) _assert(towers[2].rings, [2, 1, 0])
def test(): _assert(_bin(get_bit(5, 0)), "1") _assert(_bin(get_bit(5, 1)), "0") _assert(_bin(get_bit(5, 2)), "1") _assert(_bin(get_bit(5, 3)), "0") _assert(_bin(set_bit(5, 0)), "101") _assert(_bin(set_bit(5, 1)), "111") _assert(_bin(set_bit(5, 2)), "101") _assert(_bin(set_bit(5, 3)), "1101") _assert(_bin(clear_bit(5, 0)), "100") _assert(_bin(clear_bit(5, 1)), "101") _assert(_bin(clear_bit(5, 2)), "1") _assert(_bin(clear_bit(5, 3)), "101") _assert(_bin(toggle_bit(5, 0)), "100") _assert(_bin(toggle_bit(5, 1)), "111") _assert(_bin(toggle_bit(5, 2)), "1") _assert(_bin(toggle_bit(5, 3)), "1101") _assert(_bin(update_bit(5, 0, 0)), "100") _assert(_bin(update_bit(5, 0, 1)), "101") _assert(_bin(update_bit(5, 1, 0)), "101") _assert(_bin(update_bit(5, 1, 1)), "111") _assert(_bin(update_bit(5, 2, 0)), "1") _assert(_bin(update_bit(5, 2, 1)), "101") _assert(_bin(update_bit(5, 3, 0)), "101") _assert(_bin(update_bit(5, 3, 1)), "1101") _assert(_bin(clear_bits_from_bit_up(5, 0)), "0") _assert(_bin(clear_bits_from_bit_up(5, 1)), "1") _assert(_bin(clear_bits_from_bit_up(5, 2)), "1") _assert(_bin(clear_bits_from_bit_up(5, 3)), "101") _assert(_bin(clear_bits_from_bit_down(5, 0)), "100") _assert(_bin(clear_bits_from_bit_down(5, 1)), "100") _assert(_bin(clear_bits_from_bit_down(5, 2)), "0") _assert(_bin(clear_bits_from_bit_down(5, 3)), "0")