Add additional tests to improve coverage

Author: ahornace

suggester/pom.xml

@@ -64,6 +64,14 @@
                 </exclusion>
             </exclusions>
         </dependency>
+
+        <!-- to get rid of SL4J warning messages -->
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-nop</artifactId>
+            <version>1.7.25</version>
+        </dependency>
+
     </dependencies>
 
     <build>

suggester/src/main/java/org/opengrok/suggest/LookupResultItem.java

@@ -24,6 +24,7 @@
 
 import java.util.Collections;
 import java.util.HashSet;
+import java.util.Objects;
 import java.util.Set;
 
 /**
@@ -76,6 +77,25 @@ public int compareTo(final LookupResultItem other) {
         return Long.compare(score, other.score);
     }
 
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        LookupResultItem that = (LookupResultItem) o;
+        return score == that.score &&
+                Objects.equals(phrase, that.phrase) &&
+                Objects.equals(projects, that.projects);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(phrase, projects, score);
+    }
+
     @Override
     public String toString() {
         return "LookupResultItem{phrase='" + phrase + "', projects=" + projects + ", score=" + score + '}';

suggester/src/test/java/org/opengrok/suggest/FieldWFSTCollectionTest.java

@@ -41,11 +41,15 @@
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.util.Arrays;
 import java.util.Collections;
+import java.util.HashSet;
 import java.util.List;
 import java.util.stream.Collectors;
 
+import static junit.framework.Assert.assertTrue;
 import static junit.framework.TestCase.assertEquals;
+import static junit.framework.TestCase.assertFalse;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.collection.IsIterableContainingInAnyOrder.containsInAnyOrder;
 
@@ -67,8 +71,12 @@ public void setUp() throws IOException {
 
     @After
     public void tearDown() throws IOException {
-        f.close();
-        FileUtils.deleteDirectory(tempDir.toFile());
+        if (f != null) {
+            f.close();
+        }
+        if (tempDir.toFile().exists()) {
+            FileUtils.deleteDirectory(tempDir.toFile());
+        }
     }
 
     @Test
@@ -250,4 +258,34 @@ public void getSearchCountMapNullTest() throws IOException {
         f.getSearchCounts(null);
     }
 
+    @Test
+    public void testRemove() throws IOException {
+        Directory dir = new RAMDirectory();
+        Path tempDir = Files.createTempDirectory("test");
+
+        try (IndexWriter iw = new IndexWriter(dir, new IndexWriterConfig())) {
+            Document doc = new Document();
+            doc.add(new TextField("test", "text", Field.Store.NO));
+
+            iw.addDocument(doc);
+        }
+
+        FieldWFSTCollection f = new FieldWFSTCollection(dir, tempDir, false, Collections.singleton("test"));
+        f.init();
+        f.remove();
+
+        assertFalse(tempDir.toFile().exists());
+    }
+
+    @Test
+    public void testUnknownFieldIgnored() throws IOException {
+        addText(FIELD, "term");
+        f = new FieldWFSTCollection(dir, tempDir, false, new HashSet<>(Arrays.asList(FIELD, "unknown")));
+        f.init();
+
+        List<Lookup.LookupResult> res = f.lookup("unknown", "a", 10);
+
+        assertTrue(res.isEmpty());
+    }
+
 }

suggester/src/test/java/org/opengrok/suggest/SuggesterSearcherTest.java

@@ -33,12 +33,14 @@
 import org.apache.lucene.search.TermQuery;
 import org.apache.lucene.store.Directory;
 import org.apache.lucene.store.RAMDirectory;
+import org.apache.lucene.util.BytesRef;
 import org.junit.AfterClass;
 import org.junit.BeforeClass;
 import org.junit.Test;
 import org.opengrok.suggest.query.SuggesterFuzzyQuery;
 import org.opengrok.suggest.query.SuggesterPhraseQuery;
 import org.opengrok.suggest.query.SuggesterPrefixQuery;
+import org.opengrok.suggest.query.SuggesterRangeQuery;
 import org.opengrok.suggest.query.SuggesterRegexpQuery;
 import org.opengrok.suggest.query.SuggesterWildcardQuery;
 
@@ -133,4 +135,28 @@ public void suggesterPhraseQueryTest() {
         assertThat(tokens, contains("opengrok2"));
     }
 
+    @Test
+    public void testRangeQueryUpper() {
+        SuggesterRangeQuery q = new SuggesterRangeQuery("test", new BytesRef("opengrok"),
+                new BytesRef("t"), true, true, SuggesterRangeQuery.SuggestPosition.UPPER);
+
+        List<LookupResultItem> suggestions = searcher.suggest(null, "test", q, k -> 0);
+
+        List<String> tokens = suggestions.stream().map(LookupResultItem::getPhrase).collect(Collectors.toList());
+
+        assertThat(tokens, contains("test"));
+    }
+
+    @Test
+    public void testRangeQueryLower() {
+        SuggesterRangeQuery q = new SuggesterRangeQuery("test", new BytesRef("o"),
+                new BytesRef("test"), true, true, SuggesterRangeQuery.SuggestPosition.LOWER);
+
+        List<LookupResultItem> suggestions = searcher.suggest(null, "test", q, k -> 0);
+
+        List<String> tokens = suggestions.stream().map(LookupResultItem::getPhrase).collect(Collectors.toList());
+
+        assertThat(tokens, contains("opengrok", "opengrok2"));
+    }
+
 }

suggester/src/test/java/org/opengrok/suggest/SuggesterUtilsTest.java

@@ -29,11 +29,15 @@
 import org.apache.lucene.search.Query;
 import org.apache.lucene.search.TermQuery;
 import org.junit.Test;
+import org.opengrok.suggest.query.SuggesterPrefixQuery;
 
+import java.util.Arrays;
 import java.util.List;
 
 import static org.hamcrest.collection.IsIterableContainingInAnyOrder.containsInAnyOrder;
+import static org.hamcrest.collection.IsIterableContainingInOrder.contains;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertThat;
 
 public class SuggesterUtilsTest {
@@ -80,4 +84,27 @@ public void intoTermExceptPhraseQueryTest() {
         assertEquals(t, terms.get(0));
     }
 
+    @Test
+    public void testIsComplexQuery() {
+        assertFalse(SuggesterUtils.isComplexQuery(null, new SuggesterPrefixQuery(new Term("test", "t"))));
+    }
+
+    @Test
+    public void testCombineResults() {
+        LookupResultItem item1 = new LookupResultItem("test", "proj1", 10);
+        LookupResultItem item2 = new LookupResultItem("test", "proj2", 10);
+        LookupResultItem item3 = new LookupResultItem("test", "proj3", 10);
+        LookupResultItem item4 = new LookupResultItem("test2", "proj3", 10);
+        LookupResultItem item5 = new LookupResultItem("test3", "proj1", 15);
+
+        List<LookupResultItem> res = SuggesterUtils.combineResults(
+                Arrays.asList(item1, item2, item3, item4, item5), 2);
+
+        LookupResultItem combined = new LookupResultItem("test", "proj1", 10);
+        combined.combine(new LookupResultItem("test", "proj2", 10));
+        combined.combine(new LookupResultItem("test", "proj3", 10));
+
+        assertThat(res, contains(combined, item5));
+    }
+
 }