def test_default_ordering_2(self): results = SearchResults(5) results._add_hit(1, 5, 0.2) results._add_hit(1, 6, 0.4) for result in results: result.reorder() self.assertListEquals(results[1], [(6, 0.4), (5, 0.2)])
def test_reorder_row(self): results = SearchResults(2) results._add_hit(0, 1, 0.1) results._add_hit(0, 2, 0.8) results._add_hit(0, 3, 0.6) results._add_hit(1, 6, 0.1) results._add_hit(1, 7, 0.8) results._add_hit(1, 8, 0.6) self.assertListEquals(results[0], [(1, 0.1), (2, 0.8), (3, 0.6)]) self.assertListEquals(results[1], [(6, 0.1), (7, 0.8), (8, 0.6)]) results[1].reorder("increasing-score") self.assertListEquals(results[0], [(1, 0.1), (2, 0.8), (3, 0.6)]) self.assertListEquals(results[1], [(6, 0.1), (8, 0.6), (7, 0.8)]) results[0].reorder("decreasing-score") self.assertListEquals(results[0], [(2, 0.8), (3, 0.6), (1, 0.1)]) self.assertListEquals(results[1], [(6, 0.1), (8, 0.6), (7, 0.8)]) # Check that the default works results[0].reorder( "increasing-score") # ensure the default only affects one row results[1].reorder() self.assertListEquals(results[0], [(1, 0.1), (3, 0.6), (2, 0.8)]) self.assertListEquals(results[1], [(7, 0.8), (8, 0.6), (6, 0.1)])
def test_size_3(self): results = SearchResults(5) results._add_hit(1, 5, 0.2) results._add_hit(1, 6, 0.4) results._add_hit(1, 7, 0.2) self.assertListEquals(results[1], [(5, 0.2), (6, 0.4), (7, 0.2)]) results.reorder_all("increasing-score") self.assertListEquals(results[1], [(5, 0.2), (7, 0.2), (6, 0.4)]) results.reorder_all("decreasing-score") self.assertListEquals(results[1], [(6, 0.4), (5, 0.2), (7, 0.2)])
def setUp(self): results = SearchResults(2) results.target_ids = map(str, range(40)) all_scores = [random_scores[:10], random_scores[30:35]] # First row has columns 0, 1, 2, ..., 9 # second row has columns 0, 2, 4, 6, 8 for row, scores in enumerate(all_scores): for i, score in enumerate(scores): results._add_hit(row, i * (row + 1), score) self.results = results
def test_size_2(self): results = SearchResults(5) results._add_hit(1, 5, 0.2) results._add_hit(1, 6, 0.4) self.assertListEquals(results[1], [(5, 0.2), (6, 0.4)]) for result in results: result.reorder("increasing-score") self.assertListEquals(results[1], [(5, 0.2), (6, 0.4)]) for result in results: result.reorder("decreasing-score") self.assertListEquals(results[1], [(6, 0.4), (5, 0.2)])
def setUp(self): results = SearchResults(2) results.target_ids = map(str, range(40)) all_scores = [random_scores[:10], random_scores[30:35]] # First row has columns 0, 1, 2, ..., 9 # second row has columns 0, 2, 4, 6, 8 for row, scores in enumerate(all_scores): for i, score in enumerate(scores): results._add_hit(row, i*(row+1), score) self.results = results
def test_regression_error_where_duplicate_indices_did_not_sort_correctly(self): # The id case doesn't happen in real code, since duplicate # indices are not possible. However, I suspect that the real # issue is with duplicate primary keys, so duplicate scores # might trigger the same problem. It's easiest to test with # indices. results = SearchResults(1) ids = range(5) * 2 for id in ids: results._add_hit(0, id, id/10.0) results.reorder_all("increasing-index") self.assertListEquals(results[0].get_indices(), sorted(ids))
def test_index_as_secondary_sort(self): # Timsort preserves input order. test_random_values uses # sequentially ordered indicies so can't tell the difference # between input order and index order. Here I reverse the # order so I can really test tie-breaking. for name in ("increasing-score", "decreasing-score", "increasing-index", "decreasing-index"): results = SearchResults(1) expected = [] for i in range(300): score = random_scores[i] results._add_hit(0, 400-i, score) expected.append((400-i, score)) results.reorder_all(name) expected.sort(key = _get_sort_key[name]) self.assertListEquals(results[0], expected, "error in %s (300)" % (name,))
def _create(self): results = SearchResults(4) for i, score in enumerate((0.1, 0.9, 0.2, 0.3, 0.15, 1.0)): results._add_hit(0, i, score) for i, score in enumerate((1.0, 0.0, 0.5, 0.14, 0.28)): results._add_hit(2, i, score) for i, score in enumerate((neg_inf, 0.0001, pos_inf)): results._add_hit(3, i, score) return results
def setUp(self): results = SearchResults(4) results._add_hit(1, 1, 0.1) results._add_hit(2, 7, 1.0) results._add_hit(3, 3, 0.2) results._add_hit(3, 4, 0.5) results._add_hit(3, 5, 0.6) results._add_hit(3, 6, 0.7) self.results = results
def test_clear(self): results = SearchResults(3) results._add_hit(0, 1, 0.0) results._add_hit(1, 12, 1.0) self.assertTrue(results[0]) self.assertTrue(results[1]) results.clear_all() self.assertFalse(results[0]) self.assertListEquals(results[0], []) self.assertFalse(results[1])
def test_two(self): results = SearchResults(2) results._add_hit(0, 1, 0.1) results._add_hit(0, 2, 0.8) results._add_hit(1, 2, 0.8) results._add_hit(1, 3, 0.6) results.reorder_all("reverse") self.assertListEquals(results[0], [(2, 0.8), (1, 0.1)]) self.assertListEquals(results[1], [(3, 0.6), (2, 0.8)])
def test_random_values(self): # The underlying timsort does merge sorts of 64 element # blocks. Hence some of the code is not exercised unless the # input is at least 128 elements long. for size in (3, 5, 10, 20, 70, 100, 400): results = SearchResults(1) expected = [] for i in range(size): score = random_scores[i] expected.append((i, score)) results._add_hit(0, i, score) self.assertListEquals(results[0], expected) for name in ("increasing-score", "decreasing-score", "increasing-index", "decreasing-index"): results.reorder_all(name) expected.sort(key = _get_sort_key[name]) self.assertListEquals(results[0], expected, "error in %s:%d" % (name, size))
def test_two(self): results = SearchResults(2) results._add_hit(0, 1, 0.1) results._add_hit(0, 2, 0.8) results._add_hit(1, 2, 0.8) results._add_hit(1, 3, 0.6) results.reorder_all("move-closest-first") self.assertListEquals(results[0], [(2, 0.8), (1, 0.1)]) self.assertListEquals(results[1], [(2, 0.8), (3, 0.6)])
def test_row_len(self): results = SearchResults(5) results._add_hit(0, 1, 0.1) results._add_hit(1, 2, 0.2) results._add_hit(1, 3, 0.25) results._add_hit(2, 1, 0.15) results._add_hit(2, 5, 0.7) results._add_hit(2, 6, 0.8) results._add_hit(3, 8, 0.9) self.assertEquals(len(results[0]), 1) self.assertEquals(len(results[1]), 2) self.assertEquals(len(results[2]), 3) self.assertEquals(len(results[3]), 1) self.assertEquals(len(results[4]), 0) self.assertEquals(len(results[-5]), 1) self.assertEquals(len(results[-4]), 2) self.assertEquals(len(results[-3]), 3) self.assertEquals(len(results[-2]), 1) self.assertEquals(len(results[-1]), 0)
def test_one(self): results = SearchResults(2) results._add_hit(0, 9, 0.1) results._add_hit(1, 8, 0.8) results.reorder_all("reverse") self.assertListEquals(results[0], [(9, 0.1)]) self.assertListEquals(results[1], [(8, 0.8)])
def test_negative_index(self): results = SearchResults(3) results._add_hit(0, 1, 0.0) results._add_hit(1, 12, 1.0) self.assertListEquals(results[1], [(12, 1.0)]) self.assertListEquals(results[-2], [(12, 1.0)]) self.assertListEquals(results[-3], [(1, 0.0)])
def test_sort_negative_row(self): results = SearchResults(2) results._add_hit(0, 1, 0.1) results._add_hit(0, 2, 0.8) results._add_hit(0, 3, 0.6) results._add_hit(1, 6, 0.1) results._add_hit(1, 7, 0.8) results._add_hit(1, 8, 0.6) self.assertListEquals(results[0], [(1, 0.1), (2, 0.8), (3, 0.6)]) self.assertListEquals(results[1], [(6, 0.1), (7, 0.8), (8, 0.6)]) results[-1].reorder("increasing-score") self.assertListEquals(results[0], [(1, 0.1), (2, 0.8), (3, 0.6)]) self.assertListEquals(results[1], [(6, 0.1), (8, 0.6), (7, 0.8)]) results[-2].reorder("decreasing-score") self.assertListEquals(results[0], [(2, 0.8), (3, 0.6), (1, 0.1)]) self.assertListEquals(results[1], [(6, 0.1), (8, 0.6), (7, 0.8)]) results[1].reorder() # default is decreasing score self.assertListEquals(results[0], [(2, 0.8), (3, 0.6), (1, 0.1)]) self.assertListEquals(results[1], [(7, 0.8), (8, 0.6), (6, 0.1)])
def test_clear_negative_row(self): results = SearchResults(3) results._add_hit(0, 1, 0.0) results._add_hit(1, 12, 1.0) self.assertListEquals(results[1], [(12, 1.0)]) results[-2].clear() self.assertListEquals(results[0], [(1, 0.0)]) self.assertListEquals(results[1], []) results[-3].clear() self.assertListEquals(results[0], []) self.assertListEquals(results[1], [])
def test_regression_error_where_duplicate_indices_did_not_sort_correctly( self): # The id case doesn't happen in real code, since duplicate # indices are not possible. However, I suspect that the real # issue is with duplicate primary keys, so duplicate scores # might trigger the same problem. It's easiest to test with # indices. results = SearchResults(1) ids = range(5) * 2 for id in ids: results._add_hit(0, id, id / 10.0) results.reorder_all("increasing-index") self.assertListEquals(results[0].get_indices(), sorted(ids))
def test_clear_row(self): results = SearchResults(3) results._add_hit(0, 1, 0.0) results._add_hit(1, 12, 1.0) self.assertListEquals(results[1], [(12, 1.0)]) results[1].clear() self.assertListEquals(results[0], [(1, 0.0)]) self.assertTrue(results[0]) self.assertEquals(len(results[0]), 1) self.assertFalse(results[1]) results[0].clear() self.assertFalse(results[0]) self.assertEquals(len(results[0]), 0) self.assertFalse(results[1])
def test_index_as_secondary_sort(self): # Timsort preserves input order. test_random_values uses # sequentially ordered indicies so can't tell the difference # between input order and index order. Here I reverse the # order so I can really test tie-breaking. for name in ("increasing-score", "decreasing-score", "increasing-index", "decreasing-index"): results = SearchResults(1) expected = [] for i in range(300): score = random_scores[i] results._add_hit(0, 400 - i, score) expected.append((400 - i, score)) results.reorder_all(name) expected.sort(key=_get_sort_key[name]) self.assertListEquals(results[0], expected, "error in %s (300)" % (name, ))
def test_random_values(self): # The underlying timsort does merge sorts of 64 element # blocks. Hence some of the code is not exercised unless the # input is at least 128 elements long. for size in (3, 5, 10, 20, 70, 100, 400): results = SearchResults(1) expected = [] for i in range(size): score = random_scores[i] expected.append((i, score)) results._add_hit(0, i, score) self.assertListEquals(results[0], expected) for name in ("increasing-score", "decreasing-score", "increasing-index", "decreasing-index"): results.reorder_all(name) expected.sort(key=_get_sort_key[name]) self.assertListEquals(results[0], expected, "error in %s:%d" % (name, size))
def _create(self, i, values): results = SearchResults(i) for value in values: results._add_hit(*value) return results
def test_bad_order(self): results = SearchResults(5) with self.assertRaisesRegexp(ValueError, "Unknown sort order"): results.reorder_all("xyzzy")
def test_bad_row_order(self): results = SearchResults(5) with self.assertRaisesRegexp(ValueError, "Unknown ordering"): results[0].reorder("xyzzy")
def test_index_out_of_range(self): results = SearchResults(5) with self.assertRaisesRegexp(IndexError, "row index is out of range"): results[5] with self.assertRaisesRegexp(IndexError, "row index is out of range"): results[98]
def test_illegal_negative_index(self): results = SearchResults(3) with self.assertRaisesRegexp(IndexError, "row index is out of range"): results[-4]
def test_size_0(self): results = SearchResults(5) results.reorder_all() self.assertListEquals(results[0], [])
def test_row(self): results = SearchResults(3) results._add_hit(0, 1, 0.1) results._add_hit(0, 2, 0.8) results._add_hit(0, 3, 0.6) results._add_hit(1, 12, 0.8) results._add_hit(1, 22, 0.1) results._add_hit(1, 32, 0.6) results._add_hit(2, 12, 0.6) results._add_hit(2, 32, 0.1) results._add_hit(2, 22, 0.8) results[0].reorder("reverse") self.assertListEquals(results[0], [(3, 0.6), (2, 0.8), (1, 0.1)]) self.assertListEquals(results[1], [(12, 0.8), (22, 0.1), (32, 0.6)]) self.assertListEquals(results[2], [(12, 0.6), (32, 0.1), (22, 0.8)]) results[-1].reorder("reverse") self.assertListEquals(results[0], [(3, 0.6), (2, 0.8), (1, 0.1)]) self.assertListEquals(results[1], [(12, 0.8), (22, 0.1), (32, 0.6)]) self.assertListEquals(results[2], [(22, 0.8), (32, 0.1), (12, 0.6)])
def test_size_1(self): results = SearchResults(5) results._add_hit(1, 5, 0.2) results.reorder_all() self.assertListEquals(results[1], [(5, 0.2)])
def test_len(self): for i in (0, 1, 4, 5): results = SearchResults(i) self.assertEquals(len(results), i)
def test_empty(self): results = SearchResults(2) results.reorder_all("reverse") self.assertEquals(len(results), 2) self.assertEquals(len(results[0]), 0) self.assertEquals(len(results[1]), 0)
def test_three(self): results = SearchResults(3) results._add_hit(0, 1, 0.1) results._add_hit(0, 2, 0.8) results._add_hit(0, 3, 0.6) results._add_hit(1, 12, 0.8) results._add_hit(1, 22, 0.1) results._add_hit(1, 32, 0.6) results._add_hit(2, 12, 0.6) results._add_hit(2, 22, 0.1) results._add_hit(2, 32, 0.8) results.reorder_all("move-closest-first") self.assertListEquals(results[0], [(2, 0.8), (1, 0.1), (3, 0.6)]) self.assertListEquals(results[1], [(12, 0.8), (22, 0.1), (32, 0.6)]) self.assertListEquals(results[2], [(32, 0.8), (22, 0.1), (12, 0.6)])
def test_empty(self): results = SearchResults(2) results.reorder_all("move-closest-first") self.assertEquals(len(results), 2) self.assertEquals(len(results[0]), 0) self.assertEquals(len(results[1]), 0)