## 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 ...
`static float` `EXPLAIN_SCORE_TOLERANCE_MINIMUM` In general we use a relative epsilon, but some tests do crazy things like boost documents with 0, creating tiny tiny scores where the relative difference is large but the absolute difference is tiny.

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, IndexSearcher searcher)` Asserts that the explanation value for every document matching a query corresponds with the true score.
`static void` `checkExplanations(Query query, String defaultFieldName, IndexSearcher 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, IndexSearcher 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, IndexSearcher 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, IndexSearcher 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 float` `explainToleranceDelta(float f1, float f2)` returns a reasonable epsilon for comparing two floats, where minor differences are acceptable such as score vs.
`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 relative variation

### EXPLAIN_SCORE_TOLERANCE_MINIMUM

    public static float EXPLAIN_SCORE_TOLERANCE_MINIMUM

  In general we use a relative epsilon, but some tests do crazy things like boost documents with 0, creating tiny tiny scores where the relative difference is large but the absolute difference is tiny. we ensure the the epsilon is always at least this big.

Constructor Detail

### CheckHits

    public CheckHits()

Method Detail

### checkNoMatchExplanations

    public static void checkNoMatchExplanations(Query q,
                                                String defaultFieldName,
                                                IndexSearcher 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,
                                         IndexSearcher 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.IndexSearcher, int[])`

### checkHits

    public static void checkHits(Random random,
                                 Query query,
                                 String defaultFieldName,
                                 IndexSearcher 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.IndexSearcher, int[])`

### checkDocIds

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

  Tests that a Hits has an expected order of documents

### checkHitsQuery

    public 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.

### checkEqual

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

### hits2str

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

### topdocsString

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

### checkExplanations

    public static void checkExplanations(Query query,
                                         String defaultFieldName,
                                         IndexSearcher 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,
                                         IndexSearcher 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`

### explainToleranceDelta

    public static float explainToleranceDelta(float f1,
                                              float f2)

  returns a reasonable epsilon for comparing two floats, where minor differences are acceptable such as score vs. explain

### 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

Copyright © 2000-2013 Apache Software Foundation. All Rights Reserved.