/home/palakars/workspace-inprogress/code-in-progress/aitools3/aitools3-aq-invertedindex2-java/test/de/aitools/aq/invertedindex/core/TestIndexer.java

Go to the documentation of this file.

package de.aitools.aq.invertedindex.core;


import java.io.File;
import java.util.ArrayList;
import java.util.List;

import org.junit.Assert;
import org.junit.Test;

import de.aitools.aq.util.RandomGenerator;
import de.aitools.aq.value.Value;
import de.aitools.aq.value.pair.DoubleDouble;
import de.aitools.aq.value.pair.DoubleInt;
import de.aitools.aq.value.pair.DoubleLong;
import de.aitools.aq.value.pair.DoubleString;
import de.aitools.aq.value.pair.IntDouble;
import de.aitools.aq.value.pair.IntInt;
import de.aitools.aq.value.pair.IntLong;
import de.aitools.aq.value.pair.IntString;
import de.aitools.aq.value.pair.LongDouble;
import de.aitools.aq.value.pair.LongInt;
import de.aitools.aq.value.pair.LongLong;
import de.aitools.aq.value.pair.LongString;
import de.aitools.aq.value.quadruple.DoubleDoubleIntInt;
import de.aitools.aq.value.quadruple.DoubleDoubleLongLong;
import de.aitools.aq.value.quadruple.DoubleLongLongInt;
import de.aitools.aq.value.quadruple.IntIntDoubleDouble;
import de.aitools.aq.value.quadruple.IntIntLongLong;
import de.aitools.aq.value.quadruple.LongDoubleLongInt;
import de.aitools.aq.value.quadruple.LongLongDoubleDouble;
import de.aitools.aq.value.quadruple.LongLongIntInt;
import de.aitools.aq.value.single.SingleBuffer;
import de.aitools.aq.value.single.SingleDouble;
import de.aitools.aq.value.single.SingleInt;
import de.aitools.aq.value.single.SingleLong;
import de.aitools.aq.value.single.SingleString;
import de.aitools.aq.value.triple.DoubleDoubleDouble;
import de.aitools.aq.value.triple.DoubleIntDouble;
import de.aitools.aq.value.triple.DoubleIntInt;
import de.aitools.aq.value.triple.IntDoubleDouble;
import de.aitools.aq.value.triple.IntIntDouble;
import de.aitools.aq.value.triple.IntIntInt;
import de.aitools.aq.value.triple.LongDoubleDouble;
import de.aitools.aq.value.triple.LongIntDouble;
import de.aitools.aq.value.triple.LongIntInt;

public class TestIndexer {

        private static final int RECORD_COUNT = 100000;
        
        private static final File tmpIndexDir = new File("testIndexer");
        
        @SuppressWarnings("unchecked")
        public static <V extends Value> List<V>
        createRandomValues(Class<V> clazz, int count)
        throws InstantiationException, IllegalAccessException {
                String unicode = "valäöü€łŧ";
                List<V> values = new ArrayList<V>();
                switch (Value.getNativeTypeId(clazz))
                {
                case SingleBuffer.NATIVE_TYPE_ID:
                        for (int i = 0; i != count; ++i) {
                                SingleBuffer array = new SingleBuffer(20);
                                array.getBuffer().putDouble(i * 23.42);
                                array.getBuffer().putLong(0); // zero bytes are interesting
                                array.getBuffer().putInt(i * 23 + 42);
                                array.getBuffer().rewind();
                                values.add((V) array);
                        }
                        break;
                case SingleString.NATIVE_TYPE_ID:
                        for (int i = 0; i != count; ++i) {
                                values.add((V) new SingleString(unicode + i));
                        }
                        break;
                case DoubleString.NATIVE_TYPE_ID:
                        for (int i = 0; i != count; ++i) {
                                values.add((V) new DoubleString(i, unicode + i));
                        }
                        break;
                case IntString.NATIVE_TYPE_ID:
                        for (int i = 0; i != count; ++i) {
                                values.add((V) new IntString(i, unicode + i));
                        }
                        break;
                case LongString.NATIVE_TYPE_ID:
                        for (int i = 0; i != count; ++i) {
                                values.add((V) new LongString(i, unicode + i));
                        }
                        break;
                default:
                        for (int i = 0; i != count; ++i) {
                                values.add(RandomGenerator.nextValue(clazz));
                        }
                }
                return values;
        }
        
