class Test_Bag(unittest.TestCase):
def setUp(self):
self.alist = ['d', 'a', 'b', 'd', 'c', 'b', 'd']
self.bag = Bag(self.alist)
def test_len(self):
initialv = 7
while initialv >= 0:
self.assertEqual(self.bag.__len__(), initialv, 'unexpected len')
random.shuffle(self.alist)
if initialv > 0:
toremove = self.alist[0]
self.bag.remove(toremove)
self.alist.remove(toremove)
initialv -= 1
def test_unique(self):
initialv = 4
while initialv >= 0:
uniquevals = list(self.bag.counts)
random.shuffle(uniquevals)
self.assertEqual(self.bag.unique(), initialv,
'unexpected unique val')
self.assertEqual(self.bag.unique(), len(self.bag.counts),
'unexpected unique val')
if initialv > 0:
toremove = uniquevals[0]
del self.bag.counts[toremove]
initialv -= 1
def test_contains(self):
for value in ['a', 'b', 'c', 'd']:
self.assertTrue(self.bag.__contains__(value),
'unexpected contains')
self.assertFalse(self.bag.__contains__('x'), 'bag contains x')
def test_count(self):
masterdict = {'a': 1, 'b': 2, 'c': 1, 'd': 3, 'x': 0}
totcount = 7
for value in masterdict:
self.assertEqual(self.bag.count(value), masterdict[value],
'unexpected count')
masterdict = {
'a': 1,
'b': 2,
'c': 1,
'd': 3,
}
while totcount >= 0:
totalvalue = 0
for value in self.bag.counts:
totalvalue += self.bag.counts[value]
self.assertEqual(totalvalue, totcount)
listkeys = list(masterdict)
random.shuffle(listkeys)
if totcount > 0:
toremove = listkeys[0]
self.bag.remove(toremove)
masterdict[toremove] -= 1
if masterdict[toremove] == 0:
del masterdict[toremove]
totcount -= 1
def test_equals(self):
listone = []
listtwo = []
for x in range(1000):
c = random.randint(1, 10)
listone.append(c)
listtwo.append(c)
random.shuffle(listone)
b1 = Bag(listone)
b2 = Bag(listtwo)
self.assertTrue(b1 == b2)
def test_add(self):
listone = []
listtwo = []
for x in range(1000):
c = random.randint(1, 10)
listone.append(c)
listtwo.append(c)
random.shuffle(listone)
b1 = Bag(listone)
b2 = Bag()
for item in listtwo:
b2.add(item)
self.assertTrue(b1 == b2)
def test_remove(self):
listone = []
listtwo = []
for x in range(1000):
c = random.randint(1, 10)
listone.append(c)
listtwo.append(c)
random.shuffle(listtwo)
b1 = Bag(listone)
b2 = Bag(listone)
self.assertRaises(ValueError, b1.remove, 53)
for item in listtwo:
b2.add(item)
for item in listtwo:
b2.remove(item)
self.assertTrue(b1 == b2)
def test_contains(self):
comp_set = ['a', 'b', 'c', 'd']
while len(comp_set) != 0:
self.assertTrue(Bag.__contains__(self.bag, comp_set[0]), "'{}' not in bag.".format(str(comp_set[0])))
comp_set.remove(comp_set[0])
self.assertFalse(Bag.__contains__(self.bag, 'x'), "'x' is in bag.")
class Test_Bag(unittest.TestCase):
def setup(self):
self.alist = ['d', 'a', 'b', 'd', 'c', 'b', 'd']
self.bag = Bag(self.alist)
def test_len(self):
self.setup()
self.assertEqual(self.bag.__len__(),
7) #Initial Bag should have 7 items
count = 7
random.shuffle(self.alist) #Shuffle alist
for x in self.alist:
self.bag.remove(x) #Remove random item in bag
count -= 1
self.assertEqual(self.bag.__len__(),
count) #Check if item count went down
def test_unique(self):
self.setup()
self.assertEqual(self.bag.unique(), 4)
random.shuffle(self.alist) #Shuffle alist
for x in self.alist:
self.bag.remove(x) #Remove random item in bag
self.assertEqual(self.bag.unique(), len(self.bag.counts))
def test_contains(self):
self.setup()
self.assertTrue(self.bag.__contains__('a')) and self.assertTrue(
self.bag.__contains__('b')) and self.assertTrue(
self.bag.__contains__('c'))
self.assertFalse(self.bag.__contains__('x'))
def test_count(self):
self.setup()
self.assertEqual(self.bag.counts['a'], 1)
self.assertEqual(self.bag.counts['b'], 2)
self.assertEqual(self.bag.counts['c'], 1)
self.assertEqual(self.bag.counts['d'], 3)
self.assertEqual(self.bag.counts['x'], 0)
count = sum(self.bag.counts.values())
random.shuffle(self.alist) #Shuffle alist
for x in self.alist:
self.bag.remove(x)
count -= 1
self.assertEqual(sum(self.bag.counts.values()), count)
def test_equals(self):
rand_list = [random.randint(1, 10)
for i in range(0, 1000)] #Make 1000-value random list
bag1 = Bag(rand_list) #Create bag from random list
random.shuffle(rand_list) #Shuffle random list
bag2 = Bag(rand_list) #Create another bag from shuffled random list
self.assertTrue(bag1.__eq__(bag2)) #They should be equal
bag1.remove(rand_list[0]) #Remove 1 value from one bag
self.assertFalse(bag1.__eq__(bag2)) #They should NOT be equal
def test_add(self):
rand_list = [random.randint(1, 10)
for i in range(0, 1000)] #Make 1000-value random list
bag1 = Bag(rand_list) #Create bag from random list
bag2 = Bag() #Create another bag from shuffled random list
random.shuffle(rand_list) #Shuffle random list
for x in rand_list:
bag2.add(x)
self.assertEqual(bag1, bag2)
def test_remove(self):
rand_list = [random.randint(1, 10)
for i in range(0, 1000)] #Make 1000-value random list
bag1 = Bag(rand_list) #Create bag from random list
with self.assertRaises(ValueError):
bag1.remove(43)
bag2 = Bag(rand_list)
random.shuffle(rand_list) #Shuffle random list
for x in rand_list:
bag2.add(x)
for x in rand_list:
bag2.remove(x)
self.assertEqual(bag1, bag2)
class Test_Bag(unittest.TestCase):
def setUp(self):
self.alist = ['d','a','b','d','c','b','d']
self.bag = Bag(self.alist)
def testlen(self):
assert len(self.bag) == 7
random.shuffle(self.alist)
for i in irange(1, len(self.alist)):
self.bag.remove(self.alist[i - 1])
assert len(self.bag) == 7 - i, '{}, {}'.format(i, self.bag.counts)
def testunique(self):
assert self.bag.unique() == 4
random.shuffle(self.alist)
for i in irange(1, len(self.alist)):
self.bag.remove(self.alist[i - 1])
assert self.bag.unique() == len(self.bag.counts)
def testcontains(self):
for letter in ['a', 'b', 'c']:
assert self.bag.__contains__(letter)
assert not self.bag.__contains__('x')
def testcount(self):
assert list(map(lambda x: self.bag.count(x), ['a', 'b', 'c', 'd', 'x'])) == [1, 2, 1, 3, 0]
random.shuffle(self.alist)
for i in irange(1, len(self.alist)):
self.bag.remove(self.alist[i - 1])
assert sum([self.bag.count(x) for x in self.bag.counts]) == len(self.alist) - i
def testequals(self):
rand_list = []
for i in range(1000):
rand_list.append(random.randint(1, 10))
bag = Bag(rand_list)
random.shuffle(rand_list)
bag2 = Bag(rand_list)
assert bag == bag2
bag.remove(rand_list[0])
assert bag != bag2
def testadd(self):
rand_list = []
for i in range(1000):
rand_list.append(random.randint(1, 10))
bag = Bag(rand_list)
bag2 = Bag()
random.shuffle(rand_list)
for value in rand_list:
bag2.add(value)
assert bag == bag2
def testremove(self):
rand_list = []
for i in range(1000):
rand_list.append(random.randint(1, 10))
bag = Bag(rand_list)
try:
bag.remove(62)
except ValueError:
pass
bag2 = Bag(rand_list)
random.shuffle(rand_list)
for value in rand_list:
bag2.add(value)
for value in rand_list:
bag2.remove(value)
assert bag == bag2
