## org.apache.lucene.search
Class CheckHits

    java.lang.Object
      org.apache.lucene.search.CheckHits

    public class CheckHits

extends Object

Utility class for asserting expected hits in tests.

Nested Class Summary
`static class` `CheckHits.ExplanationAsserter` Asserts that the score explanation for every document matching a query corresponds with the true score.
`static class` `CheckHits.ExplanationAssertingSearcher` an IndexSearcher that implicitly checks hte explanation of every match whenever it executes a search.
`static class` `CheckHits.SetCollector` Just collects document ids into a set.

Field Summary
`static float` `EXPLAIN_SCORE_TOLERANCE_DELTA` Some explains methods calculate their values though a slightly different order of operations from the actual scoring method ...

Constructor Summary
`CheckHits()`

Method Summary
`static void` `checkDocIds(String mes, int[] results, ScoreDoc[] hits)` Tests that a Hits has an expected order of documents
`static void` `checkEqual(Query query, ScoreDoc[] hits1, ScoreDoc[] hits2)`
`static void` `checkExplanations(Query query, String defaultFieldName, Searcher searcher)` Asserts that the explanation value for every document matching a query corresponds with the true score.
`static void` `checkExplanations(Query query, String defaultFieldName, Searcher searcher, boolean deep)` Asserts that the explanation value for every document matching a query corresponds with the true score.
`static void` `checkHitCollector(Random random, Query query, String defaultFieldName, Searcher searcher, int[] results)` Tests that a query matches the an expected set of documents using a HitCollector.
`static void` `checkHits(Random random, Query query, String defaultFieldName, Searcher searcher, int[] results)` Tests that a query matches the an expected set of documents using Hits.
`static void` `checkHitsQuery(Query query, ScoreDoc[] hits1, ScoreDoc[] hits2, int[] results)` Tests that two queries have an expected order of documents, and that the two queries have the same score values.
`static void` `checkNoMatchExplanations(Query q, String defaultFieldName, Searcher searcher, int[] results)` Tests that all documents up to maxDoc which are *not* in the expected result set, have an explanation which indicates that the document does not match
`static String` `hits2str(ScoreDoc[] hits1, ScoreDoc[] hits2, int start, int end)`
`static String` `topdocsString(TopDocs docs, int start, int end)`
`static void` `verifyExplanation(String q, int doc, float score, boolean deep, Explanation expl)` Assert that an explanation has the expected score, and optionally that its sub-details max/sum/factor match to that score.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### EXPLAIN_SCORE_TOLERANCE_DELTA

    public static float EXPLAIN_SCORE_TOLERANCE_DELTA

  Some explains methods calculate their values though a slightly different order of operations from the actual scoring method ... this allows for a small amount of variation

Constructor Detail

### CheckHits

    public CheckHits()

Method Detail

### checkNoMatchExplanations

    public static void checkNoMatchExplanations(Query q,
                                                String defaultFieldName,
                                                Searcher searcher,
                                                int[] results)
                                         throws IOException

  Tests that all documents up to maxDoc which are *not* in the expected result set, have an explanation which indicates that the document does not match

  Throws:
    `IOException`

### checkHitCollector

    public static void checkHitCollector(Random random,
                                         Query query,
                                         String defaultFieldName,
                                         Searcher searcher,
                                         int[] results)
                                  throws IOException

  Tests that a query matches the an expected set of documents using a HitCollector.

  Note that when using the HitCollector API, documents will be collected if they "match" regardless of what their score is.

  Parameters:
    `query` - the query to test
    `searcher` - the searcher to test the query against
    `defaultFieldName` - used for displaying the query in assertion messages
    `results` - a list of documentIds that must match the query
  Throws:
    `IOException`
  See Also:
    `checkHits(java.util.Random, org.apache.lucene.search.Query, java.lang.String, org.apache.lucene.search.Searcher, int[])`

### checkHits

    public static void checkHits(Random random,
                                 Query query,
                                 String defaultFieldName,
                                 Searcher searcher,
                                 int[] results)
                          throws IOException

  Tests that a query matches the an expected set of documents using Hits.

  Note that when using the Hits API, documents will only be returned if they have a positive normalized score.

  Parameters:
    `query` - the query to test
    `searcher` - the searcher to test the query against
    `defaultFieldName` - used for displaing the query in assertion messages
    `results` - a list of documentIds that must match the query
  Throws:
    `IOException`
  See Also:
    `checkHitCollector(java.util.Random, org.apache.lucene.search.Query, java.lang.String, org.apache.lucene.search.Searcher, int[])`

### checkDocIds

    public static void checkDocIds(String mes,
                                   int[] results,
                                   ScoreDoc[] hits)
                            throws IOException

  Tests that a Hits has an expected order of documents

  Throws:
    `IOException`

### checkHitsQuery

    public static void checkHitsQuery(Query query,
                                      ScoreDoc[] hits1,
                                      ScoreDoc[] hits2,
                                      int[] results)
                               throws IOException

  Tests that two queries have an expected order of documents, and that the two queries have the same score values.

  Throws:
    `IOException`

### checkEqual

    public static void checkEqual(Query query,
                                  ScoreDoc[] hits1,
                                  ScoreDoc[] hits2)
                           throws IOException

  Throws:
    `IOException`

### hits2str

    public static String hits2str(ScoreDoc[] hits1,
                                  ScoreDoc[] hits2,
                                  int start,
                                  int end)
                           throws IOException

  Throws:
    `IOException`

### topdocsString

    public static String topdocsString(TopDocs docs,
                                       int start,
                                       int end)

### checkExplanations

    public static void checkExplanations(Query query,
                                         String defaultFieldName,
                                         Searcher searcher)
                                  throws IOException

  Asserts that the explanation value for every document matching a query corresponds with the true score.

  Parameters:
    `query` - the query to test
    `searcher` - the searcher to test the query against
    `defaultFieldName` - used for displaing the query in assertion messages
  Throws:
    `IOException`
  See Also:
    `CheckHits.ExplanationAsserter`, `for a "deep" testing of the explanation details.`

### checkExplanations

    public static void checkExplanations(Query query,
                                         String defaultFieldName,
                                         Searcher searcher,
                                         boolean deep)
                                  throws IOException

  Asserts that the explanation value for every document matching a query corresponds with the true score. Optionally does "deep" testing of the explanation details.

  Parameters:
    `query` - the query to test
    `searcher` - the searcher to test the query against
    `defaultFieldName` - used for displaing the query in assertion messages
    `deep` - indicates whether a deep comparison of sub-Explanation details should be executed
  Throws:
    `IOException`
  See Also:
    `CheckHits.ExplanationAsserter`

### verifyExplanation

    public static void verifyExplanation(String q,
                                         int doc,
                                         float score,
                                         boolean deep,
                                         Explanation expl)

  Assert that an explanation has the expected score, and optionally that its sub-details max/sum/factor match to that score.

  Parameters:
    `q` - String representation of the query for assertion messages
    `doc` - Document ID for assertion messages
    `score` - Real score value of doc with query q
    `deep` - indicates whether a deep comparison of sub-Explanation details should be executed
    `expl` - The Explanation to match against score