        private static void deleteAll(File directory) {
                File[] files = directory.listFiles();
                if (files != null) {
                        for (File file : directory.listFiles()) {
                                deleteAll(file);
                        }
                }
                directory.delete();
        }
        
        private static <V extends Value> void test(Class<V> clazz, int count) {
                // -----------------------------------------------------------------
                // Create an indexer.
                // -----------------------------------------------------------------
                Assert.assertTrue(tmpIndexDir.mkdir());
                Configuration config = new Configuration();
                config.setIndexDirectory(tmpIndexDir);
                config.setExpectedNumberOfRecords(RECORD_COUNT);
                Indexer<V> indexer = Indexer.open(clazz, config);
                
                // -----------------------------------------------------------------
                // Create values and write them to the indexer.
                // -----------------------------------------------------------------
                String key = "k e y";
                List<V> values = null;
                try {
                        values = createRandomValues(clazz, count);
                } catch (InstantiationException e) {
                        e.printStackTrace();
                } catch (IllegalAccessException e) {
                        e.printStackTrace();
                }
                for (V value : values) {
                        indexer.put(key, value); // Create one postlist for <key>
                }
                // ---------------------------------------------------------------------
                // Insert too large key
                // ---------------------------------------------------------------------
                StringBuilder sb = new StringBuilder();
                for (int i = 0; i != 100000; ++i) sb.append('x');
                Assert.assertFalse(indexer.put(sb.toString(), values.get(0)));
                indexer.index();
                
                // -----------------------------------------------------------------
                // Open an IndexSearcher and lookup the entire record set.
                // -----------------------------------------------------------------
                Searcher<V> searcher = Searcher.open(clazz, config);
                Postlist<V> postlist = searcher.search(key);
                Assert.assertNotNull(postlist);
                Assert.assertEquals(count, postlist.size());
                for (int i = 0; i != count; ++i) {
                        V value = postlist.iterator().next();
                        Assert.assertEquals(values.get(i), value);
                }
                postlist.deleteNative();
                
                // -----------------------------------------------------------------
                // Lookup some unknown key.
                // -----------------------------------------------------------------
                postlist = searcher.search("unknown");
                Assert.assertNull(postlist);
                
                // -----------------------------------------------------------------
                // Close searcher and cleanup.
                // -----------------------------------------------------------------
                searcher.close();
                deleteAll(tmpIndexDir);
        }
        
        // -------------------------------------------------------------------------
        // Test de.aitools.aq.value.single
        // -------------------------------------------------------------------------
        
        @Test
        public final void testSingleDouble() {
                test(SingleDouble.class, RECORD_COUNT);
        }
        
        @Test
        public final void testSingleInt() {
                test(SingleInt.class, RECORD_COUNT);
        }
        
        @Test
        public final void testSingleLong() {
                test(SingleLong.class, RECORD_COUNT);
        }
        
        @Test
        public final void testSingleBuffer() {
                test(SingleBuffer.class, RECORD_COUNT);
        }
        
        @Test
        public final void testSingleString() {
                test(SingleString.class, RECORD_COUNT);
        }
        
        // -------------------------------------------------------------------------
        // Test de.aitools.aq.value.pair
        // -------------------------------------------------------------------------
        
        @Test
        public final void testDoubleDouble() {
                test(DoubleDouble.class, RECORD_COUNT);
        }
        
