def test_trim_and_replace(self):
''' test the trim and replace utility '''
cake = CollectionResource(['c'])
trim = CollectionResource(['a', 'b'])
user = CollectionPreference('mark', {'a': 1, 'b': 5, 'c': 10})
piece = trim_and_replace(user, cake, trim, 1)
self.assertEqual(cake, CollectionResource(['c', 'b']))
def test_resource_create(self):
''' test that the resource factory methods work '''
cake1 = CollectionResource.random(5)
cake2 = CollectionResource.random(5)
cake3 = CollectionResource.random()
self.assertEqual(cake1.actual_value(), cake2.actual_value())
self.assertNotEqual(cake1.value, cake2.value)
self.assertNotEqual(cake1.value, cake3.value)
def test_resource_as_collection(self):
''' test that we can convert a resource to a collection '''
keys = ['red', 'blue', 'green']
cake = CollectionResource(keys)
pieces = cake.as_collection()
actual = [CollectionResource(key) for key in keys]
for this,that in zip(pieces, actual):
self.assertEqual(this.value, that.value)
def test_create_equal_pieces(self):
''' test the create equal pieces utility '''
pref = {'a': 1, 'b': 1, 'c': 1}
cake = CollectionResource(pref.keys())
user = CollectionPreference('mark', pref)
actual = create_equal_pieces(user, cake, 3)
pieces = [CollectionResource([k]) for k in pref.keys()]
self.assertEqual(actual, pieces)
def test_choose_best_piece(self):
''' test the choose best piece utility '''
prefs = {'a': 1, 'b': 2, 'c': 3}
cakes = [CollectionResource([k]) for k in prefs.keys()]
user = CollectionPreference('mark', prefs)
actual = choose_best_piece(user, cakes)
self.assertEqual(actual.value, ['c'])
user.values['b'] = 3
cakes = [CollectionResource([k]) for k in prefs.keys()]
actual = choose_best_piece(user, cakes)
self.assertEqual(actual.value, ['c'])
def test_preference_create(self):
''' test that the preference is created correctly '''
vals = {'a': 4, 'b': 3, 'c': 2, 'd': 1}
keys = sorted(vals.keys())
cake = CollectionResource(keys)
user1 = CollectionPreference('mark', vals)
user2 = OrdinalPreference('john', keys)
self.assertEqual(user1.value_of(cake), user2.value_of(cake))
random.seed(1) # to ensure same test
cake = CollectionResource(['a'])
user3 = OrdinalPreference.random(cake)
self.assertNotEqual(user2.value_of(cake), user3.value_of(cake))
def test_resource_create_pieces(self):
''' test that we can create n pieces of the cake '''
keys = ['red', 'blue', 'green', 'yellow', 'orange', 'purple']
vals = dict((k, F(1,1)) for k in keys)
cake = CollectionResource(keys)
user = CollectionPreference('mark', vals)
pieces = create_equal_pieces(user, cake, 3)
actual = [
CollectionResource(['red', 'blue']),
CollectionResource(['green', 'yellow']),
CollectionResource(['orange', 'purple'])
]
for this,that in zip(pieces, actual):
self.assertEqual(this.value, that.value)
def test_division(self):
''' test that the algorithm divides correctly '''
vals = {'red': 10, 'blue': 20, 'green': 30}
keys = vals.keys()
cake = CollectionResource(keys)
users = []
users.append(
CollectionPreference('mark', {
'red': 10,
'blue': 20,
'green': 30
}))
users.append(
CollectionPreference('john', {
'red': 10,
'blue': 30,
'green': 20
}))
users.append(
CollectionPreference('anna', {
'red': 30,
'blue': 20,
'green': 10
}))
algorithm = SealedBidsAuction(users, cake)
divisions = algorithm.divide()
for user, pieces in divisions.items():
self.assertEqual(30, get_total_value(user, pieces))
def test_choose_last_piece(self):
''' test the choose last piece utility '''
a, b, c = V('a', 10), V('b', 100), V('c', 1000)
cake = CollectionResource([a, b, c])
users = [
CollectionPreference('mark', {
a: 0.50,
b: 0.50
}),
CollectionPreference('john', {
a: 0.25,
b: 0.75
})
]
user, piece = choose_last_piece(users, cake)
self.assertEqual(user, users[1])
self.assertEqual(piece, CollectionResource([a]))
def test_choose_lowest_bidder(self):
''' test the choose lowest bidder utility '''
cake = CollectionResource(['cake'])
users = [
CollectionPreference('mark', {'cake': 1}),
CollectionPreference('john', {'cake': 0})
]
actual = choose_lowest_bidder(users, cake)
self.assertEqual(actual, users[1])
def test_initializes(self):
''' test that the algorithm initializes correctly '''
keys = ['red', 'blue', 'green', 'yello', 'orange']
vals = dict((k, 100 / len(keys)) for k in keys)
cake = CollectionResource(keys)
users = []
users.append(CollectionPreference('mark', vals))
users.append(CollectionPreference('john', vals))
algorithm = SealedBidsAuction(users, cake)
self.assertEqual(True, algorithm.is_valid())
def test_inverse_division(self):
''' test that the inverse algorithm divides correctly '''
vals = {'red': 10, 'blue': 20, 'green': 30, 'yello': 15, 'orange': 25}
keys = vals.keys()
cake = CollectionResource(keys)
users = []
users.append(CollectionPreference('mark', vals))
users.append(CollectionPreference('john', vals))
algorithm = InverseDivideAndChoose(users, cake)
divisions = algorithm.divide()
for user, piece in divisions.items():
self.assertEqual(50, user.value_of(piece))
def test_list_worst_pieces(self):
''' test the list worst pieces utility '''
cakes = [CollectionResource(['a']), CollectionResource(['b'])]
users = [
CollectionPreference('mark', {
'a': 1,
'b': 0
}),
CollectionPreference('john', {
'a': 0,
'b': 1
})
]
actual = list_worst_pieces(users, cakes)
expect = {users[0]: cakes[1], users[1]: cakes[0]}
self.assertEqual(actual, expect)
users[0].values = {'a': 1, 'b': 0}
users[1].values = {'a': 1, 'b': 0}
actual = list_worst_pieces(users, cakes)
expect = {users[0]: cakes[1], users[1]: cakes[1]}
self.assertEqual(actual, expect)
def test_resource_remove(self):
''' test that the resource remove works correctly '''
keys = ['red', 'blue', 'green', 'yellow', 'orange']
cake = CollectionResource(keys)
item = CollectionResource(keys[2:])
cake.remove(item)
actual = CollectionResource(keys[:2])
self.assertEqual(actual, cake)
def test_resource_append(self):
''' test that the resource append works correctly '''
keys = ['red', 'blue', 'green', 'yellow', 'orange']
cake = CollectionResource(keys[:-2])
item = CollectionResource(keys[-2:])
cake.append(item)
actual = CollectionResource(keys)
self.assertEqual(actual.value, cake.value)
def test_initializes(self):
''' test that the algorithm initializes correctly '''
keys = ['red', 'blue', 'green', 'yello', 'orange']
vals = dict((k, 100 / len(keys)) for k in keys)
cake = CollectionResource(keys)
users = []
users.append(CollectionPreference('mark', vals))
users.append(CollectionPreference('john', vals))
algorithm = DivideAndChoose(users, cake)
self.assertEqual(True, algorithm.is_valid())
algorithm.users.append(CollectionPreference('bill', vals))
self.assertRaises(ValueError, lambda: algorithm.is_valid())
def test_sort_by_value(self):
''' test the sort by value utility '''
keys = ['a', 'b', 'c']
prefs = {'a': 1, 'b': 2, 'c': 3}
cakes = [CollectionResource([k]) for k in keys]
user = CollectionPreference('mark', prefs)
expected = [(3, cakes[2]), (2, cakes[1]), (1, cakes[0])]
actual = sort_by_value(user, cakes, reverse=True)
self.assertEqual(actual, expected)
expected = [(1, cakes[0]), (2, cakes[1]), (3, cakes[2])]
actual = sort_by_value(user, cakes)
self.assertEqual(actual, expected)
def test_preference_create(self):
''' test that the preference factory methods work '''
path = os.path.join(os.path.abspath('contrib'), 'data')
path = os.path.join(path, 'collection')
path = os.path.join(path, 'uniform')
user1 = CollectionPreference.from_file(path)
keys = user1.values.keys()
prefs = dict((p, 0.25) for p in keys)
user2 = CollectionPreference('user2', prefs)
cake = CollectionResource(keys)
self.assertEqual(user1.value_of(cake), user2.value_of(cake))
users = [CollectionPreference.random(cake) for i in range(5)]
for user in users:
self.assertTrue(0.95 <= user.value_of(cake) <= 1.05)
def test_resource_clone(self):
''' test that the resource clone works correctly '''
keys = ['red', 'blue', 'green', 'yellow', 'orange']
vals = dict((k, F(1,1)) for k in keys)
cake = CollectionResource(keys)
user = CollectionPreference('mark', vals)
copy = cake.clone()
self.assertEqual(str(cake), str(copy))
self.assertEqual(repr(cake), repr(copy))
self.assertEqual(5, cake.actual_value(),)
self.assertEqual(cake.actual_value(), copy.actual_value())
self.assertEqual(CollectionResource('a'), CollectionResource(['a']))
def test_resource_find_pieces(self):
''' test that we can find a piece in the cake '''
keys = ['red', 'blue', 'green', 'yellow', 'orange', 'purple']
vals = dict((k, F(1,1)) for k in keys)
cake = CollectionResource(keys)
user = CollectionPreference('mark', vals)
piece = cake.find_piece(user, 3)
actual = CollectionResource(['red', 'blue', 'green'])
self.assertEqual(piece.value, actual.value)
vals = {'red':10, 'blue':20, 'green':30, 'yellow':15, 'orange':25}
keys = vals.keys()
cake = CollectionResource(keys)
user = CollectionPreference('mark', vals)
self.assertEqual(50, user.value_of(cake.find_piece(user, 50)))
self.assertEqual(60, user.value_of(cake.find_piece(user, 60)))
self.assertEqual(70, user.value_of(cake.find_piece(user, 70)))
vals = {'red':10, 'blue':20, 'green':30, 'orange':40}
keys = vals.keys()
cake = CollectionResource(keys)
user = CollectionPreference('mark', vals)
self.assertEqual(50, user.value_of(cake.find_piece(user, 50)))
self.assertEqual(60, user.value_of(cake.find_piece(user, 60)))
self.assertEqual(70, user.value_of(cake.find_piece(user, 70)))
self.assertRaises(ValueError, lambda: cake.find_piece(user, 150))
