summaryrefslogtreecommitdiff
path: root/src/core/JUTests
diff options
context:
space:
mode:
Diffstat (limited to 'src/core/JUTests')
-rw-r--r--src/core/JUTests/data/MVDataEntryTest.java93
-rw-r--r--src/core/JUTests/data/io/filters/MVDataCombinerTest.java148
2 files changed, 241 insertions, 0 deletions
diff --git a/src/core/JUTests/data/MVDataEntryTest.java b/src/core/JUTests/data/MVDataEntryTest.java
new file mode 100644
index 0000000..19ccb46
--- /dev/null
+++ b/src/core/JUTests/data/MVDataEntryTest.java
@@ -0,0 +1,93 @@
+package data;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+import com.google.common.collect.HashMultimap;
+
+public class MVDataEntryTest {
+
+ @Test
+ public void testMVDataEntryStringIntInt() {
+ String expected = "{key=line1, attrValPairs={k4=[v4], k1=[v1b, v1a, v1c], k2=[v1c]}}";
+
+ MVDataEntry e1 = new MVDataEntry("line1", 1, 1);
+ HashMultimap<String, String> e1v = e1.getAttrValPairs();
+ e1v.put("k1", "v1a");
+ e1v.put("k1", "v1b");
+ e1v.put("k1", "v1b"); // Twice, should disappear silently
+ e1v.put("k1", "v1c");
+ e1v.put("k2", "v1c");
+ e1v.put("k4", "v4");
+
+ assertEquals(expected, e1.toString());
+
+ }
+
+ @Test
+ public void testMerge() {
+ // Test data
+ MVDataEntry e1 = new MVDataEntry("10");
+ HashMultimap<String, String> e1v = e1.getAttrValPairs();
+ e1v.put("k1", "v1a");
+ e1v.put("k1", "v1b");
+ e1v.put("k1", "v1c");
+ e1v.put("k2", "v2");
+ e1v.put("k4", "v4");
+
+ MVDataEntry e2 = new MVDataEntry("2");
+ HashMultimap<String, String> e2v = e2.getAttrValPairs();
+ e2v.put("k2", "v2");
+ e2v.put("k1", "v1b");
+ e2v.put("k3", "v3");
+
+ MVDataEntry r1 = new MVDataEntry(e1);
+ r1.mergeValues(true, e2);
+ assertNotSame(r1, e1);
+ String expected1 = "{key=10, attrValPairs={k3=[v3], k4=[v4], k1=[v1b, v1a, v1c], k2=[v2]}}";
+ assertEquals(expected1, r1.toString());
+
+ MVDataEntry r2 = new MVDataEntry(e2);
+ r2.mergeValues(true, e1);
+ assertNotSame(r2, e2);
+ String expected2 = "{key=2, attrValPairs={k3=[v3], k4=[v4], k1=[v1b, v1a, v1c], k2=[v2]}}";
+ assertEquals(expected2, r2.toString());
+
+ MVDataEntry r3 = new MVDataEntry(e1);
+ r3.mergeValues(false, e2);
+ assertNotSame(r3, e1);
+ String expected3 = "{key=10, attrValPairs={k3=[v3], k4=[v4], k1=[v1b], k2=[v2]}}";
+ //System.out.println(expected3);
+ //System.out.println(r3.toString());
+ assertEquals(expected3, r3.toString());
+
+ MVDataEntry r4 = new MVDataEntry(e2);
+ r4.mergeValues(false, e1);
+ assertNotSame(r4, e1);
+ String expected4 = "{key=2, attrValPairs={k3=[v3], k4=[v4], k1=[v1b, v1a, v1c], k2=[v2]}}";
+ assertEquals(expected4, r4.toString());
+
+ assertTrue(!r2.equals(r3));
+ assertEquals(r2,r4);
+ }
+
+ @Test
+ public void testSplitAndPut() {
+ MVDataEntry r1 = new MVDataEntry("10");
+ r1.splitAndPut("k1", "v1a;v1b;v1c", ";");
+ r1.put("k2", "v2", null); // splitAndPut does not support null regex anymore, use put()
+ r1.splitAndPut("k4", "v4", "^$");
+
+ MVDataEntry expected1 = new MVDataEntry("10");
+ HashMultimap<String, String> expected1v = expected1.getAttrValPairs();
+ expected1v.put("k1", "v1a");
+ expected1v.put("k1", "v1b");
+ expected1v.put("k1", "v1c");
+ expected1v.put("k2", "v2");
+ expected1v.put("k4", "v4");
+
+ assertEquals(r1,expected1);
+ }
+
+}
diff --git a/src/core/JUTests/data/io/filters/MVDataCombinerTest.java b/src/core/JUTests/data/io/filters/MVDataCombinerTest.java
new file mode 100644
index 0000000..5d32dd8
--- /dev/null
+++ b/src/core/JUTests/data/io/filters/MVDataCombinerTest.java
@@ -0,0 +1,148 @@
+package data.io.filters;
+
+import static org.junit.Assert.*;
+
+import java.util.Iterator;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+import data.MVDataEntry;
+import data.filters.MVDataCombiner;
+import data.filters.MVDataCombiner.MVDataCombineMode;
+import data.io.MVDataReader;
+import data.io.stub.StubDataReader;
+
+public class MVDataCombinerTest {
+
+ @Rule
+ public ExpectedException exception = ExpectedException.none();
+
+ @Test
+ public void testOutOfOrderCase() {
+ // Test Data
+ MVDataEntry e10 = new MVDataEntry("line2");
+ e10.getAttrValPairs().put("merge", "e10");
+ MVDataEntry e11 = new MVDataEntry("line1");
+ e11.getAttrValPairs().put("merge", "e11");
+
+ MVDataEntry e21 = new MVDataEntry("line2");
+ e21.getAttrValPairs().put("merge", "e21");
+
+ MVDataEntry[][] fakeEntries = new MVDataEntry[][] {
+ new MVDataEntry[] { e10, e11 },
+ new MVDataEntry[] { e21 },
+ };
+
+ MVDataCombineMode mergeModes[] = new MVDataCombineMode[]{
+ MVDataCombineMode.PRIMARY_SOURCE,
+ MVDataCombineMode.MERGE_APPEND,
+ };
+
+ // Expected results
+ MVDataEntry line1 = new MVDataEntry(e10);
+ line1.mergeValues(true, e21);
+
+ MVDataEntry expected[] = new MVDataEntry[] {
+ line1,
+ null /* Should throw UnsupportedOperationException() before comparing */
+ };
+
+ // Test run
+ exception.expect(UnsupportedOperationException.class);
+ doCombineTest(expected, fakeEntries, mergeModes);
+ }
+
+
+ @Test
+ public void testGeneralCase() {
+
+ // Test Data
+ MVDataEntry e10 = new MVDataEntry("line3");
+ e10.getAttrValPairs().put("from1", "e10");
+ e10.getAttrValPairs().put("merge", "e10");
+ MVDataEntry e11 = new MVDataEntry("line4");
+ e11.getAttrValPairs().put("from1", "e11");
+ e11.getAttrValPairs().put("merge", "e11");
+
+ MVDataEntry e20 = new MVDataEntry("line1");
+ e20.getAttrValPairs().put("from2", "e20");
+ e20.getAttrValPairs().put("merge", "e20");
+ MVDataEntry e21 = new MVDataEntry("line2");
+ e21.getAttrValPairs().put("from2", "e21");
+ e21.getAttrValPairs().put("merge", "e21");
+ MVDataEntry e22 = new MVDataEntry("line3");
+ e22.getAttrValPairs().put("from2", "e22");
+ e22.getAttrValPairs().put("merge", "e22");
+
+ MVDataEntry e30 = new MVDataEntry("line2");
+ e30.getAttrValPairs().put("from3", "e30");
+ e30.getAttrValPairs().put("merge", "e30");
+
+
+ MVDataEntry[][] fakeEntries = new MVDataEntry[][] {
+ new MVDataEntry[] { e10, e11 },
+ new MVDataEntry[] { e20, e21, e22 },
+ new MVDataEntry[] { e30 },
+ };
+
+ MVDataCombineMode mergeModes[] = new MVDataCombineMode[]{
+ MVDataCombineMode.PRIMARY_SOURCE,
+ MVDataCombineMode.MERGE_REPLACE,
+ MVDataCombineMode.MERGE_APPEND,
+ };
+
+ // Expected results
+ MVDataEntry line1 = new MVDataEntry(e20);
+
+ MVDataEntry line2 = new MVDataEntry(e21);
+ line2.mergeValues(true, e30);
+
+ MVDataEntry line3 = new MVDataEntry(e10);
+ line3.mergeValues(false, e22);
+
+ MVDataEntry line4 = new MVDataEntry(e11);
+
+ MVDataEntry expected[] = new MVDataEntry[] {
+ line1,line2,line3,line4
+ };
+
+ // Test run
+ doCombineTest(expected, fakeEntries, mergeModes);
+ }
+
+ // TODO : test all Combine modes
+
+ /**
+ * Helper function to factorise Combiner tests.
+ * @param expected
+ * @param fakeEntries
+ * @param mergeModes
+ */
+ public void doCombineTest(MVDataEntry expected[], MVDataEntry[][] fakeEntries, MVDataCombineMode mergeModes[]) {
+ // Test init
+ MVDataReader readers[] = new MVDataReader[fakeEntries.length];
+ for (int i = 0; i < fakeEntries.length; i++) {
+ readers[i] = new StubDataReader("fakeReader"+i,fakeEntries[i]);
+ }
+
+ MVDataCombiner combiner = new MVDataCombiner("combiner", readers, mergeModes);
+
+ // Test twice to check if asking a new iterator "rewinds" correctly
+ for (int i=0;i<2;i++) {
+ //System.out.println("Loop " + (i+1));
+
+ Iterator<MVDataEntry> combinerIt = combiner.iterator();
+ for (int j = 0; j < expected.length; j++) {
+ assertTrue(combinerIt.hasNext());
+ MVDataEntry item = combinerIt.next();
+ //System.out.println(expected[i]);
+ //System.out.println(item);
+ //System.out.println();
+ assertEquals(expected[j], item);
+ }
+ assertFalse(combinerIt.hasNext());
+ }
+ }
+}