        @Test
        public final void testDoubleInt() {
                test(DoubleInt.class, RECORD_COUNT);
        }
        
        @Test
        public final void testDoubleLong() {
                test(DoubleLong.class, RECORD_COUNT);
        }
        
        @Test
        public final void testIntDouble() {
                test(IntDouble.class, RECORD_COUNT);
        }
        
        @Test
        public final void testIntInt() {
                test(IntInt.class, RECORD_COUNT);
        }
        
        @Test
        public final void testIntLong() {
                test(IntLong.class, RECORD_COUNT);
        }
        
        @Test
        public final void testLongDouble() {
                test(LongDouble.class, RECORD_COUNT);
        }
        
        @Test
        public final void testLongInt() {
                test(LongInt.class, RECORD_COUNT);
        }
        
        @Test
        public final void testLongLong() {
                test(LongLong.class, RECORD_COUNT);
        }
        
        // -------------------------------------------------------------------------
        // Test de.aitools.aq.value.pair with String
        // -------------------------------------------------------------------------
        
        @Test
        public final void testDoubleString() {
                test(DoubleString.class, RECORD_COUNT);
        }
        
        @Test
        public final void testIntString() {
                test(IntString.class, RECORD_COUNT);
        }
        
        @Test
        public final void testLongString() {
                test(LongString.class, RECORD_COUNT);
        }
        
        // -------------------------------------------------------------------------
        // Test de.aitools.aq.value.triple
        // -------------------------------------------------------------------------
        
        @Test
        public final void testDoubleDoubleDouble() {
                test(DoubleDoubleDouble.class, RECORD_COUNT);
        }
        
        @Test
        public final void testDoubleIntDouble() {
                test(DoubleIntDouble.class, RECORD_COUNT);
        }
        
        @Test
        public final void testDoubleIntInt() {
                test(DoubleIntInt.class, RECORD_COUNT);
        }
        
        @Test
        public final void testIntDoubleDouble() {
                test(IntDoubleDouble.class, RECORD_COUNT);
        }
        
        @Test
        public final void testIntIntDouble() {
                test(IntIntDouble.class, RECORD_COUNT);
        }
        
        @Test
        public final void testIntIntInt() {
                test(IntIntInt.class, RECORD_COUNT);
        }
        
        @Test
        public final void testLongDoubleDouble() {
                test(LongDoubleDouble.class, RECORD_COUNT);
        }
        
        @Test
        public final void testLongIntDouble() {
                test(LongIntDouble.class, RECORD_COUNT);
        }
        
        @Test
        public final void testLongIntInt() {
                test(LongIntInt.class, RECORD_COUNT);
        }
        
        // -------------------------------------------------------------------------
        // Test de.aitools.aq.value.quadruple
        // -------------------------------------------------------------------------
        
        @Test
        public final void testDoubleDoubleIntInt() {
                test(DoubleDoubleIntInt.class, RECORD_COUNT);
        }
        
        @Test
        public final void testDoubleDoubleLongLong() {
                test(DoubleDoubleLongLong.class, RECORD_COUNT);
        }
        
        @Test
        public final void testIntIntDoubleDouble() {
                test(IntIntDoubleDouble.class, RECORD_COUNT);
        }
        
        @Test
        public final void testIntIntLongLong() {
                test(IntIntLongLong.class, RECORD_COUNT);
        }
        
        @Test
        public final void testLongDoubleLongInt() {
                test(LongDoubleLongInt.class, RECORD_COUNT);
        }
        
        @Test
        public final void testLongLongDoubleDouble() {
                test(LongLongDoubleDouble.class, RECORD_COUNT);
        }
        
        @Test
        public final void testLongLongIntInt() {
                test(LongLongIntInt.class, RECORD_COUNT);
        }
        
        @Test
        public final void testDoubleLongLongInt() {
                test(DoubleLongLongInt.class, RECORD_COUNT);
        }
        
}

---