def test_lock(self): #Test locking an item tll = Structs.LockableList(values=None) tll.lock(set_lock=True, force_update=False) self.assertTrue(tll.is_locked) #Test unlocking an item with update tll = Structs.LockableList(values=None) tll.extend([3, 4, 5]) tll.lock(set_lock=True, force_update=False) tll.remove(4) actual = len(tll) expected = 3 self.assertTrue(actual == expected) tll.lock(set_lock=False, force_update=True) actual = len(tll) expected = 2 self.assertTrue(actual == expected) #Test toggle lock tll = Structs.LockableList(values=None) self.assertTrue(not tll.is_locked) tll.lock() self.assertTrue(tll.is_locked) tll.lock() self.assertTrue(not tll.is_locked)
def test_append(self): #Test appending good value values = ["bob", "steve"] tcl = Structs.TypeCheckedList(str, values=values, suppress_type_errors=True) tcl.append("jack") actual = len(tcl) expected = 3 self.assertTrue(actual == expected) #Test appending bad value, suppression on values = ["bob", "steve"] tcl = Structs.TypeCheckedList(str, values=values, suppress_type_errors=True) tcl.append(3) actual = len(tcl) expected = 2 self.assertTrue(actual == expected) #Test appending bad value, suppression off values = ["bob", "steve"] tcl = Structs.TypeCheckedList(str, values=values, suppress_type_errors=False) with self.assertRaises(TypeError): tcl.append(3)
def test_clear(self): #Test clear on front only tdb = Structs.DoubleBuffer() tdb._write_front_buffer(3) tdb._write_front_buffer(4) tdb._write_back_buffer(100) tdb._write_back_buffer(200) tdb.clear(front=True, back=False) expected_front = [] actual_front = tdb.get_front_buffer_items() self.assertListEqual(expected_front, actual_front) expected_back = [100, 200] actual_back = tdb.get_back_buffer_items() self.assertListEqual(expected_back, actual_back) #Test clear on back only tdb = Structs.DoubleBuffer() tdb._write_front_buffer(3) tdb._write_front_buffer(4) tdb._write_back_buffer(100) tdb._write_back_buffer(200) tdb.clear(front=False, back=True) expected_front = [3, 4] actual_front = tdb.get_front_buffer_items() self.assertListEqual(expected_front, actual_front) expected_back = [] actual_back = tdb.get_back_buffer_items() self.assertListEqual(expected_back, actual_back) #Test clear on both tdb = Structs.DoubleBuffer() tdb._write_front_buffer(3) tdb._write_front_buffer(4) tdb._write_back_buffer(100) tdb._write_back_buffer(200) tdb.clear(front=True, back=True) expected_front = [] actual_front = tdb.get_front_buffer_items() self.assertListEqual(expected_front, actual_front) expected_back = [] actual_back = tdb.get_back_buffer_items() self.assertListEqual(expected_back, actual_back) #Test clear on neither tdb = Structs.DoubleBuffer() tdb._write_front_buffer(3) tdb._write_front_buffer(4) tdb._write_back_buffer(100) tdb._write_back_buffer(200) tdb.clear(front=False, back=False) expected_front = [3, 4] actual_front = tdb.get_front_buffer_items() self.assertListEqual(expected_front, actual_front) expected_back = [100, 200] actual_back = tdb.get_back_buffer_items() self.assertListEqual(expected_back, actual_back)
def test_call(self): #Test normal behavior tll = Structs.LockableList(values=None) tll.extend([3, 4, 5]) actual = [] expected = [3, 4, 5] for value in tll: actual.append(value) self.assertListEqual(actual, expected) #Test locked behavior with pending addition tll = Structs.LockableList(values=None) tll.extend([3, 4, 5]) tll.lock() tll.append(100) actual = [] expected = [3, 4, 5] for value in tll: actual.append(value) self.assertListEqual(actual, expected) #Make sure the call is applying pending updates tll = Structs.LockableList(values=None) tll.extend([3, 4, 5]) tll.lock(force_update=False) tll.append(100) tll.lock(force_update=False) actual = [] expected = [3, 4, 5, 100] for value in tll: actual.append(value) self.assertListEqual(actual, expected)
def test_init(self): #Test empty constructor empty_tll = Structs.LockableList(values=None) actual = len(empty_tll) expected = 0 self.assertTrue(actual == expected) #Test constructor with values values = [1, 2, 3, 'bob'] tll = Structs.LockableList(values=values) actual = len(tll) expected = 4 self.assertTrue(actual == expected)
def test_clear(self): #Test normal clear, no lcoks tll = Structs.LockableList(values=None) tll.extend([3, 4, 5]) tll.clear() self.assertFalse(tll) self.assertFalse(tll.pending_additions) self.assertFalse(tll.pending_removals) #Test with lock and pending updates tll = Structs.LockableList(values=None) tll.extend([3, 4, 5]) tll.lock() tll.extend([100, 200]) tll.clear() self.assertFalse(tll) self.assertFalse(tll.pending_additions) self.assertFalse(tll.pending_removals)
def test_extend(self): #Test extend with empty iterable values = ["bob", "steve"] tcl = Structs.TypeCheckedList(str, values=values, suppress_type_errors=True) tcl.extend([]) actual = len(tcl) expected = 2 self.assertTrue(actual == expected) #Test extend with a non-iterable values = ["bob", "steve"] tcl = Structs.TypeCheckedList(str, values=values, suppress_type_errors=True) tcl.extend("jack") actual = len(tcl) expected = 3 self.assertTrue(actual == expected) #Test extend with all valid values = ["bob", "steve"] tcl = Structs.TypeCheckedList(str, values=values, suppress_type_errors=True) tcl.extend(values) actual = len(tcl) expected = 4 self.assertTrue(actual == expected) #Test extend with some invalid, suppressed values = ["bob", "steve"] tcl = Structs.TypeCheckedList(str, values=values, suppress_type_errors=True) tcl.extend(["jack", 3]) actual = len(tcl) expected = 3 self.assertTrue(actual == expected) #Test extend with some invalid, not suppressed values = ["bob", "steve"] tcl = Structs.TypeCheckedList(str, values=values, suppress_type_errors=False) with self.assertRaises(TypeError): tcl.extend(["jack", 3])
def test_extend(self): #Test extend on unlocked tll = Structs.LockableList(values=None) tll.extend(["Yellow", "Blue"]) actual = len(tll) expected = 2 self.assertTrue(actual == expected) #Test extend on locked- check _to_add and len() tll = Structs.LockableList(values=None) tll.lock(set_lock=True, force_update=False) tll.extend(["Yellow", "Red"]) actual = len(tll.pending_additions) expected = 2 self.assertTrue(actual == expected) actual = len(tll) expected = 0 self.assertTrue(actual == expected)
def test_init(self): #Test empty constructor empty_tcl = Structs.TypeCheckedList(int, values=None, suppress_type_errors=True) actual = len(empty_tcl) expected = 0 self.assertTrue(actual == expected) #Test constructor with values values = [1, 2, 3, 'bob'] tcl = Structs.TypeCheckedList(int, values=values, suppress_type_errors=True) actual = len(tcl) expected = 3 self.assertTrue(actual == expected) #Test bad extend with no TypeError suppression values = [1, 2, 3, 'bob'] with self.assertRaises(TypeError): tcl = Structs.TypeCheckedList(int, values=values, suppress_type_errors=False)
def test_clear(self): values = ["bob", "steve"] tcl = Structs.TypeCheckedList(str, values=values, suppress_type_errors=True) tcl.append("jack") actual = len(tcl) expected = 3 self.assertTrue(actual == expected) tcl.clear() actual = len(tcl) expected = 0 self.assertTrue(actual == expected)
def test_push(self): #Test wrong type push tdb = Structs.DoubleBuffer() #Test proper push tdb.push(3) tbd_fb = tdb.get_front_buffer_items() tbd_bb = tdb.get_back_buffer_items() expected_fb = 0 expected_bb = 1 actual_fb = len(tbd_fb) actual_bb = len(tbd_bb) self.assertTrue(expected_fb == actual_fb) self.assertTrue(expected_bb == actual_bb)
def test_flip_exact(self): tdb = Structs.DoubleBuffer() tdb.push(3) tdb.push(4) tdb.flip(mode='exact') tdb.push(100) tdb.push(200) tdb.flip(mode='exact') expected_front = [100, 200] actual_front = tdb.get_front_buffer_items() self.assertListEqual(expected_front, actual_front) expected_back = [3, 4] actual_back = tdb.get_back_buffer_items() self.assertListEqual(expected_back, actual_back)
def test_pop(self): #Test that pop from empty list raises IndexError tdb = Structs.DoubleBuffer() with self.assertRaises(IndexError): tdb.pop() #Test that pop after push STILL raises IndexError since push is to bbuf tdb = Structs.DoubleBuffer() tdb.push(3) with self.assertRaises(IndexError): tdb.pop() #Test that pop after push AND flip correctly gets the value back #Push an value after the flip to make sure that value doesn't get returned #(should be in back buffer) tdb = Structs.DoubleBuffer() tdb.push("Yellow") tdb.flip(mode='exact') tdb.push("Red") expected = "Yellow" actual = tdb.pop() self.assertTrue(expected == actual) with self.assertRaises(IndexError): tdb.pop()
def test_remove(self): #Test remove on unlocked with value in set tll = Structs.LockableList(values=None) tll.extend([3, 4, 5]) tll.remove(4) actual = len(tll) expected = 2 self.assertTrue(actual == expected) #Test remove on unlocked with value NOT in set tll = Structs.LockableList(values=None) tll.extend([3, 4, 5]) with self.assertRaises(ValueError): tll.remove(100) #Test remove of existing value on locked- check _to_add and len() tll = Structs.LockableList(values=None) tll.extend([3, 4, 5]) tll.lock(set_lock=True, force_update=False) tll.remove(4) actual = len(tll) expected = 3 self.assertTrue(actual == expected)
def test_sort(self): #Test sort for normal behavior tll = Structs.LockableList(values=None) tll.extend([5, 3, 4]) tll.sort() actual = tll[:] expected = [3, 4, 5] self.assertListEqual(actual, expected) #Test sort with pending updates tll = Structs.LockableList(values=None) tll.extend([5, 3, 4]) tll.lock(force_update=False) tll.extend([0, 1, 2]) tll.sort() actual = tll[:] expected = [3, 4, 5] self.assertListEqual(actual, expected) #Then unlock and test again tll.lock(force_update=False) tll.sort() actual = tll[:] expected = [0, 1, 2, 3, 4, 5] self.assertListEqual(actual, expected)
def test_flip_transfer_front(self): tdb = Structs.DoubleBuffer() tdb.push(3) tdb.push(4) tdb.flip(mode='exact') #This flip is simply so that we can put stuff #In both buffers tdb.push(100) tdb.push(200) tdb.flip(mode='transfer_front') #This is the flip we're testing expected_front = [100, 200, 3, 4] actual_front = tdb.get_front_buffer_items() self.assertListEqual(expected_front, actual_front) expected_back = [] actual_back = tdb.get_back_buffer_items() self.assertListEqual(expected_back, actual_back)
def test_properties(self): #Check HasPendingUpdates, is_locked, ChangedSinceLastCall tll = Structs.LockableList(values=None) tll.lock(set_lock=True, force_update=False) self.assertFalse(tll.is_dirty) self.assertTrue(tll.is_locked) tll.lock(set_lock=False, force_update=False) tll.extend([5, 3, 4]) #Extending while unlocked shouldn't queue updates self.assertFalse(tll.is_dirty) self.assertFalse(tll.is_locked) tll.lock(set_lock=True, force_update=False) tll.extend([0, 1, 2]) #Now they should be queued self.assertTrue(tll.is_dirty) self.assertTrue(tll.is_locked)
def test_no_key(self): an_enum = Structs.enum("bob", "steve") with self.assertRaises(AttributeError): an_enum.jim
def test_valid_key(self): an_enum = Structs.enum("bob", "steve") actual = an_enum.steve expected = 1 self.assertTrue(actual == expected)
def test_empty_enum(self): empty_enum = Structs.enum() actual = type(empty_enum) == type self.assertTrue(actual)