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")
