carbondata-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jack...@apache.org
Subject [06/57] [abbrv] incubator-carbondata git commit: move org.apache.carbon.common in core
Date Sat, 14 Jan 2017 07:57:15 GMT
http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/952cf517/core/src/test/java/org/apache/carbondata/core/scan/filter/FilterUtilTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/carbondata/core/scan/filter/FilterUtilTest.java b/core/src/test/java/org/apache/carbondata/core/scan/filter/FilterUtilTest.java
new file mode 100644
index 0000000..1da4415
--- /dev/null
+++ b/core/src/test/java/org/apache/carbondata/core/scan/filter/FilterUtilTest.java
@@ -0,0 +1,392 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.carbondata.core.scan.filter;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+
+import org.apache.carbondata.core.cache.dictionary.AbstractDictionaryCacheTest;
+import org.apache.carbondata.core.AbsoluteTableIdentifier;
+import org.apache.carbondata.core.CarbonTableIdentifier;
+import org.apache.carbondata.core.datastore.IndexKey;
+import org.apache.carbondata.core.datastore.block.SegmentProperties;
+import org.apache.carbondata.core.metadata.DataType;
+import org.apache.carbondata.core.metadata.Encoding;
+import org.apache.carbondata.core.metadata.schema.table.column.CarbonColumn;
+import org.apache.carbondata.core.metadata.schema.table.column.CarbonDimension;
+import org.apache.carbondata.core.metadata.schema.table.column.ColumnSchema;
+import org.apache.carbondata.core.constants.CarbonCommonConstants;
+import org.apache.carbondata.core.keygenerator.KeyGenException;
+import org.apache.carbondata.core.keygenerator.mdkey.MultiDimKeyVarLengthGenerator;
+import org.apache.carbondata.core.scan.expression.ColumnExpression;
+import org.apache.carbondata.core.scan.expression.Expression;
+import org.apache.carbondata.core.scan.expression.LiteralExpression;
+import org.apache.carbondata.core.scan.expression.conditional.ListExpression;
+import org.apache.carbondata.core.scan.filter.intf.RowImpl;
+
+import mockit.Mock;
+import mockit.MockUp;
+import org.junit.Before;
+import org.junit.Test;
+
+import static junit.framework.TestCase.assertFalse;
+import static junit.framework.TestCase.assertTrue;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+
+public class FilterUtilTest extends AbstractDictionaryCacheTest {
+
+  private ColumnSchema columnSchema;
+
+  @Before public void setUp() throws Exception {
+    init();
+    this.databaseName = props.getProperty("database", "testSchema");
+    this.tableName = props.getProperty("tableName", "carbon");
+    this.carbonStorePath = props.getProperty("storePath", "carbonStore");
+    carbonTableIdentifier =
+        new CarbonTableIdentifier(databaseName, tableName, UUID.randomUUID().toString());
+    this.carbonStorePath = props.getProperty("storePath", "carbonStore");
+    columnSchema = new ColumnSchema();
+    columnSchema.setColumnar(true);
+    columnSchema.setColumnName("IMEI");
+    columnSchema.setColumnUniqueId(UUID.randomUUID().toString());
+    columnSchema.setDataType(DataType.STRING);
+    columnSchema.setDimensionColumn(true);
+  }
+
+  @Test public void testCheckIfLeftExpressionRequireEvaluation() {
+    List<Expression> children = new ArrayList<>();
+    ListExpression expression = new ListExpression(children);
+    boolean result = FilterUtil.checkIfLeftExpressionRequireEvaluation(expression);
+    assertTrue(result);
+  }
+
+  @Test
+  public void testCheckIfLeftExpressionRequireEvaluationWithExpressionNotInstanceOfColumnExpression() {
+    ColumnExpression expression = new ColumnExpression("test", DataType.STRING);
+    boolean result = FilterUtil.checkIfLeftExpressionRequireEvaluation(expression);
+    assertFalse(result);
+  }
+
+  @Test public void testNanSafeEqualsDoublesWithUnEqualValues() {
+    Double d1 = new Double(60.67);
+    Double d2 = new Double(60.69);
+    boolean result = FilterUtil.nanSafeEqualsDoubles(d1, d2);
+    assertFalse(result);
+  }
+
+  @Test public void testNanSafeEqualsDoublesWithEqualValues() {
+    Double d1 = new Double(60.67);
+    Double d2 = new Double(60.67);
+    boolean result = FilterUtil.nanSafeEqualsDoubles(d1, d2);
+    assertTrue(result);
+  }
+
+  @Test public void testCompareFilterKeyBasedOnDataTypeForShortValue() {
+    String dictionaryVal = "1";
+    String memberVal = "1";
+    int actualResult =
+        FilterUtil.compareFilterKeyBasedOnDataType(dictionaryVal, memberVal, DataType.SHORT);
+    int expectedResult = 0;
+    assertEquals(expectedResult, actualResult);
+  }
+
+  @Test public void testCompareFilterKeyBasedOnDataTypeForIntValue() {
+    String dictionaryVal = "1000";
+    String memberVal = "1001";
+    int actualResult =
+        FilterUtil.compareFilterKeyBasedOnDataType(dictionaryVal, memberVal, DataType.INT);
+    int expectedResult = -1;
+    assertEquals(expectedResult, actualResult);
+  }
+
+  @Test public void testCompareFilterKeyBasedOnDataTypeForDoubleValue() {
+    String dictionaryVal = "1.90";
+    String memberVal = "1.89";
+    int actualResult =
+        FilterUtil.compareFilterKeyBasedOnDataType(dictionaryVal, memberVal, DataType.DOUBLE);
+    int expectedResult = 1;
+    assertEquals(expectedResult, actualResult);
+  }
+
+  @Test public void testCompareFilterKeyBasedOnDataTypeForLongValue() {
+    String dictionaryVal = "111111111111111";
+    String memberVal = "1111111111111111";
+    int actualResult =
+        FilterUtil.compareFilterKeyBasedOnDataType(dictionaryVal, memberVal, DataType.LONG);
+    int expectedResult = -1;
+    assertEquals(expectedResult, actualResult);
+  }
+
+  @Test public void testCompareFilterKeyBasedOnDataTypeForBooleanValue() {
+    String dictionaryVal = "true";
+    String memberVal = "false";
+    int actualResult =
+        FilterUtil.compareFilterKeyBasedOnDataType(dictionaryVal, memberVal, DataType.BOOLEAN);
+    int expectedResult = 1;
+    assertEquals(expectedResult, actualResult);
+  }
+
+  @Test public void testCompareFilterKeyBasedOnDataTypeForDecimalValue() {
+    String dictionaryVal = "1111111";
+    String memberVal = "1111";
+    int actualResult =
+        FilterUtil.compareFilterKeyBasedOnDataType(dictionaryVal, memberVal, DataType.DECIMAL);
+    int expectedResult = 1;
+    assertEquals(expectedResult, actualResult);
+  }
+
+  @Test public void testCompareFilterKeyBasedOnDataTypeForDefaultValue() {
+    String dictionaryVal = "11.78";
+    String memberVal = "1111.90";
+    int actualResult =
+        FilterUtil.compareFilterKeyBasedOnDataType(dictionaryVal, memberVal, DataType.FLOAT);
+    int expectedResult = -1;
+    assertEquals(expectedResult, actualResult);
+  }
+
+  @Test public void testCompareFilterKeyBasedOnDataTypeForTimestamp() {
+    String dictionaryVal = "2008-01-01 00:00:01";
+    String memberVal = "2008-01-01 00:00:01";
+    int actualValue =
+        FilterUtil.compareFilterKeyBasedOnDataType(dictionaryVal, memberVal, DataType.TIMESTAMP);
+    int expectedValue = 0;
+    assertEquals(expectedValue, actualValue);
+  }
+
+  @Test public void testCompareFilterKeyBasedOnDataTypeForException() throws Exception {
+    String dictionaryVal = "test";
+    String memberVal = "1";
+    int actualValue =
+        FilterUtil.compareFilterKeyBasedOnDataType(dictionaryVal, memberVal, DataType.INT);
+    int expectedValue = -1;
+    assertEquals(expectedValue, actualValue);
+  }
+
+  @Test public void testCreateIndexKeyFromResolvedFilterVal() throws Exception {
+    long[] startOrEndKey = new long[] { 0, 10 };
+    byte[] startOrEndKeyForNoDictDimension = { 1, 2 };
+    int[] keys = new int[] { 1, 2 };
+    MultiDimKeyVarLengthGenerator multiDimKeyVarLengthGenerator =
+        new MultiDimKeyVarLengthGenerator(keys);
+    assertTrue(FilterUtil
+        .createIndexKeyFromResolvedFilterVal(startOrEndKey, multiDimKeyVarLengthGenerator,
+            startOrEndKeyForNoDictDimension) != null);
+
+  }
+
+  @Test public void testCheckIfExpressionContainsColumn() {
+    String columnName = "IMEI";
+    Expression expression = new ColumnExpression(columnName, DataType.STRING);
+    boolean result = FilterUtil.checkIfExpressionContainsColumn(expression);
+    assertTrue(result);
+  }
+
+  @Test
+  public void testCheckIfExpressionContainsColumnWithExpressionNotInstanceOfColumnExpression() {
+    String columnName = "IMEI";
+    Expression expression = new LiteralExpression(columnName, DataType.STRING);
+    boolean result = FilterUtil.checkIfExpressionContainsColumn(expression);
+    assertFalse(result);
+  }
+
+  @Test public void testIsExpressionNeedsToResolved() {
+    boolean isIncludeFilter = true;
+    Object obj = "test";
+    LiteralExpression literalExpression = new LiteralExpression(obj, DataType.STRING);
+    boolean result = FilterUtil.isExpressionNeedsToResolved(literalExpression, isIncludeFilter);
+    assertFalse(result);
+  }
+
+  @Test public void testIsExpressionNeedsToResolvedWithDataTypeNullAndIsIncludeFilterFalse() {
+    boolean isIncludeFilter = false;
+    Object obj = "test";
+    LiteralExpression literalExpression = new LiteralExpression(obj, DataType.NULL);
+    boolean result = FilterUtil.isExpressionNeedsToResolved(literalExpression, isIncludeFilter);
+    assertTrue(result);
+  }
+
+  @Test public void testGetMaskKey() {
+    int surrogate = 1;
+    int[] keys = new int[] { 1, 2 };
+    MultiDimKeyVarLengthGenerator multiDimKeyVarLengthGenerator =
+        new MultiDimKeyVarLengthGenerator(keys);
+    int ordinal = 1;
+    int keyOrdinal = 1;
+    int columnGroupOrdinal = 1;
+    int complexTypeOrdinal = 1;
+    ColumnSchema columnSchema = new ColumnSchema();
+    columnSchema.setColumnar(true);
+    columnSchema.setColumnName("IMEI");
+    columnSchema.setColumnUniqueId(UUID.randomUUID().toString());
+    columnSchema.setDataType(DataType.STRING);
+    columnSchema.setDimensionColumn(true);
+    CarbonDimension carbonDimension =
+        new CarbonDimension(columnSchema, ordinal, keyOrdinal, columnGroupOrdinal,
+            complexTypeOrdinal);
+    byte[] expectedResult = new byte[] { 1 };
+    byte[] actualResult =
+        FilterUtil.getMaskKey(surrogate, carbonDimension, multiDimKeyVarLengthGenerator);
+    assertArrayEquals(expectedResult, actualResult);
+  }
+
+  @Test public void testGetFilterListForAllMembersRS() throws Exception {
+    Expression expression = new ColumnExpression("IMEI", DataType.STRING);
+    ColumnExpression columnExpression = new ColumnExpression("IMEI", DataType.STRING);
+    String defaultValues = "test";
+    int defaultSurrogate = 1;
+    boolean isIncludeFilter = true;
+    int ordinal = 1;
+    ColumnSchema dimColumn = new ColumnSchema();
+    dimColumn.setColumnar(true);
+    dimColumn.setColumnName("IMEI");
+    dimColumn.setColumnUniqueId(UUID.randomUUID().toString());
+    dimColumn.setDataType(DataType.STRING);
+    dimColumn.setDimensionColumn(true);
+    final CarbonColumn carbonColumn = new CarbonColumn(dimColumn, ordinal, -1);
+    new MockUp<ColumnExpression>() {
+      @Mock public CarbonColumn getCarbonColumn() {
+        return carbonColumn;
+      }
+    };
+
+    new MockUp<RowImpl>() {
+      @Mock public Object getVal(int index) {
+        return "test";
+      }
+    };
+    assertTrue(FilterUtil
+        .getFilterListForAllMembersRS(expression, columnExpression, defaultValues, defaultSurrogate,
+            isIncludeFilter) instanceof DimColumnFilterInfo);
+  }
+
+  @Test public void testGetFilterListForAllMembersRSWithDefaultValuesEqualsToNull()
+      throws Exception {
+    Expression expression = new ColumnExpression("IMEI", DataType.STRING);
+    ColumnExpression columnExpression = new ColumnExpression("IMEI", DataType.STRING);
+    String defaultValues = CarbonCommonConstants.MEMBER_DEFAULT_VAL;
+    int defaultSurrogate = 1;
+    boolean isIncludeFilter = true;
+    int ordinal = 1;
+    ColumnSchema dimColumn = new ColumnSchema();
+    dimColumn.setColumnar(true);
+    dimColumn.setColumnName("IMEI");
+    dimColumn.setColumnUniqueId(UUID.randomUUID().toString());
+    dimColumn.setDataType(DataType.STRING);
+    dimColumn.setDimensionColumn(true);
+    final CarbonColumn carbonColumn = new CarbonColumn(dimColumn, ordinal, -1);
+    new MockUp<ColumnExpression>() {
+      @Mock public CarbonColumn getCarbonColumn() {
+        return carbonColumn;
+      }
+    };
+
+    new MockUp<RowImpl>() {
+      @Mock public Object getVal(int index) {
+        return "test";
+      }
+    };
+    assertTrue(FilterUtil
+        .getFilterListForAllMembersRS(expression, columnExpression, defaultValues, defaultSurrogate,
+            isIncludeFilter) instanceof DimColumnFilterInfo);
+  }
+
+  @Test public void testgetFilterListForRS() throws Exception {
+    Expression expression = new ColumnExpression("IMEI", DataType.STRING);
+    ColumnExpression columnExpression = new ColumnExpression("IMEI", DataType.STRING);
+    String defaultValues = CarbonCommonConstants.MEMBER_DEFAULT_VAL;
+    int defaultSurrogate = 1;
+    int ordinal = 1;
+    final CarbonColumn carbonColumn = new CarbonColumn(columnSchema, ordinal, -1);
+    new MockUp<ColumnExpression>() {
+      @Mock public CarbonColumn getCarbonColumn() {
+        return carbonColumn;
+      }
+    };
+
+    new MockUp<RowImpl>() {
+      @Mock public Object getVal(int index) {
+        return "test";
+      }
+    };
+    assertTrue(FilterUtil.getFilterListForRS(expression, columnExpression, defaultValues,
+        defaultSurrogate) instanceof DimColumnFilterInfo);
+  }
+
+  @Test public void testCheckIfDataTypeNotTimeStamp() {
+    Expression expression = new ColumnExpression("test", DataType.STRING);
+    boolean result = FilterUtil.checkIfDataTypeNotTimeStamp(expression);
+    assertFalse(result);
+  }
+
+  @Test public void testPrepareDefaultEndIndexKey() throws Exception {
+    List<ColumnSchema> columnsInTable = new ArrayList<>();
+    columnsInTable.add(columnSchema);
+    int[] columnCardinality = new int[] { 1, 2 };
+    new MockUp<ColumnSchema>() {
+      @Mock public List<Encoding> getEncodingList() {
+        List<Encoding> encodingList = new ArrayList<>();
+        encodingList.add(Encoding.DICTIONARY);
+        return encodingList;
+      }
+    };
+    SegmentProperties segmentProperties = new SegmentProperties(columnsInTable, columnCardinality);
+    assertTrue(FilterUtil.prepareDefaultEndIndexKey(segmentProperties) instanceof IndexKey);
+  }
+
+  @Test public void testCheckIfRightExpressionRequireEvaluation() {
+    Expression expression = new ColumnExpression("test", DataType.STRING);
+    boolean result = FilterUtil.checkIfRightExpressionRequireEvaluation(expression);
+    assertTrue(result);
+  }
+
+  @Test
+  public void testCheckIfRightExpressionRequireEvaluationWithExpressionIsInstanceOfLiteralExpression() {
+    Expression expression = new LiteralExpression("test", DataType.STRING);
+    boolean result = FilterUtil.checkIfRightExpressionRequireEvaluation(expression);
+    assertFalse(result);
+  }
+
+  @Test public void testGetNoDictionaryValKeyMemberForFilter() {
+    boolean isIncludeFilter = true;
+    AbsoluteTableIdentifier absoluteTableIdentifier =
+        new AbsoluteTableIdentifier(this.carbonStorePath, carbonTableIdentifier);
+    ColumnExpression expression = new ColumnExpression("test", DataType.STRING);
+    List<String> evaluateResultListFinal = new ArrayList<>();
+    evaluateResultListFinal.add("test1");
+    evaluateResultListFinal.add("test2");
+    assertTrue(FilterUtil.getNoDictionaryValKeyMemberForFilter(evaluateResultListFinal, isIncludeFilter) instanceof DimColumnFilterInfo);
+  }
+
+  @Test public void testPrepareDefaultStartIndexKey() throws KeyGenException {
+    List<ColumnSchema> columnsInTable = new ArrayList<>();
+    columnsInTable.add(columnSchema);
+    int[] columnCardinality = new int[] { 1, 2 };
+    new MockUp<ColumnSchema>() {
+      @Mock public List<Encoding> getEncodingList() {
+        List<Encoding> encodingList = new ArrayList<>();
+        encodingList.add(Encoding.DICTIONARY);
+        return encodingList;
+      }
+    };
+    SegmentProperties segmentProperties = new SegmentProperties(columnsInTable, columnCardinality);
+    assertTrue(FilterUtil.prepareDefaultStartIndexKey(segmentProperties) instanceof IndexKey);
+  }
+}

http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/952cf517/core/src/test/java/org/apache/carbondata/core/scan/result/BatchResultTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/carbondata/core/scan/result/BatchResultTest.java b/core/src/test/java/org/apache/carbondata/core/scan/result/BatchResultTest.java
new file mode 100644
index 0000000..7bb70a0
--- /dev/null
+++ b/core/src/test/java/org/apache/carbondata/core/scan/result/BatchResultTest.java
@@ -0,0 +1,95 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.carbondata.core.scan.result;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.NoSuchElementException;
+
+import mockit.Mock;
+import mockit.MockUp;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+public class BatchResultTest {
+  private static BatchResult batchResult;
+  private static List<Object[]> rowsList = new ArrayList(2);
+
+  @BeforeClass public static void setUp() {
+    batchResult = new BatchResult();
+    rowsList.add(0, new Integer[] { 1, 2 });
+    rowsList.add(1, new Integer[] { 3 });
+  }
+
+  @Test public void testNext() throws NoSuchElementException {
+    BatchResult rows = new BatchResult();
+    rows.setRows(rowsList);
+    Object[] result = rows.next();
+    assert (result.equals(rowsList.get(0)));
+  }
+
+  @Test(expected = NoSuchElementException.class) public void testNextWithNoSuchElementException() {
+    BatchResult rows = new BatchResult();
+    List emptyList = new ArrayList(2);
+    rows.setRows(emptyList);
+    rows.next();
+  }
+
+  @Test public void testGetRows() {
+    new MockUp<BatchResult>() {
+      @Mock public void $init() {
+        //to be left blank
+      }
+    };
+    BatchResult batchResult = new BatchResult();
+    List<Object[]> list = batchResult.getRows();
+    assertNull("Number of rows is null", list);
+  }
+
+  @Test public void testHasNext() {
+    List<Object[]> list = new ArrayList<>();
+    list.add(0, new Integer[] { 1, 2 });
+    list.add(1, new Integer[] { 1, 2 });
+    batchResult.setRows(list);
+    boolean result = batchResult.hasNext();
+    assert (result);
+  }
+
+  @Test public void testGetRawRow() {
+    List<Object[]> list = new ArrayList<>();
+    list.add(0, new Integer[] { 1, 2 });
+    batchResult.setRows(list);
+    Object[] actualValue = batchResult.getRawRow(0);
+    assert (list.get(0) == actualValue);
+  }
+
+  @Test public void testGetSize() {
+    List<Object[]> list = new ArrayList<>();
+    list.add(0, new Integer[] { 1, 2 });
+    list.add(1, new Integer[] { 1, 2 });
+    batchResult.setRows(list);
+    int actualValue = batchResult.getSize();
+    int expectedValue = 2;
+    assertEquals(expectedValue, actualValue);
+  }
+
+}

http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/952cf517/core/src/test/java/org/apache/carbondata/core/scan/result/impl/FilterQueryScannedResultTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/carbondata/core/scan/result/impl/FilterQueryScannedResultTest.java b/core/src/test/java/org/apache/carbondata/core/scan/result/impl/FilterQueryScannedResultTest.java
new file mode 100644
index 0000000..d77f3e6
--- /dev/null
+++ b/core/src/test/java/org/apache/carbondata/core/scan/result/impl/FilterQueryScannedResultTest.java
@@ -0,0 +1,210 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.carbondata.core.scan.result.impl;
+
+
+public class FilterQueryScannedResultTest {
+
+//  private static FilterQueryScannedResult filterQueryScannedResult;
+//
+//  @BeforeClass public static void setUp() {
+//    BlockExecutionInfo blockExecutionInfo = new BlockExecutionInfo();
+//    blockExecutionInfo.setFixedLengthKeySize(2);
+//    blockExecutionInfo.setNoDictionaryBlockIndexes(new int[] { 0, 1 });
+//    blockExecutionInfo.setDictionaryColumnBlockIndex(new int[] { 0, 1 });
+//    Map<Integer, KeyStructureInfo> columnGourpToKeyInfo = new HashMap<>();
+//    columnGourpToKeyInfo.put(1, new KeyStructureInfo());
+//    blockExecutionInfo.setColumnGroupToKeyStructureInfo(columnGourpToKeyInfo);
+//    Map<Integer, GenericQueryType> genericQueryType = new HashMap<>();
+//    genericQueryType.put(1, new ArrayQueryType("Query1", "Parent", 1));
+//    blockExecutionInfo.setComplexDimensionInfoMap(genericQueryType);
+//    blockExecutionInfo.setComplexColumnParentBlockIndexes(new int[] { 1 });
+//    QueryDimension[] queryDimensions = { new QueryDimension("Col1"), new QueryDimension("Col2") };
+//    blockExecutionInfo.setQueryDimensions(queryDimensions);
+//    filterQueryScannedResult = new FilterQueryScannedResult(blockExecutionInfo);
+//    filterQueryScannedResult.setIndexes(new int[] { 1, 2, 3, 4 });
+//    DimensionChunkAttributes dimensionChunkAttributes = new DimensionChunkAttributes();
+//    dimensionChunkAttributes.setEachRowSize(0);
+//    ColumnGroupDimensionDataChunk[] columnGroupDimensionDataChunks =
+//        { new ColumnGroupDimensionDataChunk(new byte[] { 1, 2 }, dimensionChunkAttributes),
+//            new ColumnGroupDimensionDataChunk(new byte[] { 2, 3 }, dimensionChunkAttributes) };
+//    filterQueryScannedResult.setDimensionChunks(columnGroupDimensionDataChunks);
+//    MeasureColumnDataChunk measureColumnDataChunk = new MeasureColumnDataChunk();
+//    filterQueryScannedResult
+//        .setMeasureChunks(new MeasureColumnDataChunk[] { measureColumnDataChunk });
+//  }
+//
+//  @Test public void testToGetDictionaryKeyArray() {
+//    new MockUp<ColumnGroupDimensionDataChunk>() {
+//      @Mock @SuppressWarnings("unused") public int fillChunkData(byte[] data, int offset, int rowId,
+//          KeyStructureInfo restructuringInfo) {
+//        return 1;
+//      }
+//    };
+//    byte[] keyArray = filterQueryScannedResult.getDictionaryKeyArray();
+//    byte[] expectedResult = { 0, 0 };
+//    assertThat(expectedResult, is(equalTo(keyArray)));
+//  }
+//
+//  @Test public void testToGetDictionaryKeyIntegerArray() {
+//    new MockUp<ColumnGroupDimensionDataChunk>() {
+//      @Mock @SuppressWarnings("unused")
+//      public int fillConvertedChunkData(int rowId, int columnIndex, int[] row,
+//          KeyStructureInfo info) {
+//        return 1;
+//      }
+//    };
+//    int[] keyArray = filterQueryScannedResult.getDictionaryKeyIntegerArray();
+//    int[] expectedResult = { 0, 0 };
+//    assertThat(expectedResult, is(equalTo(keyArray)));
+//  }
+//
+//  @Test public void testToGetComplexTypeKeyArray() {
+//    new MockUp<ByteArrayOutputStream>() {
+//      @Mock @SuppressWarnings("unused") public synchronized byte toByteArray()[] {
+//        return new byte[] { 1, 2, 3 };
+//      }
+//    };
+//    new MockUp<ArrayQueryType>() {
+//      @Mock @SuppressWarnings("unused") public void parseBlocksAndReturnComplexColumnByteArray(
+//          DimensionColumnDataChunk[] dimensionColumnDataChunks, int rowNumber,
+//          DataOutputStream dataOutputStream) throws IOException {
+//      }
+//    };
+//    filterQueryScannedResult.incrementCounter();
+//    byte[][] keyArray = filterQueryScannedResult.getComplexTypeKeyArray();
+//    byte[][] expectedResult = { { 1, 2, 3 } };
+//    assertThat(expectedResult, is(equalTo(keyArray)));
+//  }
+//
+//  @Test public void testToGetNoDictionaryKeyArray() {
+//    new MockUp<ColumnGroupDimensionDataChunk>() {
+//      @Mock @SuppressWarnings("unused") public byte[] getChunkData(int rowId) {
+//        return new byte[] { 1, 2, 3 };
+//      }
+//    };
+//    byte[][] dictionaryKeyArray = filterQueryScannedResult.getNoDictionaryKeyArray();
+//    byte[][] expectedResult = { { 1, 2, 3 }, { 1, 2, 3 } };
+//    assertThat(expectedResult, is(equalTo(dictionaryKeyArray)));
+//  }
+//
+//  @Test public void testToGetNoDictionaryKeyStringArray() {
+//    new MockUp<ColumnGroupDimensionDataChunk>() {
+//      @Mock @SuppressWarnings("unused") public byte[] getChunkData(int rowId) {
+//        return "1".getBytes();
+//      }
+//    };
+//    filterQueryScannedResult.incrementCounter();
+//    String[] dictionaryKeyStringArray = filterQueryScannedResult.getNoDictionaryKeyStringArray();
+//    String[] expectedResult = { "1", "1" };
+//    assertThat(expectedResult, is(equalTo(dictionaryKeyStringArray)));
+//  }
+//
+//  @Test public void testToGetCurrenrRowId() {
+//    int rowId = filterQueryScannedResult.getCurrenrRowId();
+//    int expectedResult = 3;
+//    assertThat(expectedResult, is(equalTo(rowId)));
+//  }
+//
+//  @Test public void testToGetDimensionKey() {
+//    new MockUp<ColumnGroupDimensionDataChunk>() {
+//      @Mock @SuppressWarnings("unused") public byte[] getChunkData(int rowId) {
+//        return "1".getBytes();
+//      }
+//    };
+//    byte[] dictionaryKeyStringArray = filterQueryScannedResult.getDimensionKey(0);
+//    byte[] expectedResult = "1".getBytes();
+//    assertThat(expectedResult, is(equalTo(dictionaryKeyStringArray)));
+//  }
+//
+//  @Test public void testToGetIsNullMeasureValue() {
+//    new MockUp<MeasureColumnDataChunk>() {
+//      @Mock @SuppressWarnings("unused") public PresenceMeta getNullValueIndexHolder() {
+//        return new PresenceMeta();
+//
+//      }
+//    };
+//    new MockUp<PresenceMeta>() {
+//      @Mock @SuppressWarnings("unused") public BitSet getBitSet() {
+//        return new BitSet();
+//      }
+//    };
+//    new MockUp<BitSet>() {
+//      @Mock @SuppressWarnings("unused") public boolean get(int bitIndex) {
+//        return false;
+//      }
+//    };
+//
+//    boolean nullMeasureValue = filterQueryScannedResult.isNullMeasureValue(0);
+//    assertThat(false, is(equalTo(nullMeasureValue)));
+//  }
+//
+//  @Test public void testToGetLongMeasureValue() {
+//    new MockUp<MeasureColumnDataChunk>() {
+//      @Mock @SuppressWarnings("unused") public CarbonReadDataHolder getMeasureDataHolder() {
+//        return new CarbonReadDataHolder();
+//
+//      }
+//    };
+//    new MockUp<CarbonReadDataHolder>() {
+//      @Mock @SuppressWarnings("unused") public long getReadableLongValueByIndex(int index) {
+//        return 2L;
+//      }
+//    };
+//    long longMeasureValue = filterQueryScannedResult.getLongMeasureValue(0);
+//    long expectedResult = 2L;
+//    assertThat(expectedResult, is(equalTo(longMeasureValue)));
+//  }
+//
+//  @Test public void testToGetDoubleMeasureValue() {
+//    new MockUp<MeasureColumnDataChunk>() {
+//      @Mock @SuppressWarnings("unused") public CarbonReadDataHolder getMeasureDataHolder() {
+//        return new CarbonReadDataHolder();
+//
+//      }
+//    };
+//    new MockUp<CarbonReadDataHolder>() {
+//      @Mock @SuppressWarnings("unused") public double getReadableDoubleValueByIndex(int index) {
+//        return 2.0;
+//      }
+//    };
+//    double longMeasureValue = filterQueryScannedResult.getDoubleMeasureValue(0);
+//    double expectedResult = 2.0;
+//    assertThat(expectedResult, is(equalTo(longMeasureValue)));
+//  }
+//
+//  @Test public void testToGetBigDecimalMeasureValue() {
+//    new MockUp<MeasureColumnDataChunk>() {
+//      @Mock @SuppressWarnings("unused") public CarbonReadDataHolder getMeasureDataHolder() {
+//        return new CarbonReadDataHolder();
+//
+//      }
+//    };
+//    new MockUp<CarbonReadDataHolder>() {
+//      @Mock @SuppressWarnings("unused")
+//      public BigDecimal getReadableBigDecimalValueByIndex(int index) {
+//        return new BigDecimal(2);
+//      }
+//    };
+//    BigDecimal longMeasureValue = filterQueryScannedResult.getBigDecimalMeasureValue(0);
+//    BigDecimal expectedResult = new BigDecimal(2);
+//    assertThat(expectedResult, is(equalTo(longMeasureValue)));
+//  }
+
+}

http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/952cf517/core/src/test/java/org/apache/carbondata/core/scan/result/impl/NonFilterQueryScannedResultTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/carbondata/core/scan/result/impl/NonFilterQueryScannedResultTest.java b/core/src/test/java/org/apache/carbondata/core/scan/result/impl/NonFilterQueryScannedResultTest.java
new file mode 100644
index 0000000..3a33052
--- /dev/null
+++ b/core/src/test/java/org/apache/carbondata/core/scan/result/impl/NonFilterQueryScannedResultTest.java
@@ -0,0 +1,209 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.carbondata.core.scan.result.impl;
+
+
+public class NonFilterQueryScannedResultTest {
+
+//  private static NonFilterQueryScannedResult filterQueryScannedResult;
+//
+//  @BeforeClass public static void setUp() {
+//    BlockExecutionInfo blockExecutionInfo = new BlockExecutionInfo();
+//    blockExecutionInfo.setFixedLengthKeySize(2);
+//    blockExecutionInfo.setNoDictionaryBlockIndexes(new int[] { 0, 1 });
+//    blockExecutionInfo.setDictionaryColumnBlockIndex(new int[] { 0, 1 });
+//    Map<Integer, KeyStructureInfo> columnGourpToKeyInfo = new HashMap<>();
+//    columnGourpToKeyInfo.put(1, new KeyStructureInfo());
+//    blockExecutionInfo.setColumnGroupToKeyStructureInfo(columnGourpToKeyInfo);
+//    Map<Integer, GenericQueryType> genericQueryType = new HashMap<>();
+//    genericQueryType.put(1, new ArrayQueryType("Query1", "Parent", 1));
+//    blockExecutionInfo.setComplexDimensionInfoMap(genericQueryType);
+//    blockExecutionInfo.setComplexColumnParentBlockIndexes(new int[] { 1 });
+//    QueryDimension[] queryDimensions = { new QueryDimension("Col1"), new QueryDimension("Col2") };
+//    blockExecutionInfo.setQueryDimensions(queryDimensions);
+//    filterQueryScannedResult = new NonFilterQueryScannedResult(blockExecutionInfo);
+//    DimensionChunkAttributes dimensionChunkAttributes = new DimensionChunkAttributes();
+//    dimensionChunkAttributes.setEachRowSize(0);
+//    ColumnGroupDimensionDataChunk[] columnGroupDimensionDataChunks =
+//        { new ColumnGroupDimensionDataChunk(new byte[] { 1, 2 }, dimensionChunkAttributes),
+//            new ColumnGroupDimensionDataChunk(new byte[] { 2, 3 }, dimensionChunkAttributes) };
+//    filterQueryScannedResult.setDimensionChunks(columnGroupDimensionDataChunks);
+//    MeasureColumnDataChunk measureColumnDataChunk = new MeasureColumnDataChunk();
+//    filterQueryScannedResult
+//        .setMeasureChunks(new MeasureColumnDataChunk[] { measureColumnDataChunk });
+//  }
+//
+//  @Test public void testToGetDictionaryKeyArray() {
+//    new MockUp<ColumnGroupDimensionDataChunk>() {
+//      @Mock @SuppressWarnings("unused") public int fillChunkData(byte[] data, int offset, int rowId,
+//          KeyStructureInfo restructuringInfo) {
+//        return 1;
+//      }
+//    };
+//    byte[] keyArray = filterQueryScannedResult.getDictionaryKeyArray();
+//    byte[] expectedResult = { 0, 0 };
+//    assertThat(expectedResult, is(equalTo(keyArray)));
+//  }
+//
+//  @Test public void testToGetDictionaryKeyIntegerArray() {
+//    new MockUp<ColumnGroupDimensionDataChunk>() {
+//      @Mock @SuppressWarnings("unused")
+//      public int fillConvertedChunkData(int rowId, int columnIndex, int[] row,
+//          KeyStructureInfo info) {
+//        return 1;
+//      }
+//    };
+//    int[] keyArray = filterQueryScannedResult.getDictionaryKeyIntegerArray();
+//    int[] expectedResult = { 0, 0 };
+//    assertThat(expectedResult, is(equalTo(keyArray)));
+//  }
+//
+//  @Test public void testToGetComplexTypeKeyArray() {
+//    new MockUp<ByteArrayOutputStream>() {
+//      @Mock @SuppressWarnings("unused") public synchronized byte toByteArray()[] {
+//        return new byte[] { 1, 2, 3 };
+//      }
+//    };
+//    new MockUp<ArrayQueryType>() {
+//      @Mock @SuppressWarnings("unused") public void parseBlocksAndReturnComplexColumnByteArray(
+//          DimensionColumnDataChunk[] dimensionColumnDataChunks, int rowNumber,
+//          DataOutputStream dataOutputStream) throws IOException {
+//      }
+//    };
+//    filterQueryScannedResult.incrementCounter();
+//    byte[][] keyArray = filterQueryScannedResult.getComplexTypeKeyArray();
+//    byte[][] expectedResult = { { 1, 2, 3 } };
+//    assertThat(expectedResult, is(equalTo(keyArray)));
+//  }
+//
+//  @Test public void testToGetNoDictionaryKeyArray() {
+//    new MockUp<ColumnGroupDimensionDataChunk>() {
+//      @Mock @SuppressWarnings("unused") public byte[] getChunkData(int rowId) {
+//        return new byte[] { 1, 2, 3 };
+//      }
+//    };
+//    byte[][] dictionaryKeyArray = filterQueryScannedResult.getNoDictionaryKeyArray();
+//    byte[][] expectedResult = { { 1, 2, 3 }, { 1, 2, 3 } };
+//    assertThat(expectedResult, is(equalTo(dictionaryKeyArray)));
+//  }
+//
+//  @Test public void testToGetNoDictionaryKeyStringArray() {
+//    new MockUp<ColumnGroupDimensionDataChunk>() {
+//      @Mock @SuppressWarnings("unused") public byte[] getChunkData(int rowId) {
+//        return "1".getBytes();
+//      }
+//    };
+//    filterQueryScannedResult.incrementCounter();
+//    String[] dictionaryKeyStringArray = filterQueryScannedResult.getNoDictionaryKeyStringArray();
+//    String[] expectedResult = { "1", "1" };
+//    assertThat(expectedResult, is(equalTo(dictionaryKeyStringArray)));
+//  }
+//
+//  @Test public void testToGetCurrenrRowId() {
+//    int rowId = filterQueryScannedResult.getCurrenrRowId();
+//    int expectedResult = 2;
+//    assertThat(expectedResult, is(equalTo(rowId)));
+//  }
+//
+//  @Test public void testToGetDimensionKey() {
+//    new MockUp<ColumnGroupDimensionDataChunk>() {
+//      @Mock @SuppressWarnings("unused") public byte[] getChunkData(int rowId) {
+//        return "1".getBytes();
+//      }
+//    };
+//    byte[] dictionaryKeyStringArray = filterQueryScannedResult.getDimensionKey(0);
+//    byte[] expectedResult = "1".getBytes();
+//    assertThat(expectedResult, is(equalTo(dictionaryKeyStringArray)));
+//  }
+//
+//  @Test public void testToGetIsNullMeasureValue() {
+//    new MockUp<MeasureColumnDataChunk>() {
+//      @Mock @SuppressWarnings("unused") public PresenceMeta getNullValueIndexHolder() {
+//        return new PresenceMeta();
+//
+//      }
+//    };
+//    new MockUp<PresenceMeta>() {
+//      @Mock @SuppressWarnings("unused") public BitSet getBitSet() {
+//        return new BitSet();
+//      }
+//    };
+//    new MockUp<BitSet>() {
+//      @Mock @SuppressWarnings("unused") public boolean get(int bitIndex) {
+//        return false;
+//      }
+//    };
+//
+//    boolean nullMeasureValue = filterQueryScannedResult.isNullMeasureValue(0);
+//    assertThat(false, is(equalTo(nullMeasureValue)));
+//  }
+//
+//  @Test public void testToGetLongMeasureValue() {
+//    new MockUp<MeasureColumnDataChunk>() {
+//      @Mock @SuppressWarnings("unused") public CarbonReadDataHolder getMeasureDataHolder() {
+//        return new CarbonReadDataHolder();
+//
+//      }
+//    };
+//    new MockUp<CarbonReadDataHolder>() {
+//      @Mock @SuppressWarnings("unused") public long getReadableLongValueByIndex(int index) {
+//        return 2L;
+//      }
+//    };
+//    long longMeasureValue = filterQueryScannedResult.getLongMeasureValue(0);
+//    long expectedResult = 2L;
+//    assertThat(expectedResult, is(equalTo(longMeasureValue)));
+//  }
+//
+//  @Test public void testToGetDoubleMeasureValue() {
+//    new MockUp<MeasureColumnDataChunk>() {
+//      @Mock @SuppressWarnings("unused") public CarbonReadDataHolder getMeasureDataHolder() {
+//        return new CarbonReadDataHolder();
+//
+//      }
+//    };
+//    new MockUp<CarbonReadDataHolder>() {
+//      @Mock @SuppressWarnings("unused") public double getReadableDoubleValueByIndex(int index) {
+//        return 2.0;
+//      }
+//    };
+//    double longMeasureValue = filterQueryScannedResult.getDoubleMeasureValue(0);
+//    double expectedResult = 2.0;
+//    assertThat(expectedResult, is(equalTo(longMeasureValue)));
+//  }
+//
+//  @Test public void testToGetBigDecimalMeasureValue() {
+//    new MockUp<MeasureColumnDataChunk>() {
+//      @Mock @SuppressWarnings("unused") public CarbonReadDataHolder getMeasureDataHolder() {
+//        return new CarbonReadDataHolder();
+//
+//      }
+//    };
+//    new MockUp<CarbonReadDataHolder>() {
+//      @Mock @SuppressWarnings("unused")
+//      public BigDecimal getReadableBigDecimalValueByIndex(int index) {
+//        return new BigDecimal(2);
+//      }
+//    };
+//    BigDecimal longMeasureValue = filterQueryScannedResult.getBigDecimalMeasureValue(0);
+//    BigDecimal expectedResult = new BigDecimal(2);
+//    assertThat(expectedResult, is(equalTo(longMeasureValue)));
+//  }
+
+}

http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/952cf517/core/src/test/java/org/apache/carbondata/core/scan/wrappers/ByteArrayWrapperTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/carbondata/core/scan/wrappers/ByteArrayWrapperTest.java b/core/src/test/java/org/apache/carbondata/core/scan/wrappers/ByteArrayWrapperTest.java
new file mode 100644
index 0000000..cec14df
--- /dev/null
+++ b/core/src/test/java/org/apache/carbondata/core/scan/wrappers/ByteArrayWrapperTest.java
@@ -0,0 +1,107 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.carbondata.core.scan.wrappers;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static junit.framework.TestCase.assertEquals;
+import static junit.framework.TestCase.assertFalse;
+import static junit.framework.TestCase.assertTrue;
+
+public class ByteArrayWrapperTest {
+  private static ByteArrayWrapper byteArrayWrapper;
+  byte[] dictionaryKey = new byte[] { 1 };
+  byte[][] complexTypesKeys = { { 1 }, { 1 } };
+  byte[][] noDictionaryKeys = new byte[][] { { 1 }, { 1 } };
+
+  @BeforeClass
+
+  public static void setUp() {
+    byteArrayWrapper = new ByteArrayWrapper();
+  }
+
+  @AfterClass public static void tearDown() {
+    byteArrayWrapper = null;
+  }
+
+  @Test public void testHashCodeValue() {
+    byteArrayWrapper.setDictionaryKey(dictionaryKey);
+    byteArrayWrapper.setComplexTypesKeys(complexTypesKeys);
+    byteArrayWrapper.setNoDictionaryKeys(noDictionaryKeys);
+
+    int result = byteArrayWrapper.hashCode();
+    assert (29583456 == result);
+  }
+
+  @Test public void testEqualsWithOtherAsInstanceOfByteArrayWrapper() {
+    ByteArrayWrapper other;
+    other = null;
+    boolean result = byteArrayWrapper.equals(other);
+    assertFalse(result);
+  }
+
+  @Test public void testEqualsWithNoDictionaryKeysOtherNotEqualNoDictionaryKeys() {
+    byte[][] noDictionaryKeysOther = { { 1 } };
+    byteArrayWrapper.setNoDictionaryKeys(noDictionaryKeys);
+    ByteArrayWrapper other = new ByteArrayWrapper();
+    other.setNoDictionaryKeys(noDictionaryKeysOther);
+    boolean result = byteArrayWrapper.equals(other);
+    assertFalse(result);
+  }
+
+  @Test public void testEqualsWithComplexTypesKeysOtherNotEqualComplexTypesKeys() {
+    byte[][] complexTypesKeysOther = { { 1 } };
+    byteArrayWrapper.setComplexTypesKeys(complexTypesKeys);
+    byteArrayWrapper.setNoDictionaryKeys(noDictionaryKeys);
+    ByteArrayWrapper other = new ByteArrayWrapper();
+    other.setComplexTypesKeys(complexTypesKeysOther);
+    other.setNoDictionaryKeys(noDictionaryKeys);
+    boolean result = byteArrayWrapper.equals(other);
+    assertFalse(result);
+  }
+
+  @Test
+
+  public void testEqualsForFirstElementComplexTypesKeysAndOther() {
+    ByteArrayWrapper other = new ByteArrayWrapper();
+    other.setComplexTypesKeys(complexTypesKeys);
+    other.setDictionaryKey(dictionaryKey);
+    other.setNoDictionaryKeys(noDictionaryKeys);
+    byteArrayWrapper.setComplexTypesKeys(complexTypesKeys);
+    byteArrayWrapper.setDictionaryKey(dictionaryKey);
+    byteArrayWrapper.setNoDictionaryKeys(noDictionaryKeys);
+    boolean result = byteArrayWrapper.equals(other);
+    assertTrue(result);
+  }
+
+  @Test public void testCompareTo() {
+    byteArrayWrapper.setDictionaryKey(dictionaryKey);
+    ByteArrayWrapper other = new ByteArrayWrapper();
+    other.setDictionaryKey(dictionaryKey);
+    other.setNoDictionaryKeys(noDictionaryKeys);
+    other.setComplexTypesKeys(complexTypesKeys);
+    byteArrayWrapper.setNoDictionaryKeys(noDictionaryKeys);
+    byteArrayWrapper.setComplexTypesKeys(complexTypesKeys);
+    int actualResult = byteArrayWrapper.compareTo(other);
+    int expectedResult = 0;
+    assertEquals(expectedResult, actualResult);
+  }
+}

http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/952cf517/core/src/test/java/org/apache/carbondata/core/stats/DriverQueryStatisticsRecorderImplTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/carbondata/core/stats/DriverQueryStatisticsRecorderImplTest.java b/core/src/test/java/org/apache/carbondata/core/stats/DriverQueryStatisticsRecorderImplTest.java
new file mode 100644
index 0000000..54f601b
--- /dev/null
+++ b/core/src/test/java/org/apache/carbondata/core/stats/DriverQueryStatisticsRecorderImplTest.java
@@ -0,0 +1,124 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.carbondata.core.stats;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.carbondata.core.stats.DriverQueryStatisticsRecorderImpl;
+import org.apache.carbondata.core.stats.QueryStatistic;
+import org.apache.carbondata.core.stats.QueryStatisticsConstants;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static junit.framework.TestCase.assertNotNull;
+import static org.pentaho.di.core.util.Assert.assertNull;
+
+public class DriverQueryStatisticsRecorderImplTest {
+  private static DriverQueryStatisticsRecorderImpl driverQueryStatisticsRecorderImpl = null;
+  private static QueryStatistic queryStasticsWithSQL_PARSE = null;
+  private static QueryStatistic queryStasticsWithLoadMetaData = null;
+  private static QueryStatistic queryStasticsWithLOAD_BLOCKS_DRIVER = null;
+  private static QueryStatistic queryStasticsWithBLOCK_ALLOCATION = null;
+  private static QueryStatistic queryStasticsWithBLOCK_IDENTIFICATION = null;
+
+  private static List<QueryStatistic> queryStatisticList;
+
+  @BeforeClass public static void setUp() {
+    driverQueryStatisticsRecorderImpl = DriverQueryStatisticsRecorderImpl.getInstance();
+    queryStasticsWithSQL_PARSE = new QueryStatistic();
+    queryStasticsWithLoadMetaData = new QueryStatistic();
+    queryStasticsWithLOAD_BLOCKS_DRIVER = new QueryStatistic();
+    queryStasticsWithBLOCK_ALLOCATION = new QueryStatistic();
+    queryStasticsWithBLOCK_IDENTIFICATION = new QueryStatistic();
+    queryStatisticList = new ArrayList<>();
+
+  }
+
+  @Test public void testCollectDriverStatistics() {
+    queryStasticsWithLOAD_BLOCKS_DRIVER
+        .addCountStatistic(QueryStatisticsConstants.LOAD_BLOCKS_DRIVER, 3);
+    queryStasticsWithLOAD_BLOCKS_DRIVER
+        .addStatistics(QueryStatisticsConstants.LOAD_BLOCKS_DRIVER, 5);
+    queryStasticsWithLOAD_BLOCKS_DRIVER
+        .addFixedTimeStatistic(QueryStatisticsConstants.LOAD_BLOCKS_DRIVER, 5);
+    queryStatisticList.add(queryStasticsWithLOAD_BLOCKS_DRIVER);
+    queryStasticsWithBLOCK_ALLOCATION
+        .addCountStatistic(QueryStatisticsConstants.BLOCK_ALLOCATION, 3);
+    queryStasticsWithBLOCK_ALLOCATION.addStatistics(QueryStatisticsConstants.BLOCK_ALLOCATION, 5);
+    queryStasticsWithLOAD_BLOCKS_DRIVER
+        .addFixedTimeStatistic(QueryStatisticsConstants.LOAD_BLOCKS_DRIVER, 5);
+    queryStatisticList.add(queryStasticsWithBLOCK_ALLOCATION);
+    queryStasticsWithBLOCK_IDENTIFICATION
+        .addCountStatistic(QueryStatisticsConstants.BLOCK_IDENTIFICATION, 3);
+    queryStasticsWithBLOCK_IDENTIFICATION
+        .addStatistics(QueryStatisticsConstants.BLOCK_IDENTIFICATION, 5);
+    queryStatisticList.add(queryStasticsWithBLOCK_IDENTIFICATION);
+    queryStasticsWithLoadMetaData.addCountStatistic(QueryStatisticsConstants.LOAD_META, 3);
+    queryStasticsWithLoadMetaData.addStatistics(QueryStatisticsConstants.LOAD_META, 5);
+    queryStatisticList.add(queryStasticsWithLoadMetaData);
+    queryStasticsWithSQL_PARSE.addCountStatistic(QueryStatisticsConstants.SQL_PARSE, 3);
+    queryStasticsWithSQL_PARSE.addStatistics(QueryStatisticsConstants.SQL_PARSE, 5);
+    queryStatisticList.add(queryStasticsWithSQL_PARSE);
+
+    String result =
+        driverQueryStatisticsRecorderImpl.collectDriverStatistics(queryStatisticList, "query1");
+    assertNotNull(result);
+  }
+
+  @Test public void testCollectDriverStatisticsWithBlock_Allocation() {
+    queryStatisticList.clear();
+    queryStasticsWithBLOCK_ALLOCATION
+        .addCountStatistic(QueryStatisticsConstants.BLOCK_ALLOCATION, 3);
+    queryStasticsWithBLOCK_ALLOCATION.addStatistics(QueryStatisticsConstants.BLOCK_ALLOCATION, 5);
+    queryStatisticList.add(queryStasticsWithBLOCK_ALLOCATION);
+    String result =
+        driverQueryStatisticsRecorderImpl.collectDriverStatistics(queryStatisticList, "query1");
+    assertNull(result);
+  }
+
+  @Test public void testCollectDriverStatisticsWithBlock_AllocationAndBlock_Identification() {
+    queryStatisticList.clear();
+    queryStasticsWithBLOCK_ALLOCATION
+        .addCountStatistic(QueryStatisticsConstants.BLOCK_ALLOCATION, 3);
+    queryStasticsWithBLOCK_ALLOCATION.addStatistics(QueryStatisticsConstants.BLOCK_ALLOCATION, 5);
+    queryStatisticList.add(queryStasticsWithBLOCK_ALLOCATION);
+    queryStasticsWithBLOCK_IDENTIFICATION
+        .addCountStatistic(QueryStatisticsConstants.BLOCK_IDENTIFICATION, 3);
+    queryStasticsWithBLOCK_IDENTIFICATION
+        .addStatistics(QueryStatisticsConstants.BLOCK_IDENTIFICATION, 5);
+    queryStatisticList.add(queryStasticsWithBLOCK_IDENTIFICATION);
+    String result =
+        driverQueryStatisticsRecorderImpl.collectDriverStatistics(queryStatisticList, "query1");
+    assertNotNull(result);
+  }
+
+  @Test
+  public void testCollectDriverStatisticsWithBlock_AllocationAndBlock_IdentificationForException() {
+    queryStatisticList.clear();
+
+    driverQueryStatisticsRecorderImpl = DriverQueryStatisticsRecorderImpl.getInstance();
+
+    String result =
+        driverQueryStatisticsRecorderImpl.collectDriverStatistics(queryStatisticList, "query1");
+    assertNull(result);
+  }
+}
+

http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/952cf517/core/src/test/java/org/apache/carbondata/core/stats/QueryStasticsRecorderImplTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/carbondata/core/stats/QueryStasticsRecorderImplTest.java b/core/src/test/java/org/apache/carbondata/core/stats/QueryStasticsRecorderImplTest.java
new file mode 100644
index 0000000..ad5fd22
--- /dev/null
+++ b/core/src/test/java/org/apache/carbondata/core/stats/QueryStasticsRecorderImplTest.java
@@ -0,0 +1,114 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.carbondata.core.stats;
+
+import org.apache.carbondata.core.stats.QueryStatistic;
+import org.apache.carbondata.core.stats.QueryStatisticsConstants;
+import org.apache.carbondata.core.stats.QueryStatisticsRecorderImpl;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static junit.framework.TestCase.assertNotNull;
+
+public class QueryStasticsRecorderImplTest {
+
+  private static QueryStatisticsRecorderImpl queryStasticsRecorderImpl = null;
+  private static QueryStatistic queryStatistic = null;
+  private static QueryStatistic queryStatisticWithLOAD_BLOCKS_EXECUTOR = null;
+  private static QueryStatistic queryStatisticWithSCAN_BLOCKS_TIME = null;
+  private static QueryStatistic queryStatisticWithSCAN_BLOCKS_NUM = null;
+  private static QueryStatistic queryStatisticWithLOAD_DICTIONARY = null;
+  private static QueryStatistic queryStatisticWithRESULT_SIZE = null;
+  private static QueryStatistic queryStatisticWithEXECUTOR_PART = null;
+  private static QueryStatistic queryStatisticWithTOTAL_BLOCKLET_NUM = null;
+  private static QueryStatistic queryStatisticWithVALID_SCAN_BLOCKLET_NUM = null;
+
+  @BeforeClass public static void setUp() {
+    queryStatisticWithLOAD_BLOCKS_EXECUTOR = new QueryStatistic();
+    queryStasticsRecorderImpl = new QueryStatisticsRecorderImpl(System.nanoTime() + "");
+    queryStasticsRecorderImpl.logStatisticsAsTableDriver();
+    queryStatisticWithLOAD_BLOCKS_EXECUTOR
+        .addStatistics(QueryStatisticsConstants.LOAD_BLOCKS_EXECUTOR, 5L);
+    queryStatisticWithLOAD_BLOCKS_EXECUTOR
+        .addCountStatistic(QueryStatisticsConstants.LOAD_BLOCKS_EXECUTOR, 5L);
+    queryStatisticWithLOAD_BLOCKS_EXECUTOR
+        .addStatistics(QueryStatisticsConstants.LOAD_BLOCKS_EXECUTOR, 5L);
+    queryStasticsRecorderImpl.logStatistics();
+    queryStasticsRecorderImpl.recordStatistics(queryStatisticWithLOAD_BLOCKS_EXECUTOR);
+    queryStatisticWithSCAN_BLOCKS_TIME = new QueryStatistic();
+    queryStatisticWithSCAN_BLOCKS_TIME.addStatistics(QueryStatisticsConstants.SCAN_BLOCKS_TIME, 5L);
+    queryStatisticWithSCAN_BLOCKS_TIME
+        .addCountStatistic(QueryStatisticsConstants.SCAN_BLOCKS_TIME, 5L);
+    queryStatisticWithSCAN_BLOCKS_TIME.addStatistics(QueryStatisticsConstants.SCAN_BLOCKS_TIME, 5L);
+    queryStasticsRecorderImpl.logStatistics();
+    queryStasticsRecorderImpl.recordStatistics(queryStatisticWithSCAN_BLOCKS_TIME);
+    queryStatisticWithSCAN_BLOCKS_NUM = new QueryStatistic();
+    queryStatisticWithSCAN_BLOCKS_NUM.addStatistics(QueryStatisticsConstants.SCAN_BLOCKS_NUM, 5L);
+    queryStatisticWithSCAN_BLOCKS_NUM
+        .addCountStatistic(QueryStatisticsConstants.SCAN_BLOCKS_NUM, 5L);
+    queryStatisticWithSCAN_BLOCKS_NUM.addStatistics(QueryStatisticsConstants.SCAN_BLOCKS_NUM, 5L);
+    queryStasticsRecorderImpl.logStatistics();
+    queryStasticsRecorderImpl.recordStatistics(queryStatisticWithSCAN_BLOCKS_NUM);
+    queryStatisticWithLOAD_DICTIONARY = new QueryStatistic();
+    queryStatisticWithLOAD_DICTIONARY.addStatistics(QueryStatisticsConstants.LOAD_DICTIONARY, 5L);
+    queryStatisticWithLOAD_DICTIONARY
+        .addCountStatistic(QueryStatisticsConstants.LOAD_DICTIONARY, 5L);
+    queryStatisticWithLOAD_DICTIONARY.addStatistics(QueryStatisticsConstants.LOAD_DICTIONARY, 5L);
+    queryStasticsRecorderImpl.logStatistics();
+    queryStasticsRecorderImpl.recordStatistics(queryStatisticWithLOAD_DICTIONARY);
+    queryStatisticWithRESULT_SIZE = new QueryStatistic();
+    queryStatisticWithRESULT_SIZE.addStatistics(QueryStatisticsConstants.RESULT_SIZE, 5L);
+    queryStatisticWithRESULT_SIZE.addCountStatistic(QueryStatisticsConstants.RESULT_SIZE, 5L);
+    queryStatisticWithRESULT_SIZE.addStatistics(QueryStatisticsConstants.RESULT_SIZE, 5L);
+    queryStasticsRecorderImpl.logStatistics();
+    queryStasticsRecorderImpl.recordStatistics(queryStatisticWithRESULT_SIZE);
+    queryStatisticWithEXECUTOR_PART = new QueryStatistic();
+    queryStatisticWithEXECUTOR_PART.addStatistics(QueryStatisticsConstants.EXECUTOR_PART, 5L);
+    queryStatisticWithEXECUTOR_PART.addCountStatistic(QueryStatisticsConstants.EXECUTOR_PART, 5L);
+    queryStatisticWithEXECUTOR_PART.addStatistics(QueryStatisticsConstants.EXECUTOR_PART, 5L);
+    queryStasticsRecorderImpl.logStatistics();
+    queryStasticsRecorderImpl.recordStatistics(queryStatisticWithEXECUTOR_PART);
+    queryStatisticWithTOTAL_BLOCKLET_NUM = new QueryStatistic();
+    queryStatisticWithTOTAL_BLOCKLET_NUM
+        .addStatistics(QueryStatisticsConstants.TOTAL_BLOCKLET_NUM, 5L);
+    queryStatisticWithTOTAL_BLOCKLET_NUM
+        .addCountStatistic(QueryStatisticsConstants.TOTAL_BLOCKLET_NUM, 5L);
+    queryStatisticWithTOTAL_BLOCKLET_NUM
+        .addStatistics(QueryStatisticsConstants.TOTAL_BLOCKLET_NUM, 5L);
+    queryStasticsRecorderImpl.logStatistics();
+    queryStasticsRecorderImpl.recordStatistics(queryStatisticWithTOTAL_BLOCKLET_NUM);
+    queryStatisticWithVALID_SCAN_BLOCKLET_NUM = new QueryStatistic();
+    queryStatisticWithVALID_SCAN_BLOCKLET_NUM
+        .addStatistics(QueryStatisticsConstants.VALID_SCAN_BLOCKLET_NUM, 5L);
+    queryStatisticWithVALID_SCAN_BLOCKLET_NUM
+        .addCountStatistic(QueryStatisticsConstants.VALID_SCAN_BLOCKLET_NUM, 5L);
+    queryStatisticWithVALID_SCAN_BLOCKLET_NUM
+        .addStatistics(QueryStatisticsConstants.VALID_SCAN_BLOCKLET_NUM, 5L);
+    queryStasticsRecorderImpl.logStatistics();
+    queryStasticsRecorderImpl.recordStatistics(queryStatisticWithVALID_SCAN_BLOCKLET_NUM);
+    queryStasticsRecorderImpl.logStatisticsAsTableExecutor();
+  }
+
+  @Test public void testcollectExecutorStatistics() {
+    assertNotNull(queryStasticsRecorderImpl.collectExecutorStatistics());
+  }
+
+}

http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/952cf517/core/src/test/java/org/apache/carbondata/core/util/CarbonMetadataUtilTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/carbondata/core/util/CarbonMetadataUtilTest.java b/core/src/test/java/org/apache/carbondata/core/util/CarbonMetadataUtilTest.java
index d8b0f40..5855262 100644
--- a/core/src/test/java/org/apache/carbondata/core/util/CarbonMetadataUtilTest.java
+++ b/core/src/test/java/org/apache/carbondata/core/util/CarbonMetadataUtilTest.java
@@ -24,7 +24,7 @@ import mockit.MockUp;
 
 import org.apache.carbondata.core.datastore.block.SegmentProperties;
 import org.apache.carbondata.core.metadata.index.BlockIndexInfo;
-import org.apache.carbondata.core.datastorage.store.compression.WriterCompressModel;
+import org.apache.carbondata.core.datastorage.compression.WriterCompressModel;
 import org.apache.carbondata.core.metadata.BlockletInfoColumnar;
 import org.apache.carbondata.core.metadata.ValueEncoderMeta;
 import org.apache.carbondata.format.*;

http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/952cf517/core/src/test/java/org/apache/carbondata/core/util/CarbonUtilTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/carbondata/core/util/CarbonUtilTest.java b/core/src/test/java/org/apache/carbondata/core/util/CarbonUtilTest.java
index 2643758..7f6edd1 100644
--- a/core/src/test/java/org/apache/carbondata/core/util/CarbonUtilTest.java
+++ b/core/src/test/java/org/apache/carbondata/core/util/CarbonUtilTest.java
@@ -31,12 +31,12 @@ import org.apache.carbondata.core.metadata.Encoding;
 import org.apache.carbondata.core.metadata.schema.table.column.CarbonDimension;
 import org.apache.carbondata.core.metadata.schema.table.column.CarbonMeasure;
 import org.apache.carbondata.core.metadata.schema.table.column.ColumnSchema;
-import org.apache.carbondata.core.datastorage.store.columnar.ColumnGroupModel;
-import org.apache.carbondata.core.datastorage.store.compression.WriterCompressModel;
-import org.apache.carbondata.core.datastorage.store.filesystem.LocalCarbonFile;
-import org.apache.carbondata.core.datastorage.store.impl.FileFactory;
+import org.apache.carbondata.core.datastorage.columnar.ColumnGroupModel;
+import org.apache.carbondata.core.datastorage.compression.WriterCompressModel;
+import org.apache.carbondata.core.datastorage.filesystem.LocalCarbonFile;
+import org.apache.carbondata.core.datastorage.impl.FileFactory;
 import org.apache.carbondata.core.metadata.ValueEncoderMeta;
-import org.apache.carbondata.scan.model.QueryDimension;
+import org.apache.carbondata.core.scan.model.QueryDimension;
 
 import org.apache.hadoop.security.UserGroupInformation;
 import org.junit.AfterClass;

http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/952cf517/core/src/test/java/org/apache/carbondata/core/util/DataFileFooterConverterTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/carbondata/core/util/DataFileFooterConverterTest.java b/core/src/test/java/org/apache/carbondata/core/util/DataFileFooterConverterTest.java
index 1a1b5c8..f1ee0a0 100644
--- a/core/src/test/java/org/apache/carbondata/core/util/DataFileFooterConverterTest.java
+++ b/core/src/test/java/org/apache/carbondata/core/util/DataFileFooterConverterTest.java
@@ -26,9 +26,9 @@ import org.apache.carbondata.core.ColumnarFormatVersion;
 import org.apache.carbondata.core.datastore.block.TableBlockInfo;
 import org.apache.carbondata.core.metadata.blocklet.DataFileFooter;
 import org.apache.carbondata.core.metadata.blocklet.SegmentInfo;
-import org.apache.carbondata.core.datastorage.store.FileHolder;
-import org.apache.carbondata.core.datastorage.store.impl.FileFactory;
-import org.apache.carbondata.core.datastorage.store.impl.FileHolderImpl;
+import org.apache.carbondata.core.datastorage.FileHolder;
+import org.apache.carbondata.core.datastorage.impl.FileFactory;
+import org.apache.carbondata.core.datastorage.impl.FileHolderImpl;
 import org.apache.carbondata.core.reader.CarbonFooterReader;
 import org.apache.carbondata.core.reader.CarbonIndexFileReader;
 import org.apache.carbondata.core.reader.ThriftReader;

http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/952cf517/core/src/test/java/org/apache/carbondata/core/util/ValueCompressionUtilTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/carbondata/core/util/ValueCompressionUtilTest.java b/core/src/test/java/org/apache/carbondata/core/util/ValueCompressionUtilTest.java
index 6772c9d..17fe306 100644
--- a/core/src/test/java/org/apache/carbondata/core/util/ValueCompressionUtilTest.java
+++ b/core/src/test/java/org/apache/carbondata/core/util/ValueCompressionUtilTest.java
@@ -23,12 +23,29 @@ import static org.junit.Assert.assertTrue;
 
 import java.nio.ByteBuffer;
 
-import org.apache.carbondata.core.datastorage.store.compression.MeasureMetaDataModel;
-import org.apache.carbondata.core.datastorage.store.compression.WriterCompressModel;
-import org.apache.carbondata.core.datastorage.store.compression.ValueCompressionHolder;
-import org.apache.carbondata.core.datastorage.store.compression.decimal.*;
-import org.apache.carbondata.core.datastorage.store.compression.nondecimal.*;
-import org.apache.carbondata.core.datastorage.store.compression.none.*;
+import org.apache.carbondata.core.datastorage.compression.MeasureMetaDataModel;
+import org.apache.carbondata.core.datastorage.compression.WriterCompressModel;
+import org.apache.carbondata.core.datastorage.compression.ValueCompressionHolder;
+import org.apache.carbondata.core.datastorage.compression.decimal.CompressionMaxMinByte;
+import org.apache.carbondata.core.datastorage.compression.decimal.CompressionMaxMinDefault;
+import org.apache.carbondata.core.datastorage.compression.decimal.CompressionMaxMinInt;
+import org.apache.carbondata.core.datastorage.compression.decimal.CompressionMaxMinLong;
+import org.apache.carbondata.core.datastorage.compression.decimal.CompressionMaxMinShort;
+import org.apache.carbondata.core.datastorage.compression.nondecimal.CompressionNonDecimalByte;
+import org.apache.carbondata.core.datastorage.compression.nondecimal.CompressionNonDecimalDefault;
+import org.apache.carbondata.core.datastorage.compression.nondecimal.CompressionNonDecimalInt;
+import org.apache.carbondata.core.datastorage.compression.nondecimal.CompressionNonDecimalLong;
+import org.apache.carbondata.core.datastorage.compression.nondecimal.CompressionNonDecimalMaxMinByte;
+import org.apache.carbondata.core.datastorage.compression.nondecimal.CompressionNonDecimalMaxMinDefault;
+import org.apache.carbondata.core.datastorage.compression.nondecimal.CompressionNonDecimalMaxMinInt;
+import org.apache.carbondata.core.datastorage.compression.nondecimal.CompressionNonDecimalMaxMinLong;
+import org.apache.carbondata.core.datastorage.compression.nondecimal.CompressionNonDecimalMaxMinShort;
+import org.apache.carbondata.core.datastorage.compression.nondecimal.CompressionNonDecimalShort;
+import org.apache.carbondata.core.datastorage.compression.none.CompressionNoneByte;
+import org.apache.carbondata.core.datastorage.compression.none.CompressionNoneDefault;
+import org.apache.carbondata.core.datastorage.compression.none.CompressionNoneInt;
+import org.apache.carbondata.core.datastorage.compression.none.CompressionNoneLong;
+import org.apache.carbondata.core.datastorage.compression.none.CompressionNoneShort;
 import org.apache.carbondata.core.util.ValueCompressionUtil.DataType;
 
 import org.junit.Test;

http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/952cf517/core/src/test/java/org/apache/carbondata/core/writer/CarbonDictionaryWriterImplTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/carbondata/core/writer/CarbonDictionaryWriterImplTest.java b/core/src/test/java/org/apache/carbondata/core/writer/CarbonDictionaryWriterImplTest.java
index ad0abd7..6037ee8 100644
--- a/core/src/test/java/org/apache/carbondata/core/writer/CarbonDictionaryWriterImplTest.java
+++ b/core/src/test/java/org/apache/carbondata/core/writer/CarbonDictionaryWriterImplTest.java
@@ -39,8 +39,8 @@ import org.apache.carbondata.core.ColumnIdentifier;
 import org.apache.carbondata.core.path.CarbonStorePath;
 import org.apache.carbondata.core.path.CarbonTablePath;
 import org.apache.carbondata.core.constants.CarbonCommonConstants;
-import org.apache.carbondata.core.datastorage.store.filesystem.CarbonFile;
-import org.apache.carbondata.core.datastorage.store.impl.FileFactory;
+import org.apache.carbondata.core.datastorage.filesystem.CarbonFile;
+import org.apache.carbondata.core.datastorage.impl.FileFactory;
 import org.apache.carbondata.core.reader.CarbonDictionaryColumnMetaChunk;
 import org.apache.carbondata.core.reader.CarbonDictionaryMetadataReaderImpl;
 import org.apache.carbondata.core.reader.CarbonDictionaryReaderImpl;

http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/952cf517/core/src/test/java/org/apache/carbondata/core/writer/CarbonFooterWriterTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/carbondata/core/writer/CarbonFooterWriterTest.java b/core/src/test/java/org/apache/carbondata/core/writer/CarbonFooterWriterTest.java
index b8fd0b8..0036265 100644
--- a/core/src/test/java/org/apache/carbondata/core/writer/CarbonFooterWriterTest.java
+++ b/core/src/test/java/org/apache/carbondata/core/writer/CarbonFooterWriterTest.java
@@ -30,9 +30,9 @@ import org.apache.carbondata.core.datastore.block.SegmentProperties;
 import org.apache.carbondata.core.metadata.DataType;
 import org.apache.carbondata.core.metadata.Encoding;
 import org.apache.carbondata.core.constants.CarbonCommonConstants;
-import org.apache.carbondata.core.datastorage.store.compression.WriterCompressModel;
-import org.apache.carbondata.core.datastorage.store.filesystem.CarbonFile;
-import org.apache.carbondata.core.datastorage.store.impl.FileFactory;
+import org.apache.carbondata.core.datastorage.compression.WriterCompressModel;
+import org.apache.carbondata.core.datastorage.filesystem.CarbonFile;
+import org.apache.carbondata.core.datastorage.impl.FileFactory;
 import org.apache.carbondata.core.metadata.BlockletInfoColumnar;
 import org.apache.carbondata.core.reader.CarbonFooterReader;
 import org.apache.carbondata.core.util.CarbonMetadataUtil;

http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/952cf517/core/src/test/java/org/apache/carbondata/scan/collector/impl/DictionaryBasedResultCollectorTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/carbondata/scan/collector/impl/DictionaryBasedResultCollectorTest.java b/core/src/test/java/org/apache/carbondata/scan/collector/impl/DictionaryBasedResultCollectorTest.java
deleted file mode 100644
index 1ae04c5..0000000
--- a/core/src/test/java/org/apache/carbondata/scan/collector/impl/DictionaryBasedResultCollectorTest.java
+++ /dev/null
@@ -1,154 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-package org.apache.carbondata.scan.collector.impl;
-
-
-public class DictionaryBasedResultCollectorTest {
-
-//  private static DictionaryBasedResultCollector dictionaryBasedResultCollector;
-//  private static BlockExecutionInfo blockExecutionInfo;
-//
-//  @BeforeClass public static void setUp() {
-//    blockExecutionInfo = new BlockExecutionInfo();
-//    KeyStructureInfo keyStructureInfo = new KeyStructureInfo();
-//    blockExecutionInfo.setKeyStructureInfo(keyStructureInfo);
-//    AggregatorInfo aggregatorInfo = new AggregatorInfo();
-//    aggregatorInfo.setMeasureOrdinals(new int[] { 10, 20, 30, 40 });
-//    aggregatorInfo.setMeasureExists(new boolean[] { true, false, false, false });
-//    aggregatorInfo.setDefaultValues(new Object[] { 1, 2, 3, 4 });
-//    aggregatorInfo.setMeasureDataTypes(
-//        new DataType[] { DataType.INT, DataType.TIMESTAMP, DataType.INT, DataType.INT });
-//    blockExecutionInfo.setAggregatorInfo(aggregatorInfo);
-//    QueryDimension queryDimension1 = new QueryDimension("QDCol1");
-//    queryDimension1.setQueryOrder(1);
-//    ColumnSchema columnSchema = new ColumnSchema();
-//    queryDimension1.setDimension(new CarbonDimension(columnSchema, 0, 0, 0, 0));
-//    QueryDimension queryDimension2 = new QueryDimension("QDCol2");
-//    queryDimension2.setQueryOrder(2);
-//    queryDimension2.setDimension(new CarbonDimension(columnSchema, 1, 1, 1, 1));
-//    QueryDimension queryDimension3 = new QueryDimension("QDCol3");
-//    queryDimension3.setQueryOrder(3);
-//    queryDimension3.setDimension(new CarbonDimension(columnSchema, 2, 0, 0, 0));
-//    QueryDimension queryDimension4 = new QueryDimension("QDCol4");
-//    queryDimension4.setQueryOrder(4);
-//    queryDimension4.setDimension(new CarbonDimension(columnSchema, 3, 0, 0, 0));
-//    blockExecutionInfo.setQueryDimensions(
-//        new QueryDimension[] { queryDimension1, queryDimension2, queryDimension3,
-//            queryDimension4 });
-//    QueryMeasure queryMeasure1 = new QueryMeasure("QMCol1");
-//    queryMeasure1.setQueryOrder(1);
-//    QueryMeasure queryMeasure2 = new QueryMeasure("QMCol2");
-//    queryMeasure1.setQueryOrder(2);
-//    QueryMeasure queryMeasure3 = new QueryMeasure("QMCol3");
-//    queryMeasure1.setQueryOrder(3);
-//    QueryMeasure queryMeasure4 = new QueryMeasure("QMCol4");
-//    queryMeasure1.setQueryOrder(4);
-//    blockExecutionInfo.setQueryMeasures(
-//        new QueryMeasure[] { queryMeasure1, queryMeasure2, queryMeasure3, queryMeasure4 });
-//    Map<Integer, GenericQueryType> complexDimensionInfoMap = new HashMap<>();
-//    complexDimensionInfoMap.put(1, new ArrayQueryType("name1", "parent1", 1));
-//    complexDimensionInfoMap.put(2, new ArrayQueryType("name2", "parent2", 2));
-//    complexDimensionInfoMap.put(3, new ArrayQueryType("name3", "parent3", 3));
-//    complexDimensionInfoMap.put(4, new ArrayQueryType("name4", "parent4", 4));
-//    blockExecutionInfo.setComplexDimensionInfoMap(complexDimensionInfoMap);
-//    dictionaryBasedResultCollector = new DictionaryBasedResultCollector(blockExecutionInfo);
-//  }
-//
-//  @Test public void testToCollectData() {
-//    new MockUp<CarbonUtil>() {
-//      @SuppressWarnings("unused") @Mock boolean[] getDictionaryEncodingArray(
-//          QueryDimension[] queryDimensions) {
-//        return new boolean[] { true, false, true, true };
-//      }
-//
-//      @SuppressWarnings("unused") @Mock boolean[] getDirectDictionaryEncodingArray(
-//          QueryDimension[] queryDimensions) {
-//        return new boolean[] { true, true, false, false };
-//      }
-//
-//      @SuppressWarnings("unused") @Mock boolean[] getComplexDataTypeArray(
-//          QueryDimension[] queryDimensions) {
-//        return new boolean[] { false, false, true, false };
-//      }
-//    };
-//    new MockUp<DataTypeUtil>() {
-//      @SuppressWarnings("unused") @Mock Object getDataBasedOnDataType(String data,
-//          DataType actualDataType) {
-//        return 1;
-//      }
-//    };
-//
-//    new MockUp<NonFilterQueryScannedResult>() {
-//      @SuppressWarnings("unused") @Mock int[] getDictionaryKeyIntegerArray() {
-//        this.getMockInstance().incrementCounter();
-//        System.out.println("Mocked");
-//        return new int[] { 1, 2 };
-//      }
-//
-//      @SuppressWarnings("unused") @Mock String[] getNoDictionaryKeyStringArray() {
-//        return new String[] { "1", "2" };
-//      }
-//
-//      @SuppressWarnings("unused") @Mock byte[][] getComplexTypeKeyArray() {
-//        return new byte[][] { { 1, 2 }, { 1, 2 } };
-//      }
-//
-//      @SuppressWarnings("unused") @Mock public MeasureColumnDataChunk getMeasureChunk(int ordinal) {
-//        MeasureColumnDataChunk measureColumnDataChunk = new MeasureColumnDataChunk();
-//        PresenceMeta presenceMeta = new PresenceMeta();
-//        BitSet bitSet = new BitSet();
-//        bitSet.set(1);
-//        presenceMeta.setBitSet(bitSet);
-//        measureColumnDataChunk.setNullValueIndexHolder(presenceMeta);
-//        CarbonReadDataHolder carbonReadDataHolder = new CarbonReadDataHolder();
-//        carbonReadDataHolder.setReadableLongValues(new long[] { 1 });
-//        measureColumnDataChunk.setMeasureDataHolder(carbonReadDataHolder);
-//        return measureColumnDataChunk;
-//      }
-//    };
-//
-//    new MockUp<DirectDictionaryKeyGeneratorFactory>() {
-//      @SuppressWarnings("unused") @Mock DirectDictionaryGenerator getDirectDictionaryGenerator(
-//          DataType dataType) {
-//        if (dataType == DataType.TIMESTAMP) return new TimeStampDirectDictionaryGenerator(
-//            CarbonCommonConstants.CARBON_TIMESTAMP_DEFAULT_FORMAT);
-//        else return null;
-//      }
-//    };
-//    new MockUp<TimeStampDirectDictionaryGenerator>() {
-//      @SuppressWarnings("unused") @Mock Object getValueFromSurrogate(int key) {
-//        return 100L;
-//      }
-//    };
-//
-//    new MockUp<ArrayQueryType>() {
-//      @SuppressWarnings("unused") @Mock Object getDataBasedOnDataTypeFromSurrogates(
-//          ByteBuffer surrogateData) {
-//        return ByteBuffer.wrap("1".getBytes());
-//      }
-//    };
-//
-//    AbstractScannedResult abstractScannedResult =
-//        new NonFilterQueryScannedResult(blockExecutionInfo);
-//    abstractScannedResult.setNumberOfRows(2);
-//    List<Object[]> result = dictionaryBasedResultCollector.collectData(abstractScannedResult, 2);
-//    int expectedResult = 2;
-//    assertThat(result.size(), is(equalTo(expectedResult)));
-//  }
-}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/952cf517/core/src/test/java/org/apache/carbondata/scan/collector/impl/RawBasedResultCollectorTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/carbondata/scan/collector/impl/RawBasedResultCollectorTest.java b/core/src/test/java/org/apache/carbondata/scan/collector/impl/RawBasedResultCollectorTest.java
deleted file mode 100644
index a27da72..0000000
--- a/core/src/test/java/org/apache/carbondata/scan/collector/impl/RawBasedResultCollectorTest.java
+++ /dev/null
@@ -1,132 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-package org.apache.carbondata.scan.collector.impl;
-
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.MatcherAssert.assertThat;
-
-public class RawBasedResultCollectorTest {
-//
-//  private static RawBasedResultCollector rawBasedResultCollector;
-//  private static BlockExecutionInfo blockExecutionInfo;
-//  private static KeyGenerator keyGenerator;
-//
-//  @BeforeClass public static void setUp() {
-//    keyGenerator = new MockUp<KeyGenerator>() {
-//      @SuppressWarnings("unused") @Mock long[] getKeyArray(byte[] key, int[] maskedByteRanges) {
-//        return new long[] { 1, 2 };
-//      }
-//
-//      @SuppressWarnings("unused") @Mock byte[] generateKey(long[] keys) throws KeyGenException {
-//        return new byte[] { 1, 2 };
-//      }
-//
-//    }.getMockInstance();
-//
-//    blockExecutionInfo = new BlockExecutionInfo();
-//    KeyStructureInfo keyStructureInfo = new KeyStructureInfo();
-//    keyStructureInfo.setKeyGenerator(keyGenerator);
-//    keyStructureInfo.setMaxKey(new byte[] { 1, 2 });
-//    keyStructureInfo.setMaskedBytes(new int[] { 1, 2 });
-//    keyStructureInfo.setMaskByteRanges(new int[] { 1, 2 });
-//    blockExecutionInfo.setKeyStructureInfo(keyStructureInfo);
-//    AggregatorInfo aggregatorInfo = new AggregatorInfo();
-//    aggregatorInfo.setMeasureOrdinals(new int[] { 10, 20, 30, 40 });
-//    aggregatorInfo.setMeasureExists(new boolean[] { true, false, false, false });
-//    aggregatorInfo.setDefaultValues(new Object[] { 1, 2, 3, 4 });
-//    aggregatorInfo.setMeasureDataTypes(
-//        new DataType[] { DataType.INT, DataType.TIMESTAMP, DataType.INT, DataType.INT });
-//    QueryMeasure queryMeasure1 = new QueryMeasure("QMCol1");
-//    queryMeasure1.setQueryOrder(1);
-//    QueryMeasure queryMeasure2 = new QueryMeasure("QMCol2");
-//    queryMeasure1.setQueryOrder(2);
-//    QueryMeasure queryMeasure3 = new QueryMeasure("QMCol3");
-//    queryMeasure1.setQueryOrder(3);
-//    QueryMeasure queryMeasure4 = new QueryMeasure("QMCol4");
-//    queryMeasure1.setQueryOrder(4);
-//    QueryDimension queryDimension1 = new QueryDimension("QDCol1");
-//    queryDimension1.setQueryOrder(1);
-//    ColumnSchema columnSchema = new ColumnSchema();
-//    queryDimension1.setDimension(new CarbonDimension(columnSchema, 0, 0, 0, 0));
-//    QueryDimension queryDimension2 = new QueryDimension("QDCol2");
-//    queryDimension2.setQueryOrder(2);
-//    queryDimension2.setDimension(new CarbonDimension(columnSchema, 1, 1, 1, 1));
-//    QueryDimension queryDimension3 = new QueryDimension("QDCol3");
-//    queryDimension3.setQueryOrder(3);
-//    queryDimension3.setDimension(new CarbonDimension(columnSchema, 2, 0, 0, 0));
-//    QueryDimension queryDimension4 = new QueryDimension("QDCol4");
-//    queryDimension4.setQueryOrder(4);
-//    queryDimension4.setDimension(new CarbonDimension(columnSchema, 3, 0, 0, 0));
-//    blockExecutionInfo.setQueryDimensions(
-//        new QueryDimension[] { queryDimension1, queryDimension2, queryDimension3,
-//            queryDimension4 });
-//    blockExecutionInfo.setQueryMeasures(
-//        new QueryMeasure[] { queryMeasure1, queryMeasure2, queryMeasure3, queryMeasure4 });
-//    blockExecutionInfo.setFixedKeyUpdateRequired(true);
-//    blockExecutionInfo.setAggregatorInfo(aggregatorInfo);
-//    blockExecutionInfo.setMaskedByteForBlock(new int[] { 1, 2 });
-//    blockExecutionInfo.setBlockKeyGenerator(keyGenerator);
-//    rawBasedResultCollector = new RawBasedResultCollector(blockExecutionInfo);
-//  }
-//
-//  @Test public void testToCollectData() {
-//
-//    new MockUp<NonFilterQueryScannedResult>() {
-//      @SuppressWarnings("unused") @Mock byte[] getDictionaryKeyArray() {
-//        this.getMockInstance().incrementCounter();
-//        return new byte[] { 1, 2 };
-//      }
-//
-//      @SuppressWarnings("unused") @Mock byte[][] getNoDictionaryKeyArray() {
-//        return new byte[][] { { 1, 2 } };
-//      }
-//
-//      @SuppressWarnings("unused") @Mock byte[][] getComplexTypeKeyArray() {
-//        return new byte[][] { { 1, 2 }, { 1, 2 } };
-//      }
-//
-//      @SuppressWarnings("unused") @Mock public MeasureColumnDataChunk getMeasureChunk(int ordinal) {
-//        MeasureColumnDataChunk measureColumnDataChunk = new MeasureColumnDataChunk();
-//        PresenceMeta presenceMeta = new PresenceMeta();
-//        BitSet bitSet = new BitSet();
-//        bitSet.set(1);
-//        presenceMeta.setBitSet(bitSet);
-//        measureColumnDataChunk.setNullValueIndexHolder(presenceMeta);
-//        CarbonReadDataHolder carbonReadDataHolder = new CarbonReadDataHolder();
-//        carbonReadDataHolder.setReadableLongValues(new long[] { 1 });
-//        measureColumnDataChunk.setMeasureDataHolder(carbonReadDataHolder);
-//        return measureColumnDataChunk;
-//      }
-//    };
-//
-//    new MockUp<QueryUtil>() {
-//      @SuppressWarnings("unused") @Mock byte[] getMaskedKey(byte[] data, byte[] maxKey,
-//          int[] maskByteRanges, int byteCount) {
-//        return new byte[] { 1, 2 };
-//      }
-//    };
-//
-//    AbstractScannedResult abstractScannedResult =
-//        new NonFilterQueryScannedResult(blockExecutionInfo);
-//    abstractScannedResult.setNumberOfRows(2);
-//    List<Object[]> result = rawBasedResultCollector.collectData(abstractScannedResult, 2);
-//    int expectedResult = 2;
-//    assertThat(result.size(), is(equalTo(expectedResult)));
-//  }
-}

http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/952cf517/core/src/test/java/org/apache/carbondata/scan/complextypes/ArrayQueryTypeTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/carbondata/scan/complextypes/ArrayQueryTypeTest.java b/core/src/test/java/org/apache/carbondata/scan/complextypes/ArrayQueryTypeTest.java
deleted file mode 100644
index 8fc5484..0000000
--- a/core/src/test/java/org/apache/carbondata/scan/complextypes/ArrayQueryTypeTest.java
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-package org.apache.carbondata.scan.complextypes;
-
-import java.nio.ByteBuffer;
-
-import org.junit.BeforeClass;
-import org.junit.Test;
-
-import static org.pentaho.di.core.util.Assert.assertNotNull;
-import static org.pentaho.di.core.util.Assert.assertNull;
-
-public class ArrayQueryTypeTest {
-
-  private static ArrayQueryType arrayQueryType;
-
-  @BeforeClass public static void setUp() {
-    String name = "test";
-    String parentName = "testParent";
-    int blockIndex = 1;
-    arrayQueryType = new ArrayQueryType(name, parentName, blockIndex);
-  }
-
-  @Test public void testGetDataBasedOnDataTypeFromSurrogatesForNull() {
-    ByteBuffer surrogateData = ByteBuffer.allocate(10);
-    surrogateData.put(0, (byte) 0xFF);
-    surrogateData.put(1, (byte) 0xFF);
-    surrogateData.put(2, (byte) 0xFF);
-    surrogateData.put(3, (byte) 0xFF);
-    assertNull(arrayQueryType.getDataBasedOnDataTypeFromSurrogates(surrogateData));
-  }
-
-  @Test public void testGetDataBasedOnDataTypeFromSurrogates() {
-    ByteBuffer surrogateData = ByteBuffer.allocate(10);
-    surrogateData.put(3, (byte) 1);
-    arrayQueryType.setName("testName");
-    arrayQueryType.setParentname("testName");
-    arrayQueryType.addChildren(arrayQueryType);
-    assertNotNull(arrayQueryType.getDataBasedOnDataTypeFromSurrogates(surrogateData));
-  }
-}


Mime
View raw message