Esempio n. 1
0
 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)])
Esempio n. 2
0
    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)])
Esempio n. 3
0
 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)])
Esempio n. 4
0
 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
Esempio n. 5
0
 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,))
Esempio n. 9
0
 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
Esempio n. 10
0
 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
Esempio n. 11
0
 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])
Esempio n. 12
0
    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))
Esempio n. 14
0
    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 _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
Esempio n. 17
0
    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)
Esempio n. 18
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)])
Esempio n. 19
0
 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)])
Esempio n. 20
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)])
Esempio n. 21
0
 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], [])
Esempio n. 22
0
 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))
Esempio n. 23
0
 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])
Esempio n. 24
0
 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, ))
Esempio n. 25
0
 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))
Esempio n. 26
0
 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")
Esempio n. 28
0
 def test_bad_row_order(self):
     results = SearchResults(5)
     with self.assertRaisesRegexp(ValueError, "Unknown ordering"):
         results[0].reorder("xyzzy")
Esempio n. 29
0
 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]
Esempio n. 30
0
 def test_illegal_negative_index(self):
     results = SearchResults(3)
     with self.assertRaisesRegexp(IndexError, "row index is out of range"):
         results[-4]
Esempio n. 31
0
 def test_size_0(self):
     results = SearchResults(5)
     results.reorder_all()
     self.assertListEquals(results[0], [])
Esempio n. 32
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)])
Esempio n. 33
0
 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)])
Esempio n. 34
0
 def test_len(self):
     for i in (0, 1, 4, 5):
         results = SearchResults(i)
         self.assertEquals(len(results), i)
Esempio n. 35
0
 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)
Esempio n. 36
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 _create(self, i, values):
     results = SearchResults(i)
     for value in values:
         results._add_hit(*value)
     return results
Esempio n. 38
0
 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)