diff --git lucene/src/test/org/apache/lucene/search/similarities/TestEasySimilarity.java lucene/src/test/org/apache/lucene/search/similarities/TestEasySimilarity.java new file mode 100644 index 0000000..b3af826 --- /dev/null +++ lucene/src/test/org/apache/lucene/search/similarities/TestEasySimilarity.java @@ -0,0 +1,172 @@ +package org.apache.lucene.search.similarities; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; + +import org.apache.lucene.document.Document; +import org.apache.lucene.document.Field; +import org.apache.lucene.index.IndexReader; +import org.apache.lucene.index.RandomIndexWriter; +import org.apache.lucene.index.Term; +import org.apache.lucene.search.IndexSearcher; +import org.apache.lucene.search.Query; +import org.apache.lucene.search.SimilarityProvider; +import org.apache.lucene.search.TermQuery; +import org.apache.lucene.search.TopDocs; +import org.apache.lucene.store.Directory; +import org.apache.lucene.util.LuceneTestCase; + +/** + * Tests the {@link EasySimilarity}-based Similarities. + */ +public class TestEasySimilarity extends LuceneTestCase { + private static String FIELD_BODY = "body"; + private static String FIELD_ID = "id"; + /** The DFR basic models to test. */ + private static BasicModel[] BASIC_MODELS; + /** The DFR aftereffects to test. */ + private static AfterEffect[] AFTER_EFFECTS; + /** The DFR normalizations to test. */ + private static Normalization[] NORMALIZATIONS; + /** The distributions for IB. */ + private static Distribution[] DISTRIBUTIONS; + /** Lambdas for IB. */ + private static Lambda[] LAMBDAS; + + static { + BASIC_MODELS = new BasicModel[] { + new BasicModelBE(), new BasicModelD(), new BasicModelG(), + new BasicModelIF(), new BasicModelIn(), new BasicModelIne(), + new BasicModelP() + }; + AFTER_EFFECTS = new AfterEffect[] { + new AfterEffectB(), new AfterEffectL(), new AfterEffect.NoAfterEffect() + }; + NORMALIZATIONS = new Normalization[] { + new NormalizationH1(), new NormalizationH2(), + new Normalization.NoNormalization() + }; + DISTRIBUTIONS = new Distribution[] { + new DistributionLL(), new DistributionSPL() + }; + LAMBDAS = new Lambda[] { + new LambdaDF(), new LambdaTTF() + }; + } + + private IndexSearcher searcher; + private Directory dir; + private IndexReader reader; + private List sims; + + String[] docs = new String[] { + "Tiger, tiger burning bright In the forest of the night What immortal hand or eye Could frame thy fearful symmetry ?", + "In what distant depths or skies Burnt the fire of thine eyes ? On what wings dare he aspire ? What the hands the seize the fire ?", + "And what shoulder and what art Could twist the sinews of thy heart ? And when thy heart began to beat What dread hand ? And what dread feet ?", + "What the hammer? What the chain ? In what furnace was thy brain ? What the anvil ? And what dread grasp Dare its deadly terrors clasp ?", + "And when the stars threw down their spears And water'd heaven with their tear Did he smile his work to see ? Did he, who made the lamb, made thee ?", + "Tiger, tiger burning bright In the forest of the night What immortal hand or eye Dare frame thy fearful symmetry ?", + "Cruelty has a human heart And jealousy a human face Terror the human form divine And Secrecy the human dress .", + "The human dress is forg'd iron The human form a fiery forge The human face a furnace seal'd The human heart its fiery gorge ." + }; + + @Override + public void setUp() throws Exception { + super.setUp(); + + dir = newDirectory(); + RandomIndexWriter writer = new RandomIndexWriter(random, dir); + + for (int i = 0; i < docs.length; i++) { + Document d = new Document(); + d.add(newField(FIELD_ID, Integer.toString(i), Field.Store.YES, Field.Index.NO)); + d.add(newField(FIELD_BODY, docs[i], Field.Index.ANALYZED)); + writer.addDocument(d); + } + + reader = writer.getReader(); + searcher = newSearcher(reader); + writer.close(); + + sims = new ArrayList(); + for (BasicModel basicModel : BASIC_MODELS) { + for (AfterEffect afterEffect : AFTER_EFFECTS) { + for (Normalization normalization : NORMALIZATIONS) { + sims.add(new DFRSimilarity(basicModel, afterEffect, normalization)); + } + } + } + for (Distribution distribution : DISTRIBUTIONS) { + for (Lambda lambda : LAMBDAS) { + for (Normalization normalization : NORMALIZATIONS) { + sims.add(new IBSimilarity(distribution, lambda, normalization)); + } + } + } + sims.add(new LMDirichletSimilarity()); + sims.add(new LMJelinekMercerSimilarity(0.1f)); + sims.add(new LMJelinekMercerSimilarity(0.7f)); + } + + /** + * Tests whether all similarities return three documents for the query word + * "heart". + */ + public void testHeartList() throws IOException { + Query q = new TermQuery(new Term(FIELD_BODY, "heart")); + + for (EasySimilarity sim : sims) { + searcher.setSimilarityProvider(new EasySimilarityProvider(sim)); + TopDocs topDocs = searcher.search(q, 1000); + assertEquals(3, topDocs.totalHits); + } + } + + /** Test whether all similarities return document 3 before documents 7 and 8. */ + public void testHeartRanking() throws IOException { + Query q = new TermQuery(new Term(FIELD_BODY, "heart")); + + for (EasySimilarity sim : sims) { + searcher.setSimilarityProvider(new EasySimilarityProvider(sim)); + TopDocs topDocs = searcher.search(q, 1000); + assertTrue(topDocs.scoreDocs[0].doc == 2); + } + } + + @Override + public void tearDown() throws Exception { + searcher.close(); + reader.close(); + dir.close(); + super.tearDown(); + } + + /** + * A simple Similarity provider that returns in {@code get(String field)} the + * object passed to its constructor. + */ + // nocommit a real EasySimilarityProvider with coord and queryNorm implemented? + public static class EasySimilarityProvider implements SimilarityProvider { + private EasySimilarity sim; + + public EasySimilarityProvider(EasySimilarity sim) { + this.sim = sim; + } + + @Override + public float coord(int overlap, int maxOverlap) { + return 1f; + } + + @Override + public float queryNorm(float sumOfSquaredWeights) { + return 1f; + } + + @Override + public EasySimilarity get(String field) { + return sim; + } + } +}