Fix tests after latest changes

src/test/java/org/elasticsearch/index/analysis/GreeklishConverterTest.java

@@ -1,13 +1,20 @@
 package org.elasticsearch.index.analysis;
 
+import java.util.ArrayList;
 import java.util.List;
 
 import org.testng.annotations.BeforeMethod;
+import org.testng.annotations.BeforeClass;
 import org.testng.annotations.Test;
 import org.testng.Assert;
 
 public class GreeklishConverterTest {
-	private static final int MAX_EXPANSIONS = 20;
+
+	private static final int MAX_EXPANSIONS = 10;
+
+	private static final boolean GENERATE_GREEK_VARIANTS = true;
+
+	private GreeklishConverter converter;
 
 	/**
 	 * a sample of greek words to generate their greeklish
@@ -22,8 +29,10 @@ public class GreeklishConverterTest {
 	 */
 	private static final String[][] generatedGreeklishWords = {
 			{ "autokinhto", "aftokinhto", "avtokinhto", "aytokinhto",
-					"autokinito", "aftokinito", "avtokinito", "aytokinito" },
-			{"omprela", "obrela"}, {"kseskepastos", "xeskepastos"}
+					"autokinito", "aftokinito", "avtokinito", "aytokinito",
+					"autokinhtwn", "aftokinhta", "avtokinhta", "aytokinhtwn"},
+			{"omprela", "obrela", "ompreles", "obrelwn", "obreles", "omprelas"},
+			{"kseskepastos", "xeskepastos", "kseskepastou", "xeskepastwn", "kseskepastoi"}
 	};
 
 	/**
@@ -32,13 +41,29 @@ public class GreeklishConverterTest {
 	private static final String[] invalidWords = { "mobile", "αυριο64",
 			"καλάθι", "ΣΠιτι", "ομορφος" };
 
-	private GreeklishConverter converter;
-
 	private List<StringBuilder> greeklishWords;
 
-	@BeforeMethod
+	private List<String> convertedGreeklishStrings = new ArrayList<String>();
+
+	@BeforeClass
 	public void setUp() {
-		this.converter = new GreeklishConverter(MAX_EXPANSIONS, true);
+		this.converter = new GreeklishConverter(MAX_EXPANSIONS, GENERATE_GREEK_VARIANTS);
+	}
+
+	@BeforeMethod
+	public void emptyConvertedGreeklishStrings() {
+		convertedGreeklishStrings.clear();
+	}
+
+	@Test
+	public void testGreekTokenConversionsForInvalidWords() {
+		for (String invalidWord : invalidWords) {
+			greeklishWords = converter.convert(invalidWord.toCharArray(),
+					invalidWord.length());
+
+			Assert.assertNull(greeklishWords,
+					"It should not create any greeklish words");
+		}
 	}
 
 	@Test
@@ -47,39 +72,65 @@ public void testGreekTokenConversionForValidWords() {
 			greeklishWords = converter.convert(greekWords[i].toCharArray(),
 					greekWords[i].length());
 
+			populateConvertedStringsList();
+
 			Assert.assertFalse(greeklishWords.isEmpty(),
 					"Greeklish words should be generated");
-			Object[] greeklishWordsArray = greeklishWords.toArray();
-			for (int j = 0; j < greeklishWordsArray.length; j ++) {
-				Assert.assertEquals(greeklishWordsArray[j].toString(), generatedGreeklishWords[i][j]);				
+
+			for (String greeklishWord : generatedGreeklishWords[i]) {
+				Assert.assertTrue(convertedGreeklishStrings
+						.contains(greeklishWord),
+						"It should contain greeklish word: " + greeklishWord);
 			}
 		}
 	}
 
 	@Test
-	public void testGreekTokenConversionsForInvalidWords() {
-		for (String invalidWord : invalidWords) {
-			greeklishWords = converter.convert(invalidWord.toCharArray(),
-					invalidWord.length());
+	public void testMaxGreeklishExpansions() {
+		int newMaxExpansions = 2;
+		boolean generateGreekVariants = false;
+		converter = new GreeklishConverter(newMaxExpansions, generateGreekVariants);
 
-			Assert.assertNull(greeklishWords,
-					"It should not create any greeklish words");
+		greeklishWords = converter.convert(greekWords[0].toCharArray(),
+				greekWords[0].length());
+
+		populateConvertedStringsList();
+
+		Assert.assertEquals(greeklishWords.size(), newMaxExpansions,
+				"The generated words should be limited by the maxExpansions paramater");
+
+		for (int i = 0; i < newMaxExpansions; i ++) {
+			Assert.assertTrue(convertedGreeklishStrings.contains(generatedGreeklishWords[0][i]),
+					"It should contain greeklish word: " + generatedGreeklishWords[0][i]);
+		}
+
+		for (int j = newMaxExpansions; j < generatedGreeklishWords[0].length; j++) {
+			Assert.assertFalse(convertedGreeklishStrings.contains(generatedGreeklishWords[0][j]),
+					"It should not contain greeklish word: " + generatedGreeklishWords[0][j]);
 		}
 	}
 
 	@Test
-	public void testMaxGreeklishWordGenerations() {
-		int newMaxExpansions = 2;
-		converter = new GreeklishConverter(newMaxExpansions, true);
+	public void testGreekVariantsGeneration() {
+		int newMaxExpansions = 1;
+		boolean generateGreekVariants = false;
+		converter = new GreeklishConverter(newMaxExpansions, generateGreekVariants);
 
 		greeklishWords = converter.convert(greekWords[0].toCharArray(),
 				greekWords[0].length());
-		Assert.assertEquals(greeklishWords.size(), newMaxExpansions,
-				"The generated words should be limited by the maxExpansions paramater");
 
-		Object[] greeklishWordsArray = greeklishWords.toArray();
-		for (int i = 0; i < greeklishWordsArray.length; i ++) {
-			Assert.assertEquals(greeklishWordsArray[i].toString(), generatedGreeklishWords[0][i]);				
+		populateConvertedStringsList();
+
+		Assert.assertTrue(convertedGreeklishStrings.contains(generatedGreeklishWords[0][0]),
+				"It should contain greeklish word: " + generatedGreeklishWords[0][0]);
+
+		Assert.assertFalse(convertedGreeklishStrings.contains(generatedGreeklishWords[0][9]),
+				"It should not contain greeklish word: " + generatedGreeklishWords[0][9]);
+	}
+
+	private final void populateConvertedStringsList() {
+		for (StringBuilder word : greeklishWords) {
+			convertedGreeklishStrings.add(word.toString());
 		}
 	}
-}
+}

src/test/java/org/elasticsearch/index/analysis/GreeklishGeneratorTest.java

@@ -0,0 +1,90 @@
+package org.elasticsearch.index.analysis;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.testng.annotations.BeforeMethod;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+import org.testng.Assert;
+
+public class GreeklishGeneratorTest {
+
+	private static final int MAX_EXPANSIONS = 10;
+
+	/**
+	 * a sample of greek words to generate their greeklish
+	 * counterparts.
+	 */
+	private static final String[] greekWords = { "αυτοκινητο", "ομπρελα",
+			"ξεσκεπαστοσ", };
+
+	/**
+	 * the greeklish counterparts that should be generated from the
+	 * greek words.
+	 */
+	private static final String[] generatedGreeklishWords = {
+			"autokinhto", "aftokinhto", "avtokinhto", "aytokinhto",
+			"autokinito", "aftokinito", "avtokinito", "aytokinito",
+			"omprela", "obrela", "kseskepastos", "xeskepastos"
+	};
+
+	private GreeklishGenerator generator;
+
+	private List<String> inputGreekList = new ArrayList<String>();
+
+	private List<StringBuilder> greeklishWords;
+
+	private List<String> convertedGreeklishStrings = new ArrayList<String>();
+
+	@BeforeClass
+	public void populateInputGreekList() {
+		this.generator = new GreeklishGenerator(MAX_EXPANSIONS);
+
+		for (String word : greekWords) {
+			inputGreekList.add(word);
+		}
+	}
+
+	@BeforeMethod
+	public void setUp() {
+		convertedGreeklishStrings.clear();
+	}
+
+	@Test
+	public void testGreekTokenConversionForValidWords() {
+		for (int i = 0; i < greekWords.length; i++) {
+			greeklishWords = generator.generateGreeklishWords(inputGreekList);
+
+			populateConvertedStringsList();
+
+			Assert.assertFalse(greeklishWords.isEmpty(),
+					"Greeklish words should be generated");
+			for (String greeklishWord : generatedGreeklishWords) {
+				Assert.assertTrue(
+						convertedGreeklishStrings.contains(greeklishWord),
+						"It should contain the greeklish word: "
+								+ greeklishWord);
+			}
+		}
+	}
+
+	@Test
+	public void testMaxGreeklishWordGenerations() {
+		int newMaxExpansions = 2;
+		generator = new GreeklishGenerator(newMaxExpansions);
+
+		greeklishWords = generator.generateGreeklishWords(inputGreekList);
+
+		Assert.assertEquals(greeklishWords.size(), newMaxExpansions
+				* inputGreekList.size(),
+				"The generated words should be limited by the maxExpansions paramater");
+
+	}
+
+	private final void populateConvertedStringsList() {
+		for (StringBuilder word : greeklishWords) {
+			convertedGreeklishStrings.add(word.toString());
+		}
+	}
+}

src/test/java/org/elasticsearch/index/analysis/GreeklishReverseStemmerTest.java

@@ -0,0 +1,78 @@
+package org.elasticsearch.index.analysis;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.testng.annotations.BeforeMethod;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+import org.testng.Assert;
+
+public class GreeklishReverseStemmerTest {
+
+	/**
+	 * Some greek words whose variations we want to produce.
+	 */
+	private static final String[] greekWords = {
+		"κουρεματοσ", "ενδυματα", "γραφειου", "πεδιου",
+		"γραναζι", "ποδηλατα", "καλωδιων"
+	};
+
+	/**
+	 * Words that should not match to any rule.
+	 */
+	private static final String[] nonMatchingWords = {
+		"σουτιεν", "κολλαν", "αμπαλαζ", "μακιγιαζ"
+	};
+
+	/**
+	 * The output we expect for each of the above words.
+	 */
+	private static final String[][] greekVariants = {
+		{"κουρεμα", "κουρεματων", "κουρεματα"},
+		{"ενδυμα", "ενδυματων", "ενδυματα", "ενδυματοσ"},
+		{"γραφειο", "γραφεια", "γραφειων"},
+		{"πεδια", "πεδιο", "πεδιων"},
+		{"γραναζια", "γραναζιου", "γραναζιων"},
+		{"ποδηλατο", "ποδηλατου", "ποδηλατα", "ποδηλατων"},
+		{"καλωδιου", "καλωδια", "καλωδιο"}
+	};
+
+	private GreekReverseStemmer reverseStemmer;
+
+	private List<String> generatedGreekVariants;
+
+	@BeforeClass
+	public void setUp() {
+		this.reverseStemmer = new GreekReverseStemmer();
+		this.generatedGreekVariants = new ArrayList<String>();
+	}
+
+	@BeforeMethod
+	public void clearThePreviousResults() {
+		generatedGreekVariants.clear();
+	}
+
+	@Test
+	public void testGenerationOfGreekVariants() {
+		for (int i = 0; i < greekWords.length; i++) {
+			generatedGreekVariants = reverseStemmer.generateGreekVariants(greekWords[i]);
+
+			Assert.assertTrue(generatedGreekVariants.size() > 1, "The reverse stemmer should produce results");
+
+			for (String greekVariant : greekVariants[i]) {
+				Assert.assertTrue(generatedGreekVariants.contains(greekVariant),
+						"It should contain the greek variant: " + greekVariant);
+			}
+		}
+	}
+
+	@Test
+	public void testNonMatchingWords() {
+		for (String nonMatchingWord : nonMatchingWords) {
+			generatedGreekVariants = reverseStemmer.generateGreekVariants(nonMatchingWord);
+
+			Assert.assertTrue(generatedGreekVariants.size() == 1, "The reverse stemmer should not produce more results");
+		}
+	}
+}