carbondata-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jack...@apache.org
Subject [08/57] [abbrv] incubator-carbondata git commit: move org.apache.carbon.common in core
Date Sat, 14 Jan 2017 07:57:17 GMT
http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/952cf517/core/src/test/java/org/apache/carbondata/core/scan/complextypes/PrimitiveQueryTypeTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/carbondata/core/scan/complextypes/PrimitiveQueryTypeTest.java b/core/src/test/java/org/apache/carbondata/core/scan/complextypes/PrimitiveQueryTypeTest.java
new file mode 100644
index 0000000..b8f484f
--- /dev/null
+++ b/core/src/test/java/org/apache/carbondata/core/scan/complextypes/PrimitiveQueryTypeTest.java
@@ -0,0 +1,127 @@
+/*
+ * 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.complextypes;
+
+import java.nio.ByteBuffer;
+
+import org.apache.carbondata.core.cache.dictionary.ColumnDictionaryInfo;
+import org.apache.carbondata.core.cache.dictionary.Dictionary;
+import org.apache.carbondata.core.cache.dictionary.ForwardDictionary;
+import org.apache.carbondata.core.metadata.DataType;
+import org.apache.carbondata.core.keygenerator.directdictionary.DirectDictionaryGenerator;
+import org.apache.carbondata.core.keygenerator.directdictionary.DirectDictionaryKeyGeneratorFactory;
+import org.apache.carbondata.core.keygenerator.mdkey.Bits;
+import org.apache.carbondata.core.util.DataTypeUtil;
+
+import mockit.Mock;
+import mockit.MockUp;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class PrimitiveQueryTypeTest {
+  private static PrimitiveQueryType primitiveQueryType, primitiveQueryTypeForInt,
+      primitiveQueryTypeForLong, primitiveQueryTypeForDouble, primitiveQueryTypeForBoolean,
+      primitiveQueryTypeForTimeStamp, primitiveQueryTypeForTimeStampForIsDictionaryFalse;
+  private static Dictionary dictionary;
+  private boolean isDirectDictionary = false;
+
+  @BeforeClass public static void setUp() {
+    String name = "test";
+    String parentName = "testParent";
+    int blockIndex = 1;
+    int keySize = 1;
+    boolean isDirectDictionary = true;
+    primitiveQueryType =
+        new PrimitiveQueryType(name, parentName, blockIndex, DataType.STRING, keySize, dictionary,
+            isDirectDictionary);
+    primitiveQueryTypeForInt =
+        new PrimitiveQueryType(name, parentName, blockIndex, DataType.INT, keySize, dictionary,
+            isDirectDictionary);
+    primitiveQueryTypeForDouble =
+        new PrimitiveQueryType(name, parentName, blockIndex, DataType.DOUBLE, keySize, dictionary,
+            isDirectDictionary);
+    primitiveQueryTypeForLong =
+        new PrimitiveQueryType(name, parentName, blockIndex, DataType.LONG, keySize, dictionary,
+            isDirectDictionary);
+    primitiveQueryTypeForBoolean =
+        new PrimitiveQueryType(name, parentName, blockIndex, DataType.BOOLEAN, keySize, dictionary,
+            isDirectDictionary);
+    primitiveQueryTypeForTimeStamp =
+        new PrimitiveQueryType(name, parentName, blockIndex, DataType.TIMESTAMP, keySize,
+            dictionary, isDirectDictionary);
+    ColumnDictionaryInfo columnDictionaryInfo = new ColumnDictionaryInfo(DataType.STRING);
+    ForwardDictionary forwardDictionary = new ForwardDictionary(columnDictionaryInfo);
+    primitiveQueryTypeForTimeStampForIsDictionaryFalse =
+        new PrimitiveQueryType(name, parentName, blockIndex, DataType.TIMESTAMP, keySize,
+            forwardDictionary, false);
+
+  }
+
+  @Test public void testGetDataBasedOnDataTypeFromSurrogates() {
+    ByteBuffer surrogateData = ByteBuffer.allocate(10);
+    surrogateData.put(3, (byte) 1);
+    new MockUp<Bits>() {
+      @Mock public long[] getKeyArray(byte[] key, int offset) {
+        return new long[] { 1313045L };
+      }
+    };
+    Object expectedValue = 1313043000000L;
+
+    Object actualValue =
+        primitiveQueryTypeForTimeStamp.getDataBasedOnDataTypeFromSurrogates(surrogateData);
+    assertEquals(expectedValue, actualValue);
+  }
+
+  @Test public void testGetDataBasedOnDataTypeFromSurrogatesWhenIsDictionaryFalse() {
+    ByteBuffer surrogateData = ByteBuffer.allocate(10);
+    surrogateData.put(3, (byte) 1);
+    new MockUp<ForwardDictionary>() {
+      @Mock public String getDictionaryValueForKey(int surrogateKey) {
+        return "2015-10-20 12:30:01";
+      }
+    };
+
+    Object expectedValue = primitiveQueryTypeForTimeStampForIsDictionaryFalse
+        .getDataBasedOnDataTypeFromSurrogates(surrogateData);
+    Object actualValue = primitiveQueryTypeForTimeStampForIsDictionaryFalse
+        .getDataBasedOnDataTypeFromSurrogates(surrogateData);
+    assertEquals(expectedValue, actualValue);
+  }
+
+  public Object getDataBasedOnDataTypeFromSurrogates(ByteBuffer surrogateData) {
+    int keySize = 2;
+    byte[] data = new byte[keySize];
+    surrogateData.get(data);
+    Bits bit = new Bits(new int[] { keySize * 8 });
+    int surrgateValue = (int) bit.getKeyArray(data, 0)[0];
+    Object actualData = null;
+    if (isDirectDictionary) {
+      DirectDictionaryGenerator directDictionaryGenerator =
+          DirectDictionaryKeyGeneratorFactory.getDirectDictionaryGenerator(DataType.TIMESTAMP);
+      actualData = directDictionaryGenerator.getValueFromSurrogate(surrgateValue);
+    } else {
+      String dictionaryValueForKey = dictionary.getDictionaryValueForKey(surrgateValue);
+      actualData = DataTypeUtil.getDataBasedOnDataType(dictionaryValueForKey, DataType.TIMESTAMP);
+    }
+    return actualData;
+  }
+
+}

http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/952cf517/core/src/test/java/org/apache/carbondata/core/scan/complextypes/StructQueryTypeTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/carbondata/core/scan/complextypes/StructQueryTypeTest.java b/core/src/test/java/org/apache/carbondata/core/scan/complextypes/StructQueryTypeTest.java
new file mode 100644
index 0000000..2a9d724
--- /dev/null
+++ b/core/src/test/java/org/apache/carbondata/core/scan/complextypes/StructQueryTypeTest.java
@@ -0,0 +1,69 @@
+/*
+ * 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.complextypes;
+
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.List;
+
+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.assertNotNull;
+
+public class StructQueryTypeTest {
+  private static StructQueryType structQueryType;
+  private static ArrayQueryType arrayQueryType;
+
+  @BeforeClass public static void setUp() {
+    String name = "testName";
+    String parentName = "testName";
+    int blockIndex = 5;
+    structQueryType = new StructQueryType(name, parentName, blockIndex);
+    arrayQueryType = new ArrayQueryType(name, parentName, blockIndex);
+  }
+
+  @Test public void testGetDataBasedOnDataTypeFromSurrogates() {
+    ByteBuffer surrogateData = ByteBuffer.allocate(10);
+    surrogateData.put(3, (byte) 1);
+    structQueryType.addChildren(arrayQueryType);
+    List children = new ArrayList();
+    children.add(arrayQueryType);
+    assertNotNull(structQueryType.getDataBasedOnDataTypeFromSurrogates(surrogateData));
+  }
+
+  @Test public void testGetColsCount() {
+    structQueryType.setName("testName");
+    structQueryType.setParentname("testName");
+    structQueryType.addChildren(arrayQueryType);
+    new MockUp<ArrayQueryType>() {
+      @Mock int getColsCount() {
+        return 1;
+      }
+    };
+    int actualValue = structQueryType.getColsCount();
+    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/executor/util/QueryUtilTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/carbondata/core/scan/executor/util/QueryUtilTest.java b/core/src/test/java/org/apache/carbondata/core/scan/executor/util/QueryUtilTest.java
new file mode 100644
index 0000000..00f05f4
--- /dev/null
+++ b/core/src/test/java/org/apache/carbondata/core/scan/executor/util/QueryUtilTest.java
@@ -0,0 +1,241 @@
+/*
+ * 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.executor.util;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.apache.carbondata.core.datastore.block.SegmentProperties;
+import org.apache.carbondata.core.datastore.block.SegmentPropertiesTestUtil;
+import org.apache.carbondata.core.keygenerator.KeyGenException;
+import org.apache.carbondata.core.scan.model.QueryDimension;
+
+import junit.framework.TestCase;
+import mockit.Mock;
+import mockit.MockUp;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertArrayEquals;
+
+public class QueryUtilTest extends TestCase {
+
+  private SegmentProperties segmentProperties;
+
+  @BeforeClass public void setUp() {
+    segmentProperties = SegmentPropertiesTestUtil.getSegmentProperties();
+  }
+
+  @Test public void testGetMaskedByteRangeGivingProperMaksedByteRange() {
+
+    QueryDimension dimension =
+        new QueryDimension(segmentProperties.getDimensions().get(0).getColName());
+    dimension.setDimension(segmentProperties.getDimensions().get(0));
+    int[] maskedByteRange = QueryUtil
+        .getMaskedByteRange(Arrays.asList(dimension), segmentProperties.getDimensionKeyGenerator());
+    int[] expectedMaskedByteRange = { 0 };
+    for (int i = 0; i < maskedByteRange.length; i++) {
+      assertEquals(expectedMaskedByteRange[i], maskedByteRange[i]);
+    }
+  }
+
+  @Test public void testGetMaskedByteRangeGivingProperMaksedByteRangeOnlyForDictionaryKey() {
+    List<QueryDimension> dimensions = new ArrayList<QueryDimension>();
+    for (int i = 0; i < 2; i++) {
+      QueryDimension dimension =
+          new QueryDimension(segmentProperties.getDimensions().get(i).getColName());
+      dimension.setDimension(segmentProperties.getDimensions().get(i));
+      dimensions.add(dimension);
+    }
+    int[] maskedByteRange =
+        QueryUtil.getMaskedByteRange(dimensions, segmentProperties.getDimensionKeyGenerator());
+    int[] expectedMaskedByteRange = { 0 };
+    for (int i = 0; i < maskedByteRange.length; i++) {
+      assertEquals(expectedMaskedByteRange[i], maskedByteRange[i]);
+    }
+  }
+
+  @Test public void testGetMaskedByteRangeBasedOrdinalGivingProperMaskedByte() {
+    List<Integer> dimensionOrdinal = new ArrayList<Integer>();
+    dimensionOrdinal.add(0);
+    int[] maskedByteRange = QueryUtil.getMaskedByteRangeBasedOrdinal(dimensionOrdinal,
+        segmentProperties.getDimensionKeyGenerator());
+    int[] expectedMaskedByteRange = { 0 };
+    for (int i = 0; i < maskedByteRange.length; i++) {
+      assertEquals(expectedMaskedByteRange[i], maskedByteRange[i]);
+    }
+  }
+
+  @Test public void testGetMaxKeyBasedOnDimensions() {
+    List<QueryDimension> dimensions = new ArrayList<QueryDimension>();
+    for (int i = 0; i < 2; i++) {
+      QueryDimension dimension =
+          new QueryDimension(segmentProperties.getDimensions().get(i).getColName());
+      dimension.setDimension(segmentProperties.getDimensions().get(i));
+      dimensions.add(dimension);
+    }
+    byte[] maxKeyBasedOnDimensions = null;
+    try {
+      maxKeyBasedOnDimensions = QueryUtil
+          .getMaxKeyBasedOnDimensions(dimensions, segmentProperties.getDimensionKeyGenerator());
+    } catch (KeyGenException e) {
+      assertTrue(false);
+    }
+    byte[] expectedMaxKeyBasedOnDimensions = { -1, 0, 0, 0, 0, 0 };
+    for (int i = 0; i < expectedMaxKeyBasedOnDimensions.length; i++) {
+      if (expectedMaxKeyBasedOnDimensions[i] != maxKeyBasedOnDimensions[i]) {
+        assertTrue(false);
+      }
+    }
+    long[] expectedKeyArray = { 255, 0, 0, 0, 0, 0 };
+    long[] keyArray =
+        segmentProperties.getDimensionKeyGenerator().getKeyArray(maxKeyBasedOnDimensions);
+    for (int i = 0; i < keyArray.length; i++) {
+      if (expectedKeyArray[i] != keyArray[i]) {
+        assertTrue(false);
+      }
+    }
+  }
+
+  @Test public void testGetMaksedByte() {
+    QueryDimension dimension =
+        new QueryDimension(segmentProperties.getDimensions().get(0).getColName());
+    dimension.setDimension(segmentProperties.getDimensions().get(0));
+    dimension.setDimension(segmentProperties.getDimensions().get(0));
+    int[] maskedByteRange = QueryUtil
+        .getMaskedByteRange(Arrays.asList(dimension), segmentProperties.getDimensionKeyGenerator());
+    int[] maskedByte = QueryUtil
+        .getMaskedByte(segmentProperties.getDimensionKeyGenerator().getDimCount(), maskedByteRange);
+    int[] expectedMaskedByte = { 0, -1, -1, -1, -1, -1 };
+
+    for (int i = 0; i < expectedMaskedByte.length; i++) {
+      if (expectedMaskedByte[i] != maskedByte[i]) {
+        assertTrue(false);
+      }
+    }
+  }
+
+  @Test public void testSearchInArrayWithSearchInputNotPresentInArray() {
+    int[] dummyArray = { 1, 2, 3, 4, 5 };
+    int searchInput = 6;
+    boolean result = QueryUtil.searchInArray(dummyArray, searchInput);
+    assert (!result);
+  }
+
+  @Test public void testSearchInArrayWithSearchInputPresentInArray() {
+    int[] dummyArray = { 1, 2, 3, 4, 5 };
+    int searchInput = 1;
+    boolean result = QueryUtil.searchInArray(dummyArray, searchInput);
+    assert (result);
+  }
+
+  @Test public void testGetColumnGroupIdWhenOrdinalValueNotPresentInArrayIndex() {
+    int ordinal = 0;
+    new MockUp<SegmentProperties>() {
+      @Mock public int[][] getColumnGroups() {
+        int columnGroups[][] = { { 1, 1 }, { 2, 2 }, { 3, 3 }, { 4, 4 }, { 5, 5 } };
+        return columnGroups;
+      }
+    };
+    int actualValue = QueryUtil.getColumnGroupId(segmentProperties, ordinal);
+    int expectedValue = 4; //expectedValue will always be arrayLength - 1
+    assertEquals(expectedValue, actualValue);
+  }
+
+  @Test public void testGetColumnGroupIdWhenOrdinalValuePresentInArrayIndex() {
+    int ordinal = 1;
+    new MockUp<SegmentProperties>() {
+      @Mock public int[][] getColumnGroups() {
+        int columnGroups[][] = { { 1, 1 }, { 2, 2 }, { 3, 3 }, { 4, 4 }, { 5, 5 } };
+        return columnGroups;
+      }
+    };
+    int actualValue = QueryUtil.getColumnGroupId(segmentProperties, ordinal);
+    int expectedValue = 0;
+    assertEquals(expectedValue, actualValue);
+  }
+
+  @Test public void testGetColumnGroupIdWhenColumnGroupsIndexValueLengthLessThanOne() {
+    int ordinal = 1;
+    new MockUp<SegmentProperties>() {
+      @Mock public int[][] getColumnGroups() {
+        int columnGroups[][] = { { 1 } };
+        return columnGroups;
+      }
+    };
+    int actualValue = QueryUtil.getColumnGroupId(segmentProperties, ordinal);
+    int expectedValue = -1;
+    assertEquals(expectedValue, actualValue);
+  }
+
+  @Test public void testGetMaskedKey() {
+    byte[] data = { 1, 2, 3, 4, 5, 5 };
+    byte[] maxKey = { 15, 20, 25, 30, 35, 35 };
+    int[] maskByteRanges = { 1, 2, 3, 4, 5 };
+    int byteCount = 5;
+    byte[] actualValue = QueryUtil.getMaskedKey(data, maxKey, maskByteRanges, byteCount);
+    byte[] expectedValue = { 0, 1, 4, 1, 1 };
+    assertArrayEquals(expectedValue, actualValue);
+  }
+
+  @Test public void testGetMaxKeyBasedOnOrinal() throws Exception {
+    List<Integer> dummyList = new ArrayList<>();
+    dummyList.add(0, 1);
+    dummyList.add(1, 2);
+    byte[] actualValue =
+        QueryUtil.getMaxKeyBasedOnOrinal(dummyList, segmentProperties.getDimensionKeyGenerator());
+    byte[] expectedValue = { 0, -1, -1, 0, 0, 0 };
+    assertArrayEquals(expectedValue, actualValue);
+  }
+
+  @Test public void testGetSortDimensionIndexes() {
+    List<QueryDimension> sortedDimensions = new ArrayList<QueryDimension>();
+    for (int i = 0; i < 2; i++) {
+      QueryDimension dimension =
+          new QueryDimension(segmentProperties.getDimensions().get(i).getColName());
+      dimension.setDimension(segmentProperties.getDimensions().get(i));
+      sortedDimensions.add(dimension);
+    }
+    List<QueryDimension> queryDimensions = new ArrayList<QueryDimension>();
+    for (int i = 0; i < 2; i++) {
+      QueryDimension dimension =
+          new QueryDimension(segmentProperties.getDimensions().get(i).getColName());
+      dimension.setDimension(segmentProperties.getDimensions().get(i));
+      queryDimensions.add(dimension);
+    }
+    byte[] actualValue = QueryUtil.getSortDimensionIndexes(sortedDimensions, queryDimensions);
+    byte[] expectedValue = { 0, 0 };
+    assertArrayEquals(expectedValue, actualValue);
+  }
+
+  @Test public void testGetActualTypeIndex() {
+    List<String> dummyList = new ArrayList<>();
+    dummyList.add("test1");
+    dummyList.add("test2");
+    int[] actualValue = QueryUtil.getActualTypeIndex(dummyList);
+    int[] expectedValue = { 0, 1 };
+    assertArrayEquals(expectedValue, actualValue);
+  }
+
+  @AfterClass public void tearDown() {
+    segmentProperties = null;
+  }
+}

http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/952cf517/core/src/test/java/org/apache/carbondata/core/scan/executor/util/RestructureUtilTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/carbondata/core/scan/executor/util/RestructureUtilTest.java b/core/src/test/java/org/apache/carbondata/core/scan/executor/util/RestructureUtilTest.java
new file mode 100644
index 0000000..ab17b43
--- /dev/null
+++ b/core/src/test/java/org/apache/carbondata/core/scan/executor/util/RestructureUtilTest.java
@@ -0,0 +1,115 @@
+/*
+ * 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.executor.util;
+
+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.scan.executor.infos.AggregatorInfo;
+import org.apache.carbondata.core.scan.model.QueryDimension;
+import org.apache.carbondata.core.scan.model.QueryMeasure;
+
+import org.junit.Test;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class RestructureUtilTest {
+
+  @Test public void testToGetUpdatedQueryDimension() {
+    List<Encoding> encodingList = new ArrayList<Encoding>();
+    encodingList.add(Encoding.DICTIONARY);
+    ColumnSchema columnSchema1 = new ColumnSchema();
+    columnSchema1.setColumnName("Id");
+    columnSchema1.setEncodingList(encodingList);
+    ColumnSchema columnSchema2 = new ColumnSchema();
+    columnSchema2.setColumnName("Name");
+    columnSchema2.setEncodingList(encodingList);
+    ColumnSchema columnSchema3 = new ColumnSchema();
+    columnSchema3.setColumnName("Age");
+    columnSchema3.setEncodingList(encodingList);
+    ColumnSchema columnSchema4 = new ColumnSchema();
+    columnSchema4.setColumnName("Salary");
+    columnSchema4.setEncodingList(encodingList);
+    ColumnSchema columnSchema5 = new ColumnSchema();
+    columnSchema5.setColumnName("Address");
+    columnSchema5.setEncodingList(encodingList);
+
+    CarbonDimension tableBlockDimension1 = new CarbonDimension(columnSchema1, 1, 1, 1, 1);
+    CarbonDimension tableBlockDimension2 = new CarbonDimension(columnSchema2, 5, 5, 5, 5);
+    List<CarbonDimension> tableBlockDimensions =
+        Arrays.asList(tableBlockDimension1, tableBlockDimension2);
+
+    CarbonDimension tableComplexDimension1 = new CarbonDimension(columnSchema3, 4, 4, 4, 4);
+    CarbonDimension tableComplexDimension2 = new CarbonDimension(columnSchema4, 2, 2, 2, 2);
+    List<CarbonDimension> tableComplexDimensions =
+        Arrays.asList(tableComplexDimension1, tableComplexDimension2);
+
+    QueryDimension queryDimension1 = new QueryDimension("Id");
+    queryDimension1.setDimension(tableBlockDimension1);
+    QueryDimension queryDimension2 = new QueryDimension("Name");
+    queryDimension2.setDimension(tableComplexDimension2);
+    QueryDimension queryDimension3 = new QueryDimension("Address");
+    queryDimension3.setDimension(new CarbonDimension(columnSchema5, 3, 3, 3, 3));
+
+    List<QueryDimension> queryDimensions =
+        Arrays.asList(queryDimension1, queryDimension2, queryDimension3);
+
+    List<QueryDimension> result = RestructureUtil
+        .getUpdatedQueryDimension(queryDimensions, tableBlockDimensions, tableComplexDimensions);
+
+    assertThat(result, is(equalTo(Arrays.asList(queryDimension1, queryDimension2))));
+  }
+
+  @Test public void testToGetAggregatorInfos() {
+    ColumnSchema columnSchema1 = new ColumnSchema();
+    columnSchema1.setColumnName("Id");
+    ColumnSchema columnSchema2 = new ColumnSchema();
+    columnSchema2.setColumnName("Name");
+    ColumnSchema columnSchema3 = new ColumnSchema();
+    columnSchema3.setColumnName("Age");
+
+    CarbonMeasure carbonMeasure1 = new CarbonMeasure(columnSchema1, 1);
+    CarbonMeasure carbonMeasure2 = new CarbonMeasure(columnSchema2, 2);
+    CarbonMeasure carbonMeasure3 = new CarbonMeasure(columnSchema3, 3);
+    carbonMeasure3.setDefaultValue("3".getBytes());
+    List<CarbonMeasure> currentBlockMeasures = Arrays.asList(carbonMeasure1, carbonMeasure2);
+
+    QueryMeasure queryMeasure1 = new QueryMeasure("Id");
+    queryMeasure1.setMeasure(carbonMeasure1);
+    QueryMeasure queryMeasure2 = new QueryMeasure("Name");
+    queryMeasure2.setMeasure(carbonMeasure2);
+    QueryMeasure queryMeasure3 = new QueryMeasure("Age");
+    queryMeasure3.setMeasure(carbonMeasure3);
+    List<QueryMeasure> queryMeasures = Arrays.asList(queryMeasure1, queryMeasure2, queryMeasure3);
+
+    AggregatorInfo aggregatorInfo =
+        RestructureUtil.getAggregatorInfos(queryMeasures, currentBlockMeasures);
+    boolean[] measuresExist = { true, true, false };
+    assertThat(aggregatorInfo.getMeasureExists(), is(equalTo(measuresExist)));
+    Object[] defaultValues = { null, null, "3".getBytes() };
+    assertThat(aggregatorInfo.getDefaultValues(), is(equalTo(defaultValues)));
+  }
+}

http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/952cf517/core/src/test/java/org/apache/carbondata/core/scan/expression/ColumnExpressionTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/carbondata/core/scan/expression/ColumnExpressionTest.java b/core/src/test/java/org/apache/carbondata/core/scan/expression/ColumnExpressionTest.java
new file mode 100644
index 0000000..3209991
--- /dev/null
+++ b/core/src/test/java/org/apache/carbondata/core/scan/expression/ColumnExpressionTest.java
@@ -0,0 +1,71 @@
+/*
+ * 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.expression;
+
+import org.apache.carbondata.core.metadata.DataType;
+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 org.junit.Assert.assertEquals;
+
+public class ColumnExpressionTest {
+
+  private ColumnExpression columnExpression;
+
+  @Before public void setUp() {
+    String columnName = "IMEI";
+    DataType dataType = DataType.STRING;
+    columnExpression = new ColumnExpression(columnName, dataType);
+  }
+
+  @Test public void testEvaluate() {
+    RowImpl rowImpl = new RowImpl();
+    rowImpl.setValues(new Integer[] { 1 });
+    new MockUp<RowImpl>() {
+      @Mock public Object getVal(int index) {
+        return 1;
+      }
+    };
+    ExpressionResult expectedValue = new ExpressionResult(DataType.INT, 1);
+    assertEquals(expectedValue, columnExpression.evaluate(rowImpl));
+  }
+
+  @Test public void testEvaluateForNullValue() {
+    RowImpl rowImpl = new RowImpl();
+    rowImpl.setValues(null);
+    new MockUp<RowImpl>() {
+      @Mock public Object getVal(int index) {
+        return null;
+      }
+    };
+    ExpressionResult expectedValue = new ExpressionResult(null);
+    assertEquals(expectedValue, columnExpression.evaluate(rowImpl));
+  }
+
+  @Test public void testGetString() {
+    String actualValue = columnExpression.getString();
+    String expectedValue = "ColumnExpression(IMEI)";
+    assertEquals(expectedValue, actualValue);
+  }
+}

http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/952cf517/core/src/test/java/org/apache/carbondata/core/scan/expression/ExpressionResultTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/carbondata/core/scan/expression/ExpressionResultTest.java b/core/src/test/java/org/apache/carbondata/core/scan/expression/ExpressionResultTest.java
new file mode 100644
index 0000000..8f0fa02
--- /dev/null
+++ b/core/src/test/java/org/apache/carbondata/core/scan/expression/ExpressionResultTest.java
@@ -0,0 +1,498 @@
+/*
+ * 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.expression;
+
+import java.math.BigDecimal;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+
+import org.apache.carbondata.core.metadata.DataType;
+import org.apache.carbondata.core.constants.CarbonCommonConstants;
+import org.apache.carbondata.core.scan.expression.exception.FilterIllegalMemberException;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static junit.framework.TestCase.assertTrue;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.core.IsEqual.equalTo;
+import static org.junit.Assert.assertEquals;
+import static org.pentaho.di.core.util.Assert.assertFalse;
+import static org.pentaho.di.core.util.Assert.assertNull;
+
+public class ExpressionResultTest {
+  private static final double DELTA = 1e-15;
+  private static ExpressionResult expressionResult;
+
+  @BeforeClass public static void setUp() {
+    expressionResult = new ExpressionResult(DataType.INT, null);
+  }
+
+  @Test public void testGetIntForNull() throws FilterIllegalMemberException {
+    assertNull(expressionResult.getInt());
+  }
+
+  @Test public void testGetIntForString() throws FilterIllegalMemberException {
+    ExpressionResult expressionResultForString = new ExpressionResult(DataType.STRING, "5");
+    int actualValue = expressionResultForString.getInt();
+    int expectedValue = 5;
+    assertEquals(expectedValue, actualValue);
+  }
+
+  @Test(expected = FilterIllegalMemberException.class)
+  public void testGetIntForNumberFormatException() throws FilterIllegalMemberException {
+    ExpressionResult expressionResultForString = new ExpressionResult(DataType.STRING, "FOOBAR");
+    expressionResultForString.getInt();
+  }
+
+  @Test public void testGetIntForDouble() throws FilterIllegalMemberException {
+    ExpressionResult expressionResultForDouble = new ExpressionResult(DataType.DOUBLE, 5.0);
+    int actualValue = expressionResultForDouble.getInt();
+    int expectedValue = 5;
+    assertEquals(expectedValue, actualValue);
+  }
+
+  @Test public void testGetIntForInt() throws FilterIllegalMemberException {
+    ExpressionResult expressionResultForInt = new ExpressionResult(DataType.INT, 5);
+    int actualValue = expressionResultForInt.getInt();
+    int expectedValue = 5;
+    assertEquals(expectedValue, actualValue);
+  }
+
+  @Test(expected = FilterIllegalMemberException.class)
+  public void testGetIntForIllegalMemberException() throws FilterIllegalMemberException {
+    ExpressionResult expressionResultForInt = new ExpressionResult(DataType.FLOAT, 25.36);
+    expressionResultForInt.getInt();
+  }
+
+  @Test(expected = FilterIllegalMemberException.class) public void testGetIntForClassCastException()
+      throws FilterIllegalMemberException {
+    ExpressionResult expressionResultForInt = new ExpressionResult(DataType.INT, "STRING");
+    expressionResultForInt.getInt();
+  }
+
+  @Test public void testGetShortForNull() throws FilterIllegalMemberException {
+    assertNull(expressionResult.getShort());
+  }
+
+  @Test public void testGetShortForString() throws FilterIllegalMemberException {
+    ExpressionResult expressionResultForString = new ExpressionResult(DataType.STRING, "5");
+    short actualValue = expressionResultForString.getShort();
+    short expectedValue = 5;
+    assertEquals(expectedValue, actualValue);
+  }
+
+  @Test(expected = FilterIllegalMemberException.class)
+  public void testGetShortForNumberFormatException() throws FilterIllegalMemberException {
+    ExpressionResult expressionResultForString = new ExpressionResult(DataType.STRING, "FOOBAR");
+    expressionResultForString.getShort();
+  }
+
+  @Test public void testGetShortForDouble() throws FilterIllegalMemberException {
+    ExpressionResult expressionResultForDouble = new ExpressionResult(DataType.DOUBLE, 5.0);
+    short actualValue = expressionResultForDouble.getShort();
+    short expectedValue = 5;
+    assertEquals(expectedValue, actualValue);
+  }
+
+  @Test public void testGetShortForInt() throws FilterIllegalMemberException {
+    ExpressionResult expressionResultForInt = new ExpressionResult(DataType.INT, 5);
+    short actualValue = expressionResultForInt.getShort();
+    short expectedValue = 5;
+    assertEquals(expectedValue, actualValue);
+  }
+
+  @Test(expected = FilterIllegalMemberException.class)
+  public void testGetShortForIllegalMemberException() throws FilterIllegalMemberException {
+    ExpressionResult expressionResultForInt = new ExpressionResult(DataType.FLOAT, 25.36);
+    expressionResultForInt.getShort();
+  }
+
+  @Test(expected = FilterIllegalMemberException.class)
+  public void testGetShortForClassCastException() throws FilterIllegalMemberException {
+    ExpressionResult expressionResultForInt = new ExpressionResult(DataType.INT, "STRING");
+    expressionResultForInt.getShort();
+  }
+
+  @Test public void testGetStringForNull() throws FilterIllegalMemberException {
+    assertNull(expressionResult.getString());
+  }
+
+  @Test public void testGetStringForString() throws FilterIllegalMemberException {
+    ExpressionResult expressionResultForString = new ExpressionResult(DataType.STRING, "5");
+    String actualValue = expressionResultForString.getString();
+    String expectedValue = "5";
+    assertEquals(expectedValue, actualValue);
+  }
+
+  @Test public void testGetStringForException() throws FilterIllegalMemberException {
+    ExpressionResult expressionResultForString = new ExpressionResult(DataType.INT, "5");
+    String actualValue = expressionResultForString.getString();
+    String expectedValue = "5";
+    assertEquals(expectedValue, actualValue);
+  }
+
+  @Test public void testGetDoubleForNull() throws FilterIllegalMemberException {
+    assertNull(expressionResult.getDouble());
+  }
+
+  @Test public void testGetDoubleForString() throws FilterIllegalMemberException {
+    ExpressionResult expressionResultForString = new ExpressionResult(DataType.STRING, "5");
+    double actualValue = expressionResultForString.getDouble();
+    double expectedValue = 5;
+    assertEquals(expectedValue, actualValue, DELTA);
+  }
+
+  @Test(expected = FilterIllegalMemberException.class)
+  public void testGetDoubleForNumberFormatException() throws FilterIllegalMemberException {
+    ExpressionResult expressionResultForString = new ExpressionResult(DataType.STRING, "FOOBAR");
+    expressionResultForString.getDouble();
+  }
+
+  @Test public void testGetDoubleForInt() throws FilterIllegalMemberException {
+    ExpressionResult expressionResultForDouble = new ExpressionResult(DataType.INT, 5);
+    double actualValue = expressionResultForDouble.getDouble();
+    double expectedValue = 5.0;
+    assertEquals(expectedValue, actualValue, DELTA);
+  }
+
+  @Test public void testGetDoubleForDouble() throws FilterIllegalMemberException {
+    ExpressionResult expressionResultForDouble = new ExpressionResult(DataType.DOUBLE, 5.0);
+    double actualValue = expressionResultForDouble.getDouble();
+    double expectedValue = 5;
+    assertEquals(expectedValue, actualValue, DELTA);
+  }
+
+  @Test(expected = FilterIllegalMemberException.class)
+  public void testGetDoubleForIllegalMemberException() throws FilterIllegalMemberException {
+    ExpressionResult expressionResultForDouble = new ExpressionResult(DataType.FLOAT, 25.36);
+    expressionResultForDouble.getDouble();
+  }
+
+  @Test(expected = FilterIllegalMemberException.class)
+  public void testGetDoubleForClassCastException() throws FilterIllegalMemberException {
+    ExpressionResult expressionResultForDouble = new ExpressionResult(DataType.DOUBLE, "STRING");
+    expressionResultForDouble.getDouble();
+  }
+
+  @Test public void testGetLongForNull() throws FilterIllegalMemberException {
+    assertNull(expressionResult.getLong());
+  }
+
+  @Test public void testGetLongForString() throws FilterIllegalMemberException {
+    ExpressionResult expressionResultForString = new ExpressionResult(DataType.STRING, "5");
+    long actualValue = expressionResultForString.getLong();
+    long expectedValue = 5;
+    assertEquals(expectedValue, actualValue);
+  }
+
+  @Test(expected = FilterIllegalMemberException.class)
+  public void testGetLongForNumberFormatException() throws FilterIllegalMemberException {
+    ExpressionResult expressionResultForString = new ExpressionResult(DataType.STRING, "FOOBAR");
+    expressionResultForString.getLong();
+  }
+
+  @Test(expected = FilterIllegalMemberException.class)
+  public void testGetLongForIllegalMemberException() throws FilterIllegalMemberException {
+    ExpressionResult expressionResultForLong = new ExpressionResult(DataType.FLOAT, 25.36);
+    expressionResultForLong.getLong();
+  }
+
+  @Test(expected = FilterIllegalMemberException.class)
+  public void testGetLongForClassCastException() throws FilterIllegalMemberException {
+    ExpressionResult expressionResultForLong = new ExpressionResult(DataType.LONG, "STRING");
+    expressionResultForLong.getLong();
+  }
+
+  @Test public void testGetDecimalForNull() throws FilterIllegalMemberException {
+    assertNull(expressionResult.getDecimal());
+  }
+
+  @Test public void testGetDecimalForString() throws FilterIllegalMemberException {
+    ExpressionResult expressionResultForString = new ExpressionResult(DataType.STRING, "5");
+    BigDecimal actualValue = expressionResultForString.getDecimal();
+    BigDecimal expectedValue = new BigDecimal(5.00);
+    assertEquals(expectedValue, actualValue);
+  }
+
+  @Test(expected = FilterIllegalMemberException.class)
+  public void testGetDecimalForNumberFormatException() throws FilterIllegalMemberException {
+    ExpressionResult expressionResultForString = new ExpressionResult(DataType.STRING, "FOOBAR");
+    expressionResultForString.getDecimal();
+  }
+
+  @Test public void testGetDecimalForInt() throws FilterIllegalMemberException {
+    ExpressionResult expressionResultForInt = new ExpressionResult(DataType.INT, 5);
+    BigDecimal actualValue = expressionResultForInt.getDecimal();
+    BigDecimal expectedValue = new BigDecimal(5);
+    assertEquals(expectedValue, actualValue);
+  }
+
+  @Test public void testGetDecimalForDouble() throws FilterIllegalMemberException {
+    ExpressionResult expressionResultForDouble = new ExpressionResult(DataType.DOUBLE, 5);
+    BigDecimal actualValue = expressionResultForDouble.getDecimal();
+    BigDecimal expectedValue = new BigDecimal(5);
+    assertEquals(expectedValue, actualValue);
+  }
+
+  @Test public void testGetDecimalForDecimal() throws FilterIllegalMemberException {
+    ExpressionResult expressionResultForDecimal = new ExpressionResult(DataType.DECIMAL, 5);
+    BigDecimal actualValue = expressionResultForDecimal.getDecimal();
+    BigDecimal expectedValue = new BigDecimal(5);
+    assertEquals(expectedValue, actualValue);
+  }
+
+  @Test(expected = FilterIllegalMemberException.class)
+  public void testGetDecimalForIllegalMemberException() throws FilterIllegalMemberException {
+    ExpressionResult expressionResultForFloat = new ExpressionResult(DataType.FLOAT, 25.36);
+    expressionResultForFloat.getDecimal();
+  }
+
+  @Test(expected = FilterIllegalMemberException.class)
+  public void testGetDecimalForClassCastException() throws FilterIllegalMemberException {
+    ExpressionResult expressionResultForException = new ExpressionResult(DataType.LONG, "STRING");
+    expressionResultForException.getDecimal();
+  }
+
+  @Test public void testGetTimeForNull() throws FilterIllegalMemberException {
+    assertNull(expressionResult.getTime());
+  }
+
+  @Test public void testGetTimeForString() throws FilterIllegalMemberException {
+    ExpressionResult expressionResultForString =
+        new ExpressionResult(DataType.STRING, "2016-11-07 10:15:09");
+    long actualValue = expressionResultForString.getTime();
+    long expectedValue = getTime("2016-11-07 10:15:09");
+    assertEquals(expectedValue, actualValue);
+  }
+
+  public Long getTime(String value) throws FilterIllegalMemberException {
+    if (value == null) {
+      return null;
+    }
+    SimpleDateFormat parser =
+        new SimpleDateFormat(CarbonCommonConstants.CARBON_TIMESTAMP_DEFAULT_FORMAT);
+    Date dateToStr;
+    try {
+      dateToStr = parser.parse(value.toString());
+      return dateToStr.getTime();
+    } catch (ParseException e) {
+      throw new FilterIllegalMemberException("Cannot convert value to Time/Long type value");
+    }
+  }
+
+  @Test(expected = FilterIllegalMemberException.class) public void testGetTimeForParseException()
+      throws FilterIllegalMemberException {
+    ExpressionResult expressionResultForParseException =
+        new ExpressionResult(DataType.STRING, "FOOBAR");
+    expressionResultForParseException.getTime();
+  }
+
+  @Test(expected = FilterIllegalMemberException.class)
+  public void testGetTimeForIllegalMemberException() throws FilterIllegalMemberException {
+    ExpressionResult expressionResultForFloat = new ExpressionResult(DataType.FLOAT, 25.36);
+    expressionResultForFloat.getTime();
+  }
+
+  @Test(expected = FilterIllegalMemberException.class)
+  public void testGetTimeForClassCastException() throws FilterIllegalMemberException {
+    ExpressionResult expressionResultForException = new ExpressionResult(DataType.LONG, "STRING");
+    expressionResultForException.getTime();
+  }
+
+  @Test public void testGetBooleanForNull() throws FilterIllegalMemberException {
+    assertNull(expressionResult.getBoolean());
+  }
+
+  @Test public void testGetBooleanForString() throws FilterIllegalMemberException {
+    ExpressionResult expressionResultForString = new ExpressionResult(DataType.STRING, "true");
+    boolean actualValue = expressionResultForString.getBoolean();
+    boolean expectedValue = true;
+    assertEquals(expectedValue, actualValue);
+  }
+
+  @Test public void testGetBooleanForBoolean() throws FilterIllegalMemberException {
+    ExpressionResult expressionResultForString = new ExpressionResult(DataType.BOOLEAN, "true");
+    boolean actualValue = expressionResultForString.getBoolean();
+    boolean expectedValue = true;
+    assertEquals(expectedValue, actualValue);
+  }
+
+  @Test(expected = FilterIllegalMemberException.class)
+  public void testGetBooleanForIllegalMemberException() throws FilterIllegalMemberException {
+    ExpressionResult expressionResultForFloat = new ExpressionResult(DataType.FLOAT, 25.36);
+    expressionResultForFloat.getBoolean();
+  }
+
+  @Test public void testGetList() {
+    ExpressionResult obj = new ExpressionResult(DataType.STRING, "test");
+    List<ExpressionResult> actualValue = obj.getList();
+    List<ExpressionResult> expected = new ArrayList<>();
+    expected.add(0, obj);
+    assertEquals(expected, actualValue);
+  }
+
+  @Test public void testHashCode() {
+    ExpressionResult obj = new ExpressionResult(DataType.INT, 1);
+    int actualValue = obj.hashCode();
+    int expectedValue = 80;
+    assertEquals(expectedValue, actualValue);
+  }
+
+  @Test public void testHashCodeForNull() {
+    ExpressionResult obj = new ExpressionResult(null);
+    int actualValue = obj.hashCode();
+    int expectedValue = 31;
+    assertEquals(expectedValue, actualValue);
+  }
+
+  @Test public void testHashCodeForNul() {
+    ExpressionResult obj = new ExpressionResult(DataType.DOUBLE, null);
+    int actualValue = obj.hashCode();
+    int expectedValue = 31;
+    assertEquals(expectedValue, actualValue);
+  }
+
+  @Test public void testEqualsForObjNOtInstanceOfExpressionResult() {
+    ExpressionResult expressionResult = new ExpressionResult(DataType.INT, 5);
+    List obj = new ArrayList();
+    obj.add(0, 0);
+    obj.add(1, 1);
+    boolean result = expressionResult.equals(obj);
+    assertFalse(result);
+  }
+
+  @Test public void testEqualsForString() {
+    ExpressionResult expressionResult = new ExpressionResult(DataType.STRING, "5");
+    ExpressionResult objToCompare = new ExpressionResult(DataType.STRING, "6");
+    boolean result = expressionResult.equals(objToCompare);
+    assertFalse(result);
+  }
+
+  @Test public void testEqualsForShort() {
+    ExpressionResult expressionResult = new ExpressionResult(DataType.SHORT, 5);
+    ExpressionResult objToCompare = new ExpressionResult(DataType.SHORT, 6);
+    boolean result = expressionResult.equals(objToCompare);
+    assertFalse(result);
+  }
+
+  @Test public void testEqualsForInt() {
+    ExpressionResult expressionResult = new ExpressionResult(DataType.INT, 5);
+    ExpressionResult objToCompare = new ExpressionResult(DataType.INT, 6);
+    boolean result = expressionResult.equals(objToCompare);
+    assertFalse(result);
+  }
+
+  @Test public void testEqualsForDecimal() {
+    ExpressionResult expressionResult = new ExpressionResult(DataType.DECIMAL, 5);
+    ExpressionResult objToCompare = new ExpressionResult(DataType.DECIMAL, 6);
+    boolean result = expressionResult.equals(objToCompare);
+    assertFalse(result);
+  }
+
+  @Test public void testEqualsForDouble() {
+    ExpressionResult expressionResult = new ExpressionResult(DataType.DOUBLE, 5.89);
+    ExpressionResult objToCompare = new ExpressionResult(DataType.DOUBLE, 6.90);
+    boolean result = expressionResult.equals(objToCompare);
+    assertFalse(result);
+  }
+
+  @Test public void testEqualsForException() {
+    ExpressionResult expressionResult =
+        new ExpressionResult(DataType.TIMESTAMP, "2016-11-07 10:15:09");
+    ExpressionResult objToCompare = new ExpressionResult(DataType.DOUBLE, "2016-11-06 10:15:09");
+    boolean result = expressionResult.equals(objToCompare);
+    assertFalse(result);
+  }
+
+  @Test public void testEqualsForLongAndTimeStamp() {
+    ExpressionResult expressionResult =
+        new ExpressionResult(DataType.TIMESTAMP, new Long(11111111111111111L));
+    ExpressionResult objToCompare =
+        new ExpressionResult(DataType.LONG, new Long(11111111111111111L));
+    boolean result = expressionResult.equals(objToCompare);
+    assertTrue(result);
+  }
+
+  @Test public void compareToForInt() {
+    ExpressionResult obj = new ExpressionResult(DataType.INT, 5);
+    ExpressionResult expressionResult = new ExpressionResult(DataType.INT, 6);
+    int actualValue = expressionResult.compareTo(obj);
+    int expectedValue = 1;
+    assertEquals(expectedValue, actualValue);
+
+  }
+
+  @Test public void compareToForDecimal() {
+    ExpressionResult obj = new ExpressionResult(DataType.DECIMAL, 5);
+    ExpressionResult expressionResult = new ExpressionResult(DataType.DECIMAL, 6);
+    int actualValue = expressionResult.compareTo(obj);
+    int expectedValue = 1;
+    assertEquals(expectedValue, actualValue);
+  }
+
+  @Test public void compareToForException() {
+    ExpressionResult obj = new ExpressionResult(DataType.INT, 5);
+    ExpressionResult expressionResult = new ExpressionResult(DataType.DECIMAL, 6);
+    int actualValue = expressionResult.compareTo(obj);
+    int expectedValue = -1;
+    assertEquals(expectedValue, actualValue);
+  }
+
+  @Test public void compareToForTimestamp() {
+    ExpressionResult obj = new ExpressionResult(DataType.TIMESTAMP, "2016-11-07 10:15:09");
+    ExpressionResult expressionResult =
+        new ExpressionResult(DataType.TIMESTAMP, "2016-11-07 10:15:09");
+    int actualValue = expressionResult.compareTo(obj);
+    int expectedValue = 0;
+    assertEquals(expectedValue, actualValue);
+  }
+
+  @Test public void testGetListAsString() throws FilterIllegalMemberException {
+    ExpressionResult obj = new ExpressionResult(DataType.INT, 6);
+    List<String> actualValue = obj.getListAsString();
+    List<String> expectedValue = new ArrayList<>();
+    expectedValue.add("6");
+    assertThat(actualValue, is(equalTo(expectedValue)));
+  }
+
+  @Test public void compareToForString() {
+    ExpressionResult obj = new ExpressionResult(DataType.STRING, "2016");
+    ExpressionResult expressionResult = new ExpressionResult(DataType.STRING, "2016");
+    int actualValue = expressionResult.compareTo(obj);
+    int expectedValue = 0;
+    assertEquals(expectedValue, actualValue);
+  }
+
+  @Test public void testIsNullForNull() {
+    ExpressionResult obj = new ExpressionResult(DataType.STRING, null);
+    boolean actualValue = obj.isNull();
+    assertTrue(actualValue);
+  }
+
+  @Test public void testIsNullForNotNull() {
+    ExpressionResult obj = new ExpressionResult(DataType.STRING, "test");
+    boolean actualValue = obj.isNull();
+    assertFalse(actualValue);
+  }
+}

http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/952cf517/core/src/test/java/org/apache/carbondata/core/scan/expression/LiteralExpressionTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/carbondata/core/scan/expression/LiteralExpressionTest.java b/core/src/test/java/org/apache/carbondata/core/scan/expression/LiteralExpressionTest.java
new file mode 100644
index 0000000..00a2a18
--- /dev/null
+++ b/core/src/test/java/org/apache/carbondata/core/scan/expression/LiteralExpressionTest.java
@@ -0,0 +1,59 @@
+/*
+ * 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.expression;
+
+import org.apache.carbondata.core.metadata.DataType;
+import org.apache.carbondata.core.scan.filter.intf.RowImpl;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class LiteralExpressionTest {
+
+  private LiteralExpression literalExpression;
+
+  @Before public void setUp() {
+    String value = "testing";
+    literalExpression = new LiteralExpression(value, DataType.STRING);
+  }
+
+  @Test public void testEvaluate() {
+    RowImpl rowImpl = new RowImpl();
+    rowImpl.setValues(new String[] { "testing" });
+    ExpressionResult expectedResult = new ExpressionResult(DataType.STRING, "testing");
+    assertEquals(expectedResult, literalExpression.evaluate(rowImpl));
+  }
+
+  @Test public void testGetExpressionResult() {
+    RowImpl rowImpl = new RowImpl();
+    rowImpl.setValues(new String[] { "testing" });
+    literalExpression.evaluate(rowImpl);
+    ExpressionResult expectedResult = new ExpressionResult(DataType.STRING, "testing");
+    assertEquals(expectedResult, literalExpression.evaluate(rowImpl));
+  }
+
+  @Test public void testGetString() {
+    String actualValue = literalExpression.getString();
+    String expectedValue = "LiteralExpression(testing)";
+    assertEquals(expectedValue, actualValue);
+  }
+}

http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/952cf517/core/src/test/java/org/apache/carbondata/core/scan/expression/conditional/EqualToExpressionUnitTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/carbondata/core/scan/expression/conditional/EqualToExpressionUnitTest.java b/core/src/test/java/org/apache/carbondata/core/scan/expression/conditional/EqualToExpressionUnitTest.java
new file mode 100644
index 0000000..3893a07
--- /dev/null
+++ b/core/src/test/java/org/apache/carbondata/core/scan/expression/conditional/EqualToExpressionUnitTest.java
@@ -0,0 +1,315 @@
+/*
+ * 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.expression.conditional;
+
+import java.math.BigDecimal;
+import java.sql.Timestamp;
+import java.text.DateFormat;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+import org.apache.carbondata.core.metadata.DataType;
+import org.apache.carbondata.core.scan.expression.ColumnExpression;
+import org.apache.carbondata.core.scan.expression.ExpressionResult;
+import org.apache.carbondata.core.scan.expression.exception.FilterIllegalMemberException;
+import org.apache.carbondata.core.scan.expression.exception.FilterUnsupportedException;
+import org.apache.carbondata.core.scan.filter.intf.RowImpl;
+
+import mockit.Mock;
+import mockit.MockUp;
+import org.apache.spark.sql.types.Decimal;
+import org.junit.Test;
+
+import static junit.framework.Assert.assertEquals;
+import static junit.framework.Assert.assertTrue;
+import static org.junit.Assert.assertFalse;
+
+public class EqualToExpressionUnitTest {
+
+  static EqualToExpression equalToExpression;
+
+  @Test public void testForEqualToExpressionWithGetString() throws Exception {
+    ColumnExpression right = new ColumnExpression("name", DataType.STRING);
+    right.setColIndex(0);
+    equalToExpression = new EqualToExpression(right, right);
+    String expected_result = "EqualTo(ColumnExpression(name),ColumnExpression(name))";
+    String result = equalToExpression.getString();
+    assertEquals(expected_result, result);
+  }
+
+  @Test public void testEvaluateForEqualToExpressionWithShortDataType()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    ColumnExpression right = new ColumnExpression("id", DataType.SHORT);
+    right.setColIndex(0);
+    equalToExpression = new EqualToExpression(right, right);
+    RowImpl value = new RowImpl();
+    Short[] row = { 15 };
+    Object objectRow[] = { row };
+    value.setValues(objectRow);
+
+    new MockUp<ExpressionResult>() {
+      @Mock public Short getShort() {
+        return 15;
+      }
+    };
+
+    ExpressionResult result = equalToExpression.evaluate(value);
+    assertTrue(result.getBoolean());
+
+  }
+
+  @Test public void testEvaluateForEqualToExpressionWithStringDataType()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    ColumnExpression right = new ColumnExpression("name", DataType.STRING);
+    right.setColIndex(0);
+    equalToExpression = new EqualToExpression(right, right);
+    RowImpl value = new RowImpl();
+    String[] row = { "String1" };
+    Object objectRow[] = { row };
+    value.setValues(objectRow);
+
+    new MockUp<ExpressionResult>() {
+      @Mock public String getString() {
+        return "String1";
+      }
+    };
+
+    ExpressionResult result = equalToExpression.evaluate(value);
+    assertTrue(result.getBoolean());
+
+  }
+
+  @Test public void testEvaluateForEqualToExpressionWithIntDataType()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    ColumnExpression right = new ColumnExpression("number", DataType.INT);
+    right.setColIndex(0);
+    equalToExpression = new EqualToExpression(right, right);
+    RowImpl value = new RowImpl();
+    Integer[] row = { 14 };
+    Object objectRow[] = { row };
+    value.setValues(objectRow);
+
+    new MockUp<ExpressionResult>() {
+      @Mock public Integer getInt() {
+        return 14;
+      }
+    };
+
+    ExpressionResult result = equalToExpression.evaluate(value);
+    assertTrue(result.getBoolean());
+  }
+
+  @Test public void testEvaluateForEqualToExpressionWithDoubleDataType()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    ColumnExpression right = new ColumnExpression("contact", DataType.DOUBLE);
+    right.setColIndex(0);
+    equalToExpression = new EqualToExpression(right, right);
+    RowImpl value = new RowImpl();
+    Double[] row = { 44D };
+    Object objectRow[] = { row };
+    value.setValues(objectRow);
+
+    new MockUp<ExpressionResult>() {
+      @Mock public Double getDouble() {
+        return 44D;
+      }
+    };
+
+    ExpressionResult result = equalToExpression.evaluate(value);
+    assertTrue(result.getBoolean());
+  }
+
+  @Test public void testEvaluateForEqualToExpressionWithLongDataType()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    ColumnExpression right = new ColumnExpression("contact", DataType.LONG);
+    right.setColIndex(0);
+    equalToExpression = new EqualToExpression(right, right);
+    RowImpl value = new RowImpl();
+    Long[] row = { 1234567654321L };
+    Object objectRow[] = { row };
+    value.setValues(objectRow);
+
+    new MockUp<ExpressionResult>() {
+      @Mock public Long getLong() {
+        return 1234567654321L;
+      }
+    };
+
+    ExpressionResult result = equalToExpression.evaluate(value);
+    assertTrue(result.getBoolean());
+  }
+
+  @Test public void testEvaluateForEqualToExpressionWithTimestampDataType()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    try {
+      ColumnExpression right = new ColumnExpression("timestamp", DataType.TIMESTAMP);
+      right.setColIndex(0);
+      equalToExpression = new EqualToExpression(right, right);
+      RowImpl value = new RowImpl();
+      DateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy");
+      Date date = dateFormat.parse("23/09/2007");
+      long time = date.getTime();
+      Timestamp[] row = { new Timestamp(time) };
+      Object objectRow[] = { row };
+      value.setValues(objectRow);
+
+      new MockUp<ExpressionResult>() {
+        @Mock public Long getTime() {
+          return 18465213000000L;
+        }
+      };
+
+      ExpressionResult result = equalToExpression.evaluate(value);
+      assertTrue(result.getBoolean());
+    } catch (ParseException e) {
+      System.out.println("Error while parsing " + e.getMessage());
+    }
+  }
+
+  @Test(expected = FilterUnsupportedException.class) public void testForEqualToExpressionForDefaultCase()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    ColumnExpression right = new ColumnExpression("contact", DataType.BOOLEAN);
+    right.setColIndex(0);
+    equalToExpression = new EqualToExpression(right, right);
+    RowImpl value = new RowImpl();
+    Boolean[] row = { true };
+    Object objectRow[] = { row };
+    value.setValues(objectRow);
+    ExpressionResult result = equalToExpression.evaluate(value);
+  }
+
+  @Test public void testEvaluateForEqualToExpressionWithBooleanParameter()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    ColumnExpression right = new ColumnExpression("id", DataType.SHORT);
+    right.setColIndex(0);
+    equalToExpression = new EqualToExpression(right, right, true);
+    RowImpl value = new RowImpl();
+    Short[] row = { 15 };
+    Object objectRow[] = { row };
+    value.setValues(objectRow);
+
+    new MockUp<ExpressionResult>() {
+      @Mock public Short getShort() {
+        return 15;
+      }
+    };
+
+    ExpressionResult result = equalToExpression.evaluate(value);
+    assertTrue(result.getBoolean());
+
+  }
+
+  @Test public void testEvaluateForEqualToExpressionWithLeftAndRightDifferentDataType()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    ColumnExpression left = new ColumnExpression("name", DataType.STRING);
+    left.setColIndex(0);
+    ColumnExpression right = new ColumnExpression("number", DataType.INT);
+    right.setColIndex(0);
+    equalToExpression = new EqualToExpression(left, right);
+    RowImpl value = new RowImpl();
+    String[] row1 = { "String1" };
+    Integer[] row = { 14 };
+    Object objectRow[] = { row, row1 };
+    value.setValues(objectRow);
+
+    new MockUp<ExpressionResult>() {
+      @Mock public Integer getInt() {
+        return 14;
+      }
+    };
+
+    ExpressionResult result = equalToExpression.evaluate(value);
+    assertTrue(result.getBoolean());
+  }
+
+  @Test public void testEvaluateForEqualToExpressionWithIsNullReturnFalse()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    ColumnExpression right = new ColumnExpression("id", DataType.SHORT);
+    right.setColIndex(0);
+    equalToExpression = new EqualToExpression(right, right);
+    RowImpl value = new RowImpl();
+    Short[] row = { 15 };
+    Object objectRow[] = { row };
+    value.setValues(objectRow);
+
+    new MockUp<ExpressionResult>() {
+      @Mock public boolean isNull() {
+        return true;
+      }
+    };
+
+    new MockUp<ExpressionResult>() {
+      @Mock public Short getShort() {
+        return 15;
+      }
+    };
+
+    ExpressionResult result = equalToExpression.evaluate(value);
+    assertFalse(result.getBoolean());
+
+  }
+
+  @Test public void testEvaluateForEqualToExpressionWithNullWhileCreatingObject()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    ColumnExpression right = new ColumnExpression("id", DataType.SHORT);
+    right.setColIndex(0);
+    equalToExpression = new EqualToExpression(right, right, true);
+    RowImpl value = new RowImpl();
+    Short[] row = { 15 };
+    Object objectRow[] = { row };
+    value.setValues(objectRow);
+
+    new MockUp<ExpressionResult>() {
+      @Mock public boolean isNull() {
+        return true;
+      }
+    };
+
+    new MockUp<ExpressionResult>() {
+      @Mock public Short getShort() {
+        return 15;
+      }
+    };
+
+    ExpressionResult result = equalToExpression.evaluate(value);
+    assertEquals(DataType.BOOLEAN, result.getDataType());
+
+  }
+
+  @Test public void testEvaluateForEqualToExpressionWithDecimalDataType()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    ColumnExpression right = new ColumnExpression("contact", DataType.DECIMAL);
+    right.setColIndex(0);
+    equalToExpression = new EqualToExpression(right, right);
+    RowImpl value = new RowImpl();
+    Decimal[] row = new Decimal[] { Decimal.apply(12345.0) };
+    Object objectRow[] = { row };
+    value.setValues(objectRow);
+
+    new MockUp<ExpressionResult>() {
+      @Mock public BigDecimal getDecimal() {
+        return new BigDecimal(12345.0);
+      }
+    };
+
+    ExpressionResult result = equalToExpression.evaluate(value);
+    assertTrue(result.getBoolean());
+  }
+}

http://git-wip-us.apache.org/repos/asf/incubator-carbondata/blob/952cf517/core/src/test/java/org/apache/carbondata/core/scan/expression/conditional/GreaterThanEqualToExpressionUnitTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/carbondata/core/scan/expression/conditional/GreaterThanEqualToExpressionUnitTest.java b/core/src/test/java/org/apache/carbondata/core/scan/expression/conditional/GreaterThanEqualToExpressionUnitTest.java
new file mode 100644
index 0000000..88e3729
--- /dev/null
+++ b/core/src/test/java/org/apache/carbondata/core/scan/expression/conditional/GreaterThanEqualToExpressionUnitTest.java
@@ -0,0 +1,293 @@
+/*
+ * 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.expression.conditional;
+
+import java.math.BigDecimal;
+import java.sql.Timestamp;
+import java.text.DateFormat;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+import org.apache.carbondata.core.metadata.DataType;
+import org.apache.carbondata.core.scan.expression.ColumnExpression;
+import org.apache.carbondata.core.scan.expression.ExpressionResult;
+import org.apache.carbondata.core.scan.expression.exception.FilterIllegalMemberException;
+import org.apache.carbondata.core.scan.expression.exception.FilterUnsupportedException;
+import org.apache.carbondata.core.scan.filter.intf.RowImpl;
+
+import mockit.Mock;
+import mockit.MockUp;
+import org.apache.spark.sql.types.Decimal;
+import org.junit.Test;
+
+import static junit.framework.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+public class GreaterThanEqualToExpressionUnitTest {
+
+  static GreaterThanEqualToExpression greaterThanEqualToExpression;
+
+  @Test public void testEvaluateForGreaterThanEqualToExpressionWithBothStringISSame()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    ColumnExpression left = new ColumnExpression("left_name", DataType.STRING);
+    left.setColIndex(0);
+    ColumnExpression right = new ColumnExpression("right_name", DataType.STRING);
+    right.setColIndex(1);
+    greaterThanEqualToExpression = new GreaterThanEqualToExpression(left, right);
+    RowImpl value = new RowImpl();
+    String[] row = { "string1" };
+    String[] row1 = { "string1" };
+    Object objectRow[] = { row, row1 };
+
+    new MockUp<ExpressionResult>() {
+      @Mock public String getString() {
+        return "string1";
+      }
+    };
+    value.setValues(objectRow);
+    ExpressionResult result = greaterThanEqualToExpression.evaluate(value);
+    assertTrue(result.getBoolean());
+  }
+
+  @Test public void testEvaluateForGreaterThanEqualToExpressionWithShortDataType()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    ColumnExpression right = new ColumnExpression("id", DataType.SHORT);
+    right.setColIndex(0);
+    ColumnExpression left = new ColumnExpression("id", DataType.SHORT);
+    left.setColIndex(1);
+    greaterThanEqualToExpression = new GreaterThanEqualToExpression(left, right);
+    RowImpl value = new RowImpl();
+    Short[] row = { 15 };
+    Short[] row1 = { 16 };
+    Object objectRow[] = { row1, row };
+    value.setValues(objectRow);
+
+    new MockUp<ExpressionResult>() {
+      @Mock public Short getShort() {
+        return 16;
+      }
+    };
+
+    ExpressionResult result = greaterThanEqualToExpression.evaluate(value);
+    assertTrue(result.getBoolean());
+
+  }
+
+  @Test public void testEvaluateForGreaterThanEqualToExpressionWithIntDataType()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    ColumnExpression right = new ColumnExpression("right_number", DataType.INT);
+    right.setColIndex(0);
+    ColumnExpression left = new ColumnExpression("left_number", DataType.INT);
+    left.setColIndex(1);
+    greaterThanEqualToExpression = new GreaterThanEqualToExpression(left, right);
+    RowImpl value = new RowImpl();
+    Integer[] row = { 140 };
+    Integer[] row1 = { 145 };
+    Object objectRow[] = { row1, row };
+    value.setValues(objectRow);
+
+    new MockUp<ExpressionResult>() {
+      @Mock public Integer getInt() {
+        return 145;
+      }
+    };
+
+    ExpressionResult result = greaterThanEqualToExpression.evaluate(value);
+    assertTrue(result.getBoolean());
+  }
+
+  @Test public void testEvaluateForGreaterThanEqualToExpressionWithDoubleDataType()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    ColumnExpression right = new ColumnExpression("right_contact", DataType.DOUBLE);
+    right.setColIndex(0);
+    ColumnExpression left = new ColumnExpression("left_contact", DataType.DOUBLE);
+    left.setColIndex(1);
+    greaterThanEqualToExpression = new GreaterThanEqualToExpression(left, right);
+    RowImpl value = new RowImpl();
+    Double[] row = { 44D };
+    Double[] row1 = { 45D };
+    Object objectRow[] = { row1, row };
+    value.setValues(objectRow);
+
+    new MockUp<ExpressionResult>() {
+      @Mock public Double getDouble() {
+        return 45D;
+      }
+    };
+
+    ExpressionResult result = greaterThanEqualToExpression.evaluate(value);
+    assertTrue(result.getBoolean());
+  }
+
+  @Test public void testEvaluateForGreaterThanEqualToExpressionWithLongDataType()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    ColumnExpression right = new ColumnExpression("contact", DataType.LONG);
+    right.setColIndex(0);
+    ColumnExpression left = new ColumnExpression("contact", DataType.LONG);
+    left.setColIndex(1);
+    greaterThanEqualToExpression = new GreaterThanEqualToExpression(left, right);
+    RowImpl value = new RowImpl();
+    Long[] row = { 1234567654321L };
+    Long[] row1 = { 1234567654321L };
+    Object objectRow[] = { row1, row };
+    value.setValues(objectRow);
+
+    new MockUp<ExpressionResult>() {
+      @Mock public Long getLong() {
+        return 1234567654321L;
+      }
+    };
+
+    ExpressionResult result = greaterThanEqualToExpression.evaluate(value);
+    assertTrue(result.getBoolean());
+  }
+
+  @Test public void testEvaluateForGreaterThanEqualToExpressionWithTimestampDataType()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    try {
+      ColumnExpression left = new ColumnExpression("timestamp", DataType.TIMESTAMP);
+      left.setColIndex(0);
+      ColumnExpression right = new ColumnExpression("timestamp", DataType.TIMESTAMP);
+      right.setColIndex(1);
+      greaterThanEqualToExpression = new GreaterThanEqualToExpression(left, right);
+      RowImpl value = new RowImpl();
+      DateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy");
+      Date date = dateFormat.parse("23/09/2007");
+      long time = date.getTime();
+      Timestamp[] row = { new Timestamp(time) };
+      Timestamp[] row1 = { new Timestamp(time) };
+      Object objectRow[] = { row, row1 };
+      value.setValues(objectRow);
+
+      new MockUp<ExpressionResult>() {
+        @Mock public Long getTime() {
+          return 18465213000000L;
+        }
+      };
+
+      ExpressionResult result = greaterThanEqualToExpression.evaluate(value);
+      assertTrue(result.getBoolean());
+    } catch (ParseException e) {
+      System.out.println("Error while parsing " + e.getMessage());
+    }
+  }
+
+  @Test(expected = FilterUnsupportedException.class) public void testForGreaterThanEqualToExpressionWithDefaultCase()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    ColumnExpression right = new ColumnExpression("contact", DataType.BOOLEAN);
+    right.setColIndex(0);
+    ColumnExpression left = new ColumnExpression("contact", DataType.BOOLEAN);
+    left.setColIndex(1);
+    greaterThanEqualToExpression = new GreaterThanEqualToExpression(left, right);
+    RowImpl value = new RowImpl();
+    Boolean[] row = { true };
+    Object objectRow[] = { row, row };
+    value.setValues(objectRow);
+    greaterThanEqualToExpression.evaluate(value);
+  }
+
+  @Test public void testEvaluateForGreaterThanEqualToExpressionWithDecimalDataType()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    ColumnExpression right = new ColumnExpression("contact", DataType.DECIMAL);
+    right.setColIndex(0);
+    ColumnExpression left = new ColumnExpression("contact", DataType.DECIMAL);
+    left.setColIndex(1);
+    greaterThanEqualToExpression = new GreaterThanEqualToExpression(left, right);
+    RowImpl value = new RowImpl();
+    Decimal[] row = new Decimal[] { Decimal.apply(12345.0) };
+    Object objectRow[] = { row, row };
+    value.setValues(objectRow);
+
+    new MockUp<ExpressionResult>() {
+      @Mock public BigDecimal getDecimal() {
+        return new BigDecimal(12345.0);
+      }
+    };
+
+    ExpressionResult result = greaterThanEqualToExpression.evaluate(value);
+    assertTrue(result.getBoolean());
+  }
+
+  @Test public void testEvaluateForGreaterThanEqualToExpressionWithIsNullReturnTrue()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    ColumnExpression left = new ColumnExpression("id", DataType.SHORT);
+    left.setColIndex(0);
+    ColumnExpression right = new ColumnExpression("id", DataType.SHORT);
+    right.setColIndex(1);
+    greaterThanEqualToExpression = new GreaterThanEqualToExpression(left, right);
+    RowImpl value = new RowImpl();
+    Short[] row = { 15 };
+    Object objectRow[] = { row, row };
+    value.setValues(objectRow);
+
+    new MockUp<ExpressionResult>() {
+      @Mock public boolean isNull() {
+        return true;
+      }
+    };
+
+    new MockUp<ExpressionResult>() {
+      @Mock public Short getShort() {
+        return 15;
+      }
+    };
+
+    ExpressionResult result = greaterThanEqualToExpression.evaluate(value);
+    assertFalse(result.getBoolean());
+
+  }
+
+  @Test public void testEvaluateForGreaterThanEqualToExpressionWithLeftAndRightDifferentDataType()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    ColumnExpression left = new ColumnExpression("name", DataType.STRING);
+    left.setColIndex(1);
+    ColumnExpression right = new ColumnExpression("number", DataType.INT);
+    right.setColIndex(0);
+    greaterThanEqualToExpression = new GreaterThanEqualToExpression(left, right);
+    RowImpl value = new RowImpl();
+    String[] row1 = { "String1" };
+    Integer[] row = { 14 };
+    Object objectRow[] = { row, row1 };
+    value.setValues(objectRow);
+
+    new MockUp<ExpressionResult>() {
+      @Mock public Integer getInt() {
+        return 14;
+      }
+    };
+
+    ExpressionResult result = greaterThanEqualToExpression.evaluate(value);
+    assertTrue(result.getBoolean());
+  }
+
+  @Test public void testForGreaterThanEqualToExpressionWithGetString() throws Exception {
+    ColumnExpression left = new ColumnExpression("left_name", DataType.STRING);
+    left.setColIndex(0);
+    ColumnExpression right = new ColumnExpression("right_name", DataType.STRING);
+    right.setColIndex(1);
+    greaterThanEqualToExpression = new GreaterThanEqualToExpression(left, right);
+    String expected_result = "GreaterThanEqualTo(ColumnExpression(left_name),ColumnExpression(right_name))";
+    String result = greaterThanEqualToExpression.getString();
+    assertEquals(expected_result, result);
+  }
+
+}
+


Mime
View raw message