carbondata-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jack...@apache.org
Subject [06/50] [abbrv] carbondata git commit: [CARBONDATA-2720] Remove dead code
Date Wed, 18 Jul 2018 02:19:39 GMT
http://git-wip-us.apache.org/repos/asf/carbondata/blob/f9114036/core/src/test/java/org/apache/carbondata/core/scan/expression/conditional/GreaterThanExpressionUnitTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/carbondata/core/scan/expression/conditional/GreaterThanExpressionUnitTest.java b/core/src/test/java/org/apache/carbondata/core/scan/expression/conditional/GreaterThanExpressionUnitTest.java
index 38a7222..5391861 100644
--- a/core/src/test/java/org/apache/carbondata/core/scan/expression/conditional/GreaterThanExpressionUnitTest.java
+++ b/core/src/test/java/org/apache/carbondata/core/scan/expression/conditional/GreaterThanExpressionUnitTest.java
@@ -106,6 +106,40 @@ public class GreaterThanExpressionUnitTest {
 
   }
 
+  @Test public void testEvaluateForGreaterThanExpressionWithShortDataType1()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    ColumnExpression right = new ColumnExpression("id", DataTypes.SHORT);
+    right.setColIndex(0);
+    ColumnExpression left = new ColumnExpression("id", DataTypes.SHORT);
+    left.setColIndex(1);
+    greaterThanExpression = new GreaterThanExpression(left, right);
+    RowImpl value = new RowImpl();
+    Short[] row = { 170 };
+    Short[] row1 = { 70 };
+    Object objectRow[] = { row, row1 };
+    value.setValues(objectRow);
+
+    new MockUp<ExpressionResult>() {
+      Boolean returnMockFlag = true;
+
+      @Mock public Short getShort() {
+        if (returnMockFlag) {
+          returnMockFlag = false;
+          return 70;
+
+        } else {
+          return 170;
+
+        }
+
+      }
+    };
+
+    ExpressionResult result = greaterThanExpression.evaluate(value);
+    assertFalse(result.getBoolean());
+
+  }
+
   @Test public void testEvaluateForGreaterThanExpressionWithDoubleDataType()
       throws FilterUnsupportedException, FilterIllegalMemberException {
     ColumnExpression right = new ColumnExpression("right_contact", DataTypes.DOUBLE);
@@ -217,6 +251,51 @@ public class GreaterThanExpressionUnitTest {
     }
   }
 
+  @Test public void testEvaluateForGreaterThanExpressionWithTimestampDataType1()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    try {
+      ColumnExpression left = new ColumnExpression("timestamp", DataTypes.TIMESTAMP);
+      left.setColIndex(0);
+      ColumnExpression right = new ColumnExpression("timestamp", DataTypes.TIMESTAMP);
+      right.setColIndex(1);
+
+      greaterThanExpression = new GreaterThanExpression(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) };
+
+      Date date1 = dateFormat.parse("24/09/2007");
+      long time1 = date1.getTime();
+      Timestamp[] row1 = { new Timestamp(time1) };
+
+      Object objectRow[] = { row1, row };
+      value.setValues(objectRow);
+
+      new MockUp<ExpressionResult>() {
+        Boolean returnMockFlag = true;
+
+        @Mock public Long getTime() {
+          if (returnMockFlag) {
+            returnMockFlag = false;
+            return 1190505600L;
+          } else {
+            return 1190592000L;
+          }
+        }
+      };
+
+      ExpressionResult result = greaterThanExpression.evaluate(value);
+      assertFalse(result.getBoolean());
+    } catch (ParseException e) {
+      System.out.println("Error while parsing " + e.getMessage());
+    }
+  }
+
   @Test public void testEvaluateForGreaterThanExpressionWithLongDataType()
       throws FilterUnsupportedException, FilterIllegalMemberException {
     ColumnExpression right = new ColumnExpression("contact", DataTypes.LONG);
@@ -247,6 +326,36 @@ public class GreaterThanExpressionUnitTest {
     assertTrue(result.getBoolean());
   }
 
+  @Test public void testEvaluateForGreaterThanExpressionWithLongDataType1()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    ColumnExpression right = new ColumnExpression("contact", DataTypes.LONG);
+    right.setColIndex(0);
+    ColumnExpression left = new ColumnExpression("contact", DataTypes.LONG);
+    left.setColIndex(1);
+    greaterThanExpression = new GreaterThanExpression(left, right);
+    RowImpl value = new RowImpl();
+    Long[] row = { 1234567654321L };
+    Long[] row1 = { 123456765432234L };
+    Object objectRow[] = { row1, row };
+    value.setValues(objectRow);
+
+    new MockUp<ExpressionResult>() {
+      Boolean returnMockFlag = true;
+
+      @Mock public Long getLong() {
+        if (returnMockFlag) {
+          returnMockFlag = false;
+          return 1234567654321L;
+        } else {
+          return 123456765432234L;
+        }
+      }
+    };
+
+    ExpressionResult result = greaterThanExpression.evaluate(value);
+    assertFalse(result.getBoolean());
+  }
+
   @Test public void testEvaluateForGreaterThanExpressionWithDecimalDataType()
       throws FilterUnsupportedException, FilterIllegalMemberException {
     ColumnExpression right = new ColumnExpression("contact", DataTypes.createDefaultDecimalType());
@@ -277,6 +386,36 @@ public class GreaterThanExpressionUnitTest {
     assertTrue(result.getBoolean());
   }
 
+  @Test public void testEvaluateForGreaterThanExpressionWithDecimalDataType1()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    ColumnExpression right = new ColumnExpression("contact", DataTypes.createDefaultDecimalType());
+    right.setColIndex(0);
+    ColumnExpression left = new ColumnExpression("contact", DataTypes.createDefaultDecimalType());
+    left.setColIndex(1);
+    greaterThanExpression = new GreaterThanExpression(left, right);
+    RowImpl value = new RowImpl();
+    BigDecimal[] row = new BigDecimal[] { new BigDecimal(12345.0) };
+    BigDecimal[] row1 = new BigDecimal[] { new BigDecimal(123451245.0) };
+    Object objectRow[] = { row1, row };
+    value.setValues(objectRow);
+
+    new MockUp<ExpressionResult>() {
+      Boolean returnMockFlag = true;
+
+      @Mock public BigDecimal getDecimal() {
+        if (returnMockFlag) {
+          returnMockFlag = false;
+          return new BigDecimal(12345.0);
+        } else {
+          return new BigDecimal(123451245.0);
+        }
+      }
+    };
+
+    ExpressionResult result = greaterThanExpression.evaluate(value);
+    assertFalse(result.getBoolean());
+  }
+
   @Test public void testForGreaterThanExpressionWithDefaultCase()
       throws FilterUnsupportedException, FilterIllegalMemberException {
     ColumnExpression right = new ColumnExpression("contact", DataTypes.BOOLEAN);
@@ -316,6 +455,38 @@ public class GreaterThanExpressionUnitTest {
 
   }
 
+  @Test public void testEvaluateForGreaterThanExpressionWithIsNullReturnTrue1()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    ColumnExpression right = new ColumnExpression("id", DataTypes.SHORT);
+    right.setColIndex(0);
+    greaterThanExpression = new GreaterThanExpression(right, right);
+    RowImpl value = new RowImpl();
+    Short[] row = { 15 };
+    Object objectRow[] = { row };
+    value.setValues(objectRow);
+
+    new MockUp<ExpressionResult>() {
+      boolean isFirst = true;
+      @Mock public boolean isNull() {
+        if (isFirst) {
+          isFirst = false;
+          return false;
+        }
+        return true;
+      }
+    };
+
+    new MockUp<ExpressionResult>() {
+      @Mock public Short getShort() {
+        return 15;
+      }
+    };
+
+    ExpressionResult result = greaterThanExpression.evaluate(value);
+    assertFalse(result.getBoolean());
+
+  }
+
   @Test public void testEvaluateForGreaterThanExpressionWithLeftAndRightDifferentDataType()
       throws FilterUnsupportedException, FilterIllegalMemberException {
     ColumnExpression left = new ColumnExpression("name", DataTypes.STRING);
@@ -348,6 +519,38 @@ public class GreaterThanExpressionUnitTest {
     assertTrue(result.getBoolean());
   }
 
+  @Test public void testEvaluateForGreaterThanExpressionWithLeftAndRightDifferentDataType1()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    ColumnExpression left = new ColumnExpression("name", DataTypes.INT);
+    left.setColIndex(0);
+    ColumnExpression right = new ColumnExpression("number", DataTypes.STRING);
+    right.setColIndex(1);
+    greaterThanExpression = new GreaterThanExpression(left, right);
+    RowImpl value = new RowImpl();
+    String[] row = { "String1" };
+    Integer[] row1 = { 14 };
+    Object objectRow[] = { row1, row };
+    value.setValues(objectRow);
+
+    new MockUp<ExpressionResult>() {
+      Boolean returnMockFlag = true;
+
+      @Mock public Integer getInt() {
+        if (returnMockFlag) {
+          returnMockFlag = false;
+          return 15;
+        } else {
+          return 14;
+
+        }
+
+      }
+    };
+
+    ExpressionResult result = greaterThanExpression.evaluate(value);
+    assertTrue(result.getBoolean());
+  }
+
   @Test public void testForGreaterThanExpressionWithGetString() throws Exception {
     ColumnExpression right = new ColumnExpression("right_name", DataTypes.STRING);
     right.setColIndex(0);

http://git-wip-us.apache.org/repos/asf/carbondata/blob/f9114036/core/src/test/java/org/apache/carbondata/core/scan/expression/conditional/LessThanEqualToExpressionUnitTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/carbondata/core/scan/expression/conditional/LessThanEqualToExpressionUnitTest.java b/core/src/test/java/org/apache/carbondata/core/scan/expression/conditional/LessThanEqualToExpressionUnitTest.java
index d3c8cf4..14594e7 100644
--- a/core/src/test/java/org/apache/carbondata/core/scan/expression/conditional/LessThanEqualToExpressionUnitTest.java
+++ b/core/src/test/java/org/apache/carbondata/core/scan/expression/conditional/LessThanEqualToExpressionUnitTest.java
@@ -109,6 +109,40 @@ public class LessThanEqualToExpressionUnitTest {
 
   }
 
+  @Test public void testEvaluateForLessThanEqualToExpressionWithShortDataType1()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    ColumnExpression right = new ColumnExpression("id", DataTypes.SHORT);
+    right.setColIndex(0);
+    ColumnExpression left = new ColumnExpression("id", DataTypes.SHORT);
+    left.setColIndex(1);
+    lessThanEqualToExpression = new LessThanEqualToExpression(left, right);
+    RowImpl value = new RowImpl();
+    Short[] row = { 1550 };
+    Short[] row1 = { 3365 };
+    Object objectRow[] = { row, row1 };
+    value.setValues(objectRow);
+
+    new MockUp<ExpressionResult>() {
+      Boolean returnMockFlag = true;
+
+      @Mock public Short getShort() {
+        if (returnMockFlag) {
+          returnMockFlag = false;
+          return 3365;
+
+        } else {
+          return 1550;
+
+        }
+
+      }
+    };
+
+    ExpressionResult result = lessThanEqualToExpression.evaluate(value);
+    assertFalse(result.getBoolean());
+
+  }
+
   @Test public void testEvaluateForLessThanEqualToExpressionWithDoubleDataType()
       throws FilterUnsupportedException, FilterIllegalMemberException {
     ColumnExpression right = new ColumnExpression("right_contact", DataTypes.DOUBLE);
@@ -220,6 +254,51 @@ public class LessThanEqualToExpressionUnitTest {
     }
   }
 
+  @Test public void testEvaluateForLessThanEqualToExpressionWithTimestampDataType1()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    try {
+      ColumnExpression left = new ColumnExpression("timestamp", DataTypes.TIMESTAMP);
+      left.setColIndex(0);
+      ColumnExpression right = new ColumnExpression("timestamp", DataTypes.TIMESTAMP);
+      right.setColIndex(1);
+
+      lessThanEqualToExpression = new LessThanEqualToExpression(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) };
+
+      Date date1 = dateFormat.parse("24/09/2007");
+      long time1 = date1.getTime();
+      Timestamp[] row1 = { new Timestamp(time1) };
+
+      Object objectRow[] = { row, row1 };
+      value.setValues(objectRow);
+
+      new MockUp<ExpressionResult>() {
+        Boolean returnMockFlag = true;
+
+        @Mock public Long getTime() {
+          if (returnMockFlag) {
+            returnMockFlag = false;
+            return 1190592000L;
+          } else {
+            return 1190505600L;
+          }
+        }
+      };
+
+      ExpressionResult result = lessThanEqualToExpression.evaluate(value);
+      assertFalse(result.getBoolean());
+    } catch (ParseException e) {
+      System.out.println("Error while parsing " + e.getMessage());
+    }
+  }
+
   @Test public void testEvaluateForLessThanEqualToExpressionWithLongDataType()
       throws FilterUnsupportedException, FilterIllegalMemberException {
     ColumnExpression right = new ColumnExpression("right_contact", DataTypes.LONG);
@@ -280,6 +359,38 @@ public class LessThanEqualToExpressionUnitTest {
     assertTrue(result.getBoolean());
   }
 
+  @Test public void testEvaluateForLessThanEqualToExpressionWithDecimalDataType1()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    ColumnExpression right =
+        new ColumnExpression("right_contact", DataTypes.createDefaultDecimalType());
+    right.setColIndex(0);
+    ColumnExpression left =
+        new ColumnExpression("left_contact", DataTypes.createDefaultDecimalType());
+    left.setColIndex(1);
+    lessThanEqualToExpression = new LessThanEqualToExpression(left, right);
+    RowImpl value = new RowImpl();
+    BigDecimal[] row = new BigDecimal[] { new BigDecimal(46851.2) };
+    BigDecimal[] row1 = new BigDecimal[] { new BigDecimal(45821.02) };
+    Object objectRow[] = { row1, row };
+    value.setValues(objectRow);
+
+    new MockUp<ExpressionResult>() {
+      Boolean returnMockFlag = true;
+
+      @Mock public BigDecimal getDecimal() {
+        if (returnMockFlag) {
+          returnMockFlag = false;
+          return new BigDecimal(46851.2);
+        } else {
+          return new BigDecimal(45821.02);
+        }
+      }
+    };
+
+    ExpressionResult result = lessThanEqualToExpression.evaluate(value);
+    assertFalse(result.getBoolean());
+  }
+
   @Test public void testForLessThanEqualToExpressionWithDefaultCase()
       throws FilterUnsupportedException, FilterIllegalMemberException {
     ColumnExpression right = new ColumnExpression("contact", DataTypes.BOOLEAN);
@@ -319,6 +430,38 @@ public class LessThanEqualToExpressionUnitTest {
 
   }
 
+  @Test public void testEvaluateForLessThanEqualToExpressionWithIsNullReturnTrue1()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    ColumnExpression right = new ColumnExpression("id", DataTypes.SHORT);
+    right.setColIndex(0);
+    lessThanEqualToExpression = new LessThanEqualToExpression(right, right);
+    RowImpl value = new RowImpl();
+    Short[] row = { 15856 };
+    Object objectRow[] = { row };
+    value.setValues(objectRow);
+
+    new MockUp<ExpressionResult>() {
+      boolean isFirst = true;
+      @Mock public boolean isNull() {
+        if (isFirst) {
+          isFirst = false;
+          return false;
+        }
+        return true;
+      }
+    };
+
+    new MockUp<ExpressionResult>() {
+      @Mock public Short getShort() {
+        return 15856;
+      }
+    };
+
+    ExpressionResult result = lessThanEqualToExpression.evaluate(value);
+    assertFalse(result.getBoolean());
+
+  }
+
   @Test public void testEvaluateForLessThanEqualToExpressionWithLeftAndRightDifferentDataType()
       throws FilterUnsupportedException, FilterIllegalMemberException {
     ColumnExpression left = new ColumnExpression("name", DataTypes.STRING);
@@ -351,6 +494,38 @@ public class LessThanEqualToExpressionUnitTest {
     assertTrue(result.getBoolean());
   }
 
+  @Test public void testEvaluateForLessThanEqualToExpressionWithLeftAndRightDifferentDataType1()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    ColumnExpression left = new ColumnExpression("name", DataTypes.INT);
+    left.setColIndex(0);
+    ColumnExpression right = new ColumnExpression("number", DataTypes.STRING);
+    right.setColIndex(1);
+    lessThanEqualToExpression = new LessThanEqualToExpression(left, right);
+    RowImpl value = new RowImpl();
+    String[] row = { "S" };
+    Integer[] row1 = { 1450 };
+    Object objectRow[] = { row1, row };
+    value.setValues(objectRow);
+
+    new MockUp<ExpressionResult>() {
+      Boolean returnMockFlag = true;
+
+      @Mock public Integer getInt() {
+        if (returnMockFlag) {
+          returnMockFlag = false;
+          return 84;
+        } else {
+          return 1450;
+
+        }
+
+      }
+    };
+
+    ExpressionResult result = lessThanEqualToExpression.evaluate(value);
+    assertTrue(result.getBoolean());
+  }
+
   @Test public void testForLessThanEqualToExpressionWithGetString() throws Exception {
     ColumnExpression right = new ColumnExpression("right_name", DataTypes.STRING);
     right.setColIndex(0);

http://git-wip-us.apache.org/repos/asf/carbondata/blob/f9114036/core/src/test/java/org/apache/carbondata/core/scan/expression/conditional/LessThanExpressionUnitTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/carbondata/core/scan/expression/conditional/LessThanExpressionUnitTest.java b/core/src/test/java/org/apache/carbondata/core/scan/expression/conditional/LessThanExpressionUnitTest.java
index e038a56..395750a 100644
--- a/core/src/test/java/org/apache/carbondata/core/scan/expression/conditional/LessThanExpressionUnitTest.java
+++ b/core/src/test/java/org/apache/carbondata/core/scan/expression/conditional/LessThanExpressionUnitTest.java
@@ -72,6 +72,37 @@ public class LessThanExpressionUnitTest {
     assertTrue(result.getBoolean());
   }
 
+  @Test public void testEvaluateForLessThanExpressionWithStringDataType1()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    ColumnExpression left = new ColumnExpression("left_name", DataTypes.STRING);
+    left.setColIndex(0);
+    ColumnExpression right = new ColumnExpression("right_name", DataTypes.STRING);
+    right.setColIndex(1);
+    lessThanExpression = new LessThanExpression(left, right);
+    RowImpl value = new RowImpl();
+    String[] row = { "First String Value" };
+    String[] row1 = { "string1" };
+    Object objectRow[] = { row, row1 };
+    new MockUp<ExpressionResult>() {
+      Boolean returnMockFlag = true;
+
+      @Mock public String getString() {
+        if (returnMockFlag) {
+          returnMockFlag = false;
+          return "string1";
+
+        } else {
+          return "First String Value";
+
+        }
+
+      }
+    };
+    value.setValues(objectRow);
+    ExpressionResult result = lessThanExpression.evaluate(value);
+    assertFalse(result.getBoolean());
+  }
+
   @Test public void testEvaluateForLessThanExpressionWithShortDataType()
       throws FilterUnsupportedException, FilterIllegalMemberException {
     ColumnExpression right = new ColumnExpression("id", DataTypes.SHORT);
@@ -106,6 +137,40 @@ public class LessThanExpressionUnitTest {
 
   }
 
+  @Test public void testEvaluateForLessThanExpressionWithShortDataType1()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    ColumnExpression right = new ColumnExpression("id", DataTypes.SHORT);
+    right.setColIndex(0);
+    ColumnExpression left = new ColumnExpression("id", DataTypes.SHORT);
+    left.setColIndex(1);
+    lessThanExpression = new LessThanExpression(left, right);
+    RowImpl value = new RowImpl();
+    Short[] row = { 7052 };
+    Short[] row1 = { 7450 };
+    Object objectRow[] = { row, row1 };
+    value.setValues(objectRow);
+
+    new MockUp<ExpressionResult>() {
+      Boolean returnMockFlag = true;
+
+      @Mock public Short getShort() {
+        if (returnMockFlag) {
+          returnMockFlag = false;
+          return 7450;
+
+        } else {
+          return 7052;
+
+        }
+
+      }
+    };
+
+    ExpressionResult result = lessThanExpression.evaluate(value);
+    assertFalse(result.getBoolean());
+
+  }
+
   @Test public void testEvaluateForLessThanExpressionWithDoubleDataType()
       throws FilterUnsupportedException, FilterIllegalMemberException {
     ColumnExpression right = new ColumnExpression("right_contact", DataTypes.DOUBLE);
@@ -217,6 +282,51 @@ public class LessThanExpressionUnitTest {
     }
   }
 
+  @Test public void testEvaluateForLessThanExpressionWithTimestampDataType1()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    try {
+      ColumnExpression left = new ColumnExpression("timestamp", DataTypes.TIMESTAMP);
+      left.setColIndex(0);
+      ColumnExpression right = new ColumnExpression("timestamp", DataTypes.TIMESTAMP);
+      right.setColIndex(1);
+
+      lessThanExpression = new LessThanExpression(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) };
+
+      Date date1 = dateFormat.parse("24/09/2007");
+      long time1 = date1.getTime();
+      Timestamp[] row1 = { new Timestamp(time1) };
+
+      Object objectRow[] = { row, row1 };
+      value.setValues(objectRow);
+
+      new MockUp<ExpressionResult>() {
+        Boolean returnMockFlag = true;
+
+        @Mock public Long getTime() {
+          if (returnMockFlag) {
+            returnMockFlag = false;
+            return 1190592000L;
+          } else {
+            return 1190505600L;
+          }
+        }
+      };
+
+      ExpressionResult result = lessThanExpression.evaluate(value);
+      assertFalse(result.getBoolean());
+    } catch (ParseException e) {
+      System.out.println("Error while parsing " + e.getMessage());
+    }
+  }
+
  @Test public void testEvaluateForLessThanExpressionWithLongDataType()
       throws FilterUnsupportedException, FilterIllegalMemberException {
     ColumnExpression right = new ColumnExpression("contact", DataTypes.LONG);
@@ -247,6 +357,36 @@ public class LessThanExpressionUnitTest {
     assertTrue(result.getBoolean());
   }
 
+  @Test public void testEvaluateForLessThanExpressionWithLongDataType1()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    ColumnExpression right = new ColumnExpression("contact", DataTypes.LONG);
+    right.setColIndex(0);
+    ColumnExpression left = new ColumnExpression("contact", DataTypes.LONG);
+    left.setColIndex(1);
+    lessThanExpression = new LessThanExpression(left, right);
+    RowImpl value = new RowImpl();
+    Long[] row = { 14523656L };
+    Long[] row1 = { 12456325L };
+    Object objectRow[] = { row1, row };
+    value.setValues(objectRow);
+
+    new MockUp<ExpressionResult>() {
+      Boolean returnMockFlag = true;
+
+      @Mock public Long getLong() {
+        if (returnMockFlag) {
+          returnMockFlag = false;
+          return 14523656L;
+        } else {
+          return 12456325L;
+        }
+      }
+    };
+
+    ExpressionResult result = lessThanExpression.evaluate(value);
+    assertFalse(result.getBoolean());
+  }
+
  @Test public void testEvaluateForLessThanExpressionWithDecimalDataType()
       throws FilterUnsupportedException, FilterIllegalMemberException {
     ColumnExpression right = new ColumnExpression("contact", DataTypes.createDefaultDecimalType());
@@ -316,6 +456,38 @@ public class LessThanExpressionUnitTest {
 
   }
 
+  @Test public void testEvaluateForLessThanExpressionWithIsNullReturnTrue1()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    ColumnExpression right = new ColumnExpression("id", DataTypes.SHORT);
+    right.setColIndex(0);
+    lessThanExpression = new LessThanExpression(right, right);
+    RowImpl value = new RowImpl();
+    Short[] row = { 15 };
+    Object objectRow[] = { row };
+    value.setValues(objectRow);
+
+    new MockUp<ExpressionResult>() {
+      boolean isFirst = true;
+      @Mock public boolean isNull() {
+        if (isFirst) {
+          isFirst = false;
+          return false;
+        }
+        return true;
+      }
+    };
+
+    new MockUp<ExpressionResult>() {
+      @Mock public Short getShort() {
+        return 15;
+      }
+    };
+
+    ExpressionResult result = lessThanExpression.evaluate(value);
+    assertFalse(result.getBoolean());
+
+  }
+
   @Test public void testEvaluateForLessThanExpressionWithLeftAndRightDifferentDataType()
       throws FilterUnsupportedException, FilterIllegalMemberException {
     ColumnExpression left = new ColumnExpression("name", DataTypes.STRING);
@@ -348,6 +520,38 @@ public class LessThanExpressionUnitTest {
     assertTrue(result.getBoolean());
   }
 
+  @Test public void testEvaluateForLessThanExpressionWithLeftAndRightDifferentDataType1()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    ColumnExpression left = new ColumnExpression("name", DataTypes.INT);
+    left.setColIndex(0);
+    ColumnExpression right = new ColumnExpression("number", DataTypes.STRING);
+    right.setColIndex(1);
+    lessThanExpression = new LessThanExpression(left, right);
+    RowImpl value = new RowImpl();
+    String[] row = { "S" };
+    Integer[] row1 = { 1864 };
+    Object objectRow[] = { row1, row };
+    value.setValues(objectRow);
+
+    new MockUp<ExpressionResult>() {
+      Boolean returnMockFlag = true;
+
+      @Mock public Integer getInt() {
+        if (returnMockFlag) {
+          returnMockFlag = false;
+          return 84;
+        } else {
+          return 1864;
+
+        }
+
+      }
+    };
+
+    ExpressionResult result = lessThanExpression.evaluate(value);
+    assertTrue(result.getBoolean());
+  }
+
  @Test public void testForLessThanExpressionWithGetString() throws Exception {
     ColumnExpression right = new ColumnExpression("right_name", DataTypes.STRING);
     right.setColIndex(0);

http://git-wip-us.apache.org/repos/asf/carbondata/blob/f9114036/core/src/test/java/org/apache/carbondata/core/scan/expression/conditional/ListExpressionUnitTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/carbondata/core/scan/expression/conditional/ListExpressionUnitTest.java b/core/src/test/java/org/apache/carbondata/core/scan/expression/conditional/ListExpressionUnitTest.java
index b885fc8..17e5eb7 100644
--- a/core/src/test/java/org/apache/carbondata/core/scan/expression/conditional/ListExpressionUnitTest.java
+++ b/core/src/test/java/org/apache/carbondata/core/scan/expression/conditional/ListExpressionUnitTest.java
@@ -33,6 +33,7 @@ import java.util.ArrayList;
 import static org.hamcrest.core.Is.is;
 import static org.hamcrest.core.IsEqual.equalTo;
 import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
 
 public class ListExpressionUnitTest {
 
@@ -58,4 +59,25 @@ public class ListExpressionUnitTest {
     ExpressionResult result = listExpression.evaluate(value);
     assertThat(expected_value, is(equalTo(result.getList().get(0).getString())));
   }
+
+  @Test public void testGetString() throws FilterUnsupportedException, FilterIllegalMemberException  {
+    ColumnExpression left = new ColumnExpression("left_name", DataTypes.STRING);
+    left.setColIndex(0);
+    ColumnExpression right = new ColumnExpression("right_name", DataTypes.STRING);
+    right.setColIndex(1);
+
+    List<Expression> children = new ArrayList<>();
+    children.add(left);
+    children.add(right);
+
+    listExpression = new ListExpression(children);
+    RowImpl value = new RowImpl();
+    String row = "Row is for left";
+    String row1 = "I am row 1";
+    Object objectRow[] = { row, row1 };
+    value.setValues(objectRow);
+    String expected_value = "ListExpression(ColumnExpression(left_name);ColumnExpression(right_name);)";
+    String exresult = listExpression.getString();
+    assertTrue(exresult.equals(expected_value));
+  }
 }

http://git-wip-us.apache.org/repos/asf/carbondata/blob/f9114036/core/src/test/java/org/apache/carbondata/core/scan/expression/conditional/NotEqualsExpressionUnitTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/carbondata/core/scan/expression/conditional/NotEqualsExpressionUnitTest.java b/core/src/test/java/org/apache/carbondata/core/scan/expression/conditional/NotEqualsExpressionUnitTest.java
index 34448f4..d0ee21e 100644
--- a/core/src/test/java/org/apache/carbondata/core/scan/expression/conditional/NotEqualsExpressionUnitTest.java
+++ b/core/src/test/java/org/apache/carbondata/core/scan/expression/conditional/NotEqualsExpressionUnitTest.java
@@ -108,7 +108,34 @@ public class NotEqualsExpressionUnitTest {
 
   }
 
-  @Test public void testEvaluateForNotEqualsExpressionWithIntDataType()
+  @Test public void testEvaluateForNotEqualsExpressionWithShortDataType1()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+
+    ColumnExpression left = new ColumnExpression("left_id", DataTypes.SHORT);
+    left.setColIndex(0);
+    ColumnExpression right = new ColumnExpression("right_id", DataTypes.SHORT);
+    right.setColIndex(1);
+    notEqualsExpression = new NotEqualsExpression(left, right);
+    RowImpl value = new RowImpl();
+    Short[] row = { 15 };
+    Short[] row1 = { 16 };
+    Object objectRow[] = { row, row1 };
+    value.setValues(objectRow);
+
+    new MockUp<ExpressionResult>() {
+
+      @Mock public Short getShort() {
+        return 15;
+
+      }
+    };
+
+    ExpressionResult result = notEqualsExpression.evaluate(value);
+    assertFalse(result.getBoolean());
+
+  }
+
+  @Test public void testEvaluateForNotEqualsExpressionWithIntDataType1()
       throws FilterUnsupportedException, FilterIllegalMemberException {
     ColumnExpression right = new ColumnExpression("right_number", DataTypes.INT);
     right.setColIndex(1);
@@ -139,6 +166,29 @@ public class NotEqualsExpressionUnitTest {
     assertTrue(result.getBoolean());
   }
 
+  @Test public void testEvaluateForNotEqualsExpressionWithIntDataType()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    ColumnExpression right = new ColumnExpression("right_number", DataTypes.INT);
+    right.setColIndex(1);
+    ColumnExpression left = new ColumnExpression("left_number", DataTypes.INT);
+    left.setColIndex(0);
+    notEqualsExpression = new NotEqualsExpression(left, right);
+    RowImpl value = new RowImpl();
+    Integer[] row = { 15 };
+    Integer[] row1 = { 16 };
+    Object objectRow[] = { row, row1 };
+    value.setValues(objectRow);
+
+    new MockUp<ExpressionResult>() {
+      @Mock public Integer getInt() {
+        return 15;
+      }
+    };
+
+    ExpressionResult result = notEqualsExpression.evaluate(value);
+    assertFalse(result.getBoolean());
+  }
+
   @Test public void testEvaluateForNotEqualsExpressionWithDoubleDataType()
       throws FilterUnsupportedException, FilterIllegalMemberException {
     ColumnExpression right = new ColumnExpression("right_contact", DataTypes.DOUBLE);
@@ -200,6 +250,31 @@ public class NotEqualsExpressionUnitTest {
     assertTrue(result.getBoolean());
   }
 
+  @Test public void testEvaluateForNotEqualsExpressionWithLongDataType1()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    ColumnExpression right = new ColumnExpression("right_contact", DataTypes.LONG);
+    right.setColIndex(1);
+    ColumnExpression left = new ColumnExpression("left_contact", DataTypes.LONG);
+    left.setColIndex(0);
+    notEqualsExpression = new NotEqualsExpression(left, right);
+    RowImpl value = new RowImpl();
+    Long[] row = { 1234567654321L };
+    Long[] row1 = { 12345676541L };
+    Object objectRow[] = { row, row1 };
+    value.setValues(objectRow);
+
+    new MockUp<ExpressionResult>() {
+      Boolean returnMockFlag = true;
+
+      @Mock public Long getLong() {
+        return 1234567654321L;
+      }
+    };
+
+    ExpressionResult result = notEqualsExpression.evaluate(value);
+    assertFalse(result.getBoolean());
+  }
+
   @Test public void testEvaluateForNotEqualsExpressionWithTimestampDataType()
       throws FilterUnsupportedException, FilterIllegalMemberException {
     try {
@@ -245,6 +320,46 @@ public class NotEqualsExpressionUnitTest {
     }
   }
 
+  @Test public void testEvaluateForNotEqualsExpressionWithTimestampDataType1()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    try {
+      ColumnExpression left = new ColumnExpression("left_timestamp", DataTypes.TIMESTAMP);
+      left.setColIndex(0);
+      ColumnExpression right = new ColumnExpression("right_timestamp", DataTypes.TIMESTAMP);
+      right.setColIndex(1);
+
+      notEqualsExpression = new NotEqualsExpression(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) };
+
+      Date date1 = dateFormat.parse("24/09/2007");
+      long time1 = date1.getTime();
+      Timestamp[] row1 = { new Timestamp(time1) };
+
+      Object objectRow[] = { row1, row };
+      value.setValues(objectRow);
+
+      new MockUp<ExpressionResult>() {
+        Boolean returnMockFlag = true;
+
+        @Mock public Long getTime() {
+          return 1190592000L;
+        }
+      };
+
+      ExpressionResult result = notEqualsExpression.evaluate(value);
+      assertFalse(result.getBoolean());
+    } catch (ParseException e) {
+      System.out.println("Error while parsing " + e.getMessage());
+    }
+  }
+
   @Test public void testForNotEqualsExpressionWithDefaultCase()
       throws FilterUnsupportedException, FilterIllegalMemberException {
     ColumnExpression right = new ColumnExpression("contact", DataTypes.BOOLEAN);
@@ -287,6 +402,31 @@ public class NotEqualsExpressionUnitTest {
     assertTrue(result.getBoolean());
   }
 
+  @Test public void testEvaluateWithForNotEqualsExpressionDecimalDataType1()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    ColumnExpression right = new ColumnExpression("contact", DataTypes.createDefaultDecimalType());
+    right.setColIndex(1);
+    ColumnExpression left = new ColumnExpression("contact", DataTypes.createDefaultDecimalType());
+    left.setColIndex(0);
+    notEqualsExpression = new NotEqualsExpression(left, right);
+    RowImpl value = new RowImpl();
+    BigDecimal[] row = new BigDecimal[] { new BigDecimal(12345.0) };
+    BigDecimal[] row1 = new BigDecimal[] { new BigDecimal(1235445.0) };
+    Object objectRow[] = { row, row1 };
+    value.setValues(objectRow);
+
+    new MockUp<ExpressionResult>() {
+      Boolean returnMockFlag = true;
+
+      @Mock public BigDecimal getDecimal() {
+        return new BigDecimal(12345.0);
+      }
+    };
+
+    ExpressionResult result = notEqualsExpression.evaluate(value);
+    assertFalse(result.getBoolean());
+  }
+
   @Test public void testEvaluateForNotEqualsExpressionWithIsNullReturnTrue()
       throws FilterUnsupportedException, FilterIllegalMemberException {
     ColumnExpression right = new ColumnExpression("id", DataTypes.SHORT);
@@ -314,6 +454,38 @@ public class NotEqualsExpressionUnitTest {
 
   }
 
+  @Test public void testEvaluateForNotEqualsExpressionWithIsNullReturnTrue1()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    ColumnExpression right = new ColumnExpression("id", DataTypes.SHORT);
+    right.setColIndex(0);
+    notEqualsExpression = new NotEqualsExpression(right, right);
+    RowImpl value = new RowImpl();
+    Short[] row = { 150 };
+    Object objectRow[] = { row };
+    value.setValues(objectRow);
+
+    new MockUp<ExpressionResult>() {
+      boolean isFirst = true;
+      @Mock public boolean isNull() {
+        if (isFirst) {
+          isFirst = false;
+          return false;
+        }
+        return true;
+      }
+    };
+
+    new MockUp<ExpressionResult>() {
+      @Mock public Short getShort() {
+        return 150;
+      }
+    };
+
+    ExpressionResult result = notEqualsExpression.evaluate(value);
+    assertFalse(result.getBoolean());
+
+  }
+
   @Test public void testEvaluateForNotEqualsExpressionWithLeftAndRightDifferentDataType()
       throws FilterUnsupportedException, FilterIllegalMemberException {
     ColumnExpression left = new ColumnExpression("name", DataTypes.STRING);
@@ -344,6 +516,36 @@ public class NotEqualsExpressionUnitTest {
     assertTrue(result.getBoolean());
   }
 
+  @Test public void testEvaluateForNotEqualsExpressionWithLeftAndRightDifferentDataType1()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    ColumnExpression left = new ColumnExpression("name", DataTypes.INT);
+    left.setColIndex(0);
+    ColumnExpression right = new ColumnExpression("number", DataTypes.STRING);
+    right.setColIndex(1);
+    notEqualsExpression = new NotEqualsExpression(left, right);
+    RowImpl value = new RowImpl();
+    String[] row1 = { "S" };
+    Integer[] row = { 14 };
+    Object objectRow[] = { row1, row };
+    value.setValues(objectRow);
+
+    new MockUp<ExpressionResult>() {
+      Boolean returnMockFlag = true;
+
+      @Mock public Integer getInt() {
+        if (returnMockFlag) {
+          returnMockFlag = false;
+          return 84;
+        } else {
+          return 14;
+        }
+      }
+    };
+
+    ExpressionResult result = notEqualsExpression.evaluate(value);
+    assertTrue(result.getBoolean());
+  }
+
   @Test public void testForNotEqualsExpressionWithGetString() throws Exception {
     ColumnExpression right = new ColumnExpression("right_name", DataTypes.STRING);
     ColumnExpression left = new ColumnExpression("left_name", DataTypes.STRING);

http://git-wip-us.apache.org/repos/asf/carbondata/blob/f9114036/core/src/test/java/org/apache/carbondata/core/scan/expression/conditional/NotInExpressionUnitTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/carbondata/core/scan/expression/conditional/NotInExpressionUnitTest.java b/core/src/test/java/org/apache/carbondata/core/scan/expression/conditional/NotInExpressionUnitTest.java
index d31361b..54791cc 100644
--- a/core/src/test/java/org/apache/carbondata/core/scan/expression/conditional/NotInExpressionUnitTest.java
+++ b/core/src/test/java/org/apache/carbondata/core/scan/expression/conditional/NotInExpressionUnitTest.java
@@ -36,6 +36,7 @@ import mockit.MockUp;
 import org.junit.Test;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 
 public class NotInExpressionUnitTest {
@@ -143,6 +144,35 @@ public class NotInExpressionUnitTest {
     assertTrue(result.getBoolean());
   }
 
+  @Test public void testEvaluateForNotInExpressionWithDoubleDataType1()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    ColumnExpression left = new ColumnExpression("left_contact", DataTypes.DOUBLE);
+    left.setColIndex(0);
+    ColumnExpression right = new ColumnExpression("right_contact", DataTypes.DOUBLE);
+    right.setColIndex(1);
+    notInExpression = new NotInExpression(left, right);
+    RowImpl value = new RowImpl();
+    Double row = 44521D;
+    Double row1 = 44521.023D;
+    Object objectRow[] = { row, row1 };
+    value.setValues(objectRow);
+
+    new MockUp<ExpressionResult>() {
+      @Mock public boolean isNull() {
+        return true;
+      }
+    };
+
+    new MockUp<ExpressionResult>() {
+      @Mock public Double getDouble() {
+        return 44521.023D;
+      }
+    };
+
+    ExpressionResult result = notInExpression.evaluate(value);
+    assertFalse(result.getBoolean());
+  }
+
   @Test public void testEvaluateForNotInExpressionWithLongDataType()
       throws FilterUnsupportedException, FilterIllegalMemberException {
     ColumnExpression left = new ColumnExpression("left_contact", DataTypes.LONG);

http://git-wip-us.apache.org/repos/asf/carbondata/blob/f9114036/core/src/test/java/org/apache/carbondata/core/scan/expression/logical/AndExpressionTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/carbondata/core/scan/expression/logical/AndExpressionTest.java b/core/src/test/java/org/apache/carbondata/core/scan/expression/logical/AndExpressionTest.java
index 6bb6900..5cc6a7b 100644
--- a/core/src/test/java/org/apache/carbondata/core/scan/expression/logical/AndExpressionTest.java
+++ b/core/src/test/java/org/apache/carbondata/core/scan/expression/logical/AndExpressionTest.java
@@ -71,6 +71,74 @@ public class AndExpressionTest {
     assertTrue(actualValue instanceof ExpressionResult);
   }
 
+  @Test public void testEvaluate1() throws FilterIllegalMemberException,
+      FilterUnsupportedException {
+    RowImpl rowImpl = new RowImpl();
+    rowImpl.setValues(new Boolean[] { false });
+    final ExpressionResult expressionResult = new ExpressionResult(DataTypes.BOOLEAN, "true");
+    new MockUp<ColumnExpression>() {
+      @Mock public ExpressionResult evaluate(RowIntf value) {
+        return expressionResult;
+      }
+    };
+
+    assertTrue(andExpression.evaluate(rowImpl) instanceof ExpressionResult);
+  }
+
+  @Test public void testEvaluate2() throws FilterIllegalMemberException,
+      FilterUnsupportedException {
+    RowImpl rowImpl = new RowImpl();
+    rowImpl.setValues(new Boolean[] { false });
+    final ExpressionResult expressionResultRight = new ExpressionResult(DataTypes.BOOLEAN, "false");
+    final ExpressionResult expressionResultLeft = new ExpressionResult(DataTypes.BOOLEAN, "true");
+    new MockUp<ColumnExpression>() {
+      boolean isLeft = true;
+      @Mock public ExpressionResult evaluate(RowIntf value) {
+        if (isLeft) {
+          isLeft = false;
+          return expressionResultLeft;
+        }
+        return expressionResultRight;
+      }
+    };
+
+    assertTrue(andExpression.evaluate(rowImpl) instanceof ExpressionResult);
+  }
+
+  @Test public void testEvaluate3() throws FilterIllegalMemberException,
+      FilterUnsupportedException {
+    RowImpl rowImpl = new RowImpl();
+    rowImpl.setValues(new Boolean[] { false });
+    final ExpressionResult expressionResultRight = new ExpressionResult(DataTypes.BOOLEAN, "false");
+    final ExpressionResult expressionResultLeft = new ExpressionResult(DataTypes.BOOLEAN, "false");
+    new MockUp<ColumnExpression>() {
+      boolean isLeft = true;
+      @Mock public ExpressionResult evaluate(RowIntf value) {
+        if (isLeft) {
+          isLeft = false;
+          return expressionResultLeft;
+        }
+        return expressionResultRight;
+      }
+    };
+
+    assertTrue(andExpression.evaluate(rowImpl) instanceof ExpressionResult);
+  }
+
+  @Test public void testEvaluate4()
+      throws FilterIllegalMemberException, FilterUnsupportedException {
+    RowImpl rowImpl = new RowImpl();
+    rowImpl.setValues(new Boolean[] { false });
+    final ExpressionResult expressionResult = new ExpressionResult(DataTypes.BOOLEAN, "false");
+    new MockUp<ColumnExpression>() {
+      @Mock public ExpressionResult evaluate(RowIntf value) {
+        return expressionResult;
+      }
+    };
+
+    assertTrue(andExpression.evaluate(rowImpl) instanceof ExpressionResult);
+  }
+
   @Test public void testGetString() {
     String actualValue = andExpression.getString();
     String expectedValue = "And(ColumnExpression(IMEI),ColumnExpression(IMEI))";

http://git-wip-us.apache.org/repos/asf/carbondata/blob/f9114036/core/src/test/java/org/apache/carbondata/core/scan/expression/logical/FalseExpressionTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/carbondata/core/scan/expression/logical/FalseExpressionTest.java b/core/src/test/java/org/apache/carbondata/core/scan/expression/logical/FalseExpressionTest.java
index 59bf0b5..85486e2 100644
--- a/core/src/test/java/org/apache/carbondata/core/scan/expression/logical/FalseExpressionTest.java
+++ b/core/src/test/java/org/apache/carbondata/core/scan/expression/logical/FalseExpressionTest.java
@@ -22,6 +22,7 @@ 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.ExpressionType;
 import org.apache.carbondata.core.scan.filter.intf.RowImpl;
 
 import org.junit.Before;
@@ -43,4 +44,15 @@ public class FalseExpressionTest {
     ExpressionResult actualValue = falseExpression.evaluate(rowImpl);
     assertEquals(new ExpressionResult(DataTypes.BOOLEAN, false), actualValue);
   }
+
+  @Test public void testGetString() {
+    String actualValue = falseExpression.getString();
+    String expectedValue = "False(ColumnExpression(IMEI)";
+    assertEquals(expectedValue, actualValue);
+  }
+
+  @Test public void testFilterExpressionType() {
+    ExpressionType actualValue = falseExpression.getFilterExpressionType();
+    assertEquals(ExpressionType.FALSE, actualValue);
+  }
 }

http://git-wip-us.apache.org/repos/asf/carbondata/blob/f9114036/core/src/test/java/org/apache/carbondata/core/scan/expression/logical/OrExpressionTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/carbondata/core/scan/expression/logical/OrExpressionTest.java b/core/src/test/java/org/apache/carbondata/core/scan/expression/logical/OrExpressionTest.java
index 6acfaea..83c3269 100644
--- a/core/src/test/java/org/apache/carbondata/core/scan/expression/logical/OrExpressionTest.java
+++ b/core/src/test/java/org/apache/carbondata/core/scan/expression/logical/OrExpressionTest.java
@@ -61,6 +61,74 @@ public class OrExpressionTest {
     assertTrue(orExpression.evaluate(rowImpl) instanceof ExpressionResult);
   }
 
+  @Test public void testEvaluate1() throws FilterIllegalMemberException,
+  FilterUnsupportedException {
+    RowImpl rowImpl = new RowImpl();
+    rowImpl.setValues(new Boolean[] { false });
+    final ExpressionResult expressionResult = new ExpressionResult(DataTypes.BOOLEAN, "true");
+    new MockUp<ColumnExpression>() {
+      @Mock public ExpressionResult evaluate(RowIntf value) {
+        return expressionResult;
+      }
+    };
+
+    assertTrue(orExpression.evaluate(rowImpl) instanceof ExpressionResult);
+  }
+
+  @Test public void testEvaluate2() throws FilterIllegalMemberException,
+      FilterUnsupportedException {
+    RowImpl rowImpl = new RowImpl();
+    rowImpl.setValues(new Boolean[] { false });
+    final ExpressionResult expressionResultRight = new ExpressionResult(DataTypes.BOOLEAN, "false");
+    final ExpressionResult expressionResultLeft = new ExpressionResult(DataTypes.BOOLEAN, "true");
+    new MockUp<ColumnExpression>() {
+      boolean isLeft = true;
+      @Mock public ExpressionResult evaluate(RowIntf value) {
+        if (isLeft) {
+          isLeft = false;
+          return expressionResultLeft;
+        }
+        return expressionResultRight;
+      }
+    };
+
+    assertTrue(orExpression.evaluate(rowImpl) instanceof ExpressionResult);
+  }
+
+  @Test public void testEvaluate3() throws FilterIllegalMemberException,
+      FilterUnsupportedException {
+    RowImpl rowImpl = new RowImpl();
+    rowImpl.setValues(new Boolean[] { false });
+    final ExpressionResult expressionResultRight = new ExpressionResult(DataTypes.BOOLEAN, "false");
+    final ExpressionResult expressionResultLeft = new ExpressionResult(DataTypes.BOOLEAN, "false");
+    new MockUp<ColumnExpression>() {
+      boolean isLeft = true;
+      @Mock public ExpressionResult evaluate(RowIntf value) {
+        if (isLeft) {
+          isLeft = false;
+          return expressionResultLeft;
+        }
+        return expressionResultRight;
+      }
+    };
+
+    assertTrue(orExpression.evaluate(rowImpl) instanceof ExpressionResult);
+  }
+
+  @Test public void testEvaluate4()
+      throws FilterIllegalMemberException, FilterUnsupportedException {
+    RowImpl rowImpl = new RowImpl();
+    rowImpl.setValues(new Boolean[] { false });
+    final ExpressionResult expressionResult = new ExpressionResult(DataTypes.BOOLEAN, "false");
+    new MockUp<ColumnExpression>() {
+      @Mock public ExpressionResult evaluate(RowIntf value) {
+        return expressionResult;
+      }
+    };
+
+    assertTrue(orExpression.evaluate(rowImpl) instanceof ExpressionResult);
+  }
+
   @Test(expected = Exception.class) public void testEvaluateForDefault()
       throws FilterUnsupportedException, FilterIllegalMemberException {
     RowImpl rowImpl = new RowImpl();

http://git-wip-us.apache.org/repos/asf/carbondata/blob/f9114036/core/src/test/java/org/apache/carbondata/core/scan/expression/logical/RangeExpressionTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/carbondata/core/scan/expression/logical/RangeExpressionTest.java b/core/src/test/java/org/apache/carbondata/core/scan/expression/logical/RangeExpressionTest.java
new file mode 100644
index 0000000..b76a3db
--- /dev/null
+++ b/core/src/test/java/org/apache/carbondata/core/scan/expression/logical/RangeExpressionTest.java
@@ -0,0 +1,148 @@
+/*
+ * 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.logical;
+
+import mockit.Mock;
+import mockit.MockUp;
+
+import org.apache.carbondata.core.metadata.datatype.DataTypes;
+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 org.apache.carbondata.core.scan.filter.intf.RowIntf;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import static junit.framework.TestCase.assertTrue;
+import static org.junit.Assert.assertEquals;
+
+public class RangeExpressionTest {
+  private RangeExpression rangeExpression;
+
+  @Before public void setUp() {
+    ColumnExpression leftExpression = new ColumnExpression("IMEI", DataTypes.BOOLEAN);
+    ColumnExpression rightExpression = new ColumnExpression("IMEI", DataTypes.BOOLEAN);
+    rangeExpression = new RangeExpression(leftExpression, rightExpression);
+  }
+
+  @Test public void testGetString() {
+    String actualValue = rangeExpression.getString();
+    String expectedValue = "Range(ColumnExpression(IMEI),ColumnExpression(IMEI))";
+    assertEquals(expectedValue, actualValue);
+  }
+
+  @Test public void testEvaluate() throws FilterIllegalMemberException, FilterUnsupportedException {
+    RowImpl rowImpl = new RowImpl();
+    rowImpl.setValues(new Boolean[] { false });
+    final ExpressionResult expressionResult = new ExpressionResult(DataTypes.BOOLEAN, "test");
+    new MockUp<ColumnExpression>() {
+      @Mock public ExpressionResult evaluate(RowIntf value) {
+        return expressionResult;
+      }
+    };
+
+    assertTrue(rangeExpression.evaluate(rowImpl) instanceof ExpressionResult);
+  }
+
+  @Test public void testEvaluate1()
+      throws FilterIllegalMemberException, FilterUnsupportedException {
+    RowImpl rowImpl = new RowImpl();
+    rowImpl.setValues(new Boolean[] { false });
+    final ExpressionResult expressionResult = new ExpressionResult(DataTypes.BOOLEAN, "true");
+    new MockUp<ColumnExpression>() {
+      @Mock public ExpressionResult evaluate(RowIntf value) {
+        return expressionResult;
+      }
+    };
+
+    assertTrue(rangeExpression.evaluate(rowImpl) instanceof ExpressionResult);
+  }
+
+  @Test public void testEvaluate2()
+      throws FilterIllegalMemberException, FilterUnsupportedException {
+    RowImpl rowImpl = new RowImpl();
+    rowImpl.setValues(new Boolean[] { false });
+    final ExpressionResult expressionResultRight = new ExpressionResult(DataTypes.BOOLEAN, "false");
+    final ExpressionResult expressionResultLeft = new ExpressionResult(DataTypes.BOOLEAN, "true");
+    new MockUp<ColumnExpression>() {
+      boolean isLeft = true;
+
+      @Mock public ExpressionResult evaluate(RowIntf value) {
+        if (isLeft) {
+          isLeft = false;
+          return expressionResultLeft;
+        }
+        return expressionResultRight;
+      }
+    };
+
+    assertTrue(rangeExpression.evaluate(rowImpl) instanceof ExpressionResult);
+  }
+
+  @Test public void testEvaluate3()
+      throws FilterIllegalMemberException, FilterUnsupportedException {
+    RowImpl rowImpl = new RowImpl();
+    rowImpl.setValues(new Boolean[] { false });
+    final ExpressionResult expressionResultRight = new ExpressionResult(DataTypes.BOOLEAN, "false");
+    final ExpressionResult expressionResultLeft = new ExpressionResult(DataTypes.BOOLEAN, "false");
+    new MockUp<ColumnExpression>() {
+      boolean isLeft = true;
+
+      @Mock public ExpressionResult evaluate(RowIntf value) {
+        if (isLeft) {
+          isLeft = false;
+          return expressionResultLeft;
+        }
+        return expressionResultRight;
+      }
+    };
+
+    assertTrue(rangeExpression.evaluate(rowImpl) instanceof ExpressionResult);
+  }
+
+  @Test public void testEvaluate4()
+      throws FilterIllegalMemberException, FilterUnsupportedException {
+    RowImpl rowImpl = new RowImpl();
+    rowImpl.setValues(new Boolean[] { false });
+    final ExpressionResult expressionResult = new ExpressionResult(DataTypes.BOOLEAN, "false");
+    new MockUp<ColumnExpression>() {
+      @Mock public ExpressionResult evaluate(RowIntf value) {
+        return expressionResult;
+      }
+    };
+
+    assertTrue(rangeExpression.evaluate(rowImpl) instanceof ExpressionResult);
+  }
+
+  @Test(expected = Exception.class) public void testEvaluateForDefault()
+      throws FilterUnsupportedException, FilterIllegalMemberException {
+    RowImpl rowImpl = new RowImpl();
+    rowImpl.setValues(new Boolean[] { true });
+    final ExpressionResult expressionResult = new ExpressionResult(DataTypes.STRING, "test");
+    new MockUp<ColumnExpression>() {
+      @Mock public ExpressionResult evaluate(RowIntf value)
+          throws FilterUnsupportedException, FilterIllegalMemberException {
+        return expressionResult;
+      }
+    };
+    rangeExpression.evaluate(rowImpl);
+  }
+}

http://git-wip-us.apache.org/repos/asf/carbondata/blob/f9114036/core/src/test/java/org/apache/carbondata/core/scan/expression/logical/TrueExpressionTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/carbondata/core/scan/expression/logical/TrueExpressionTest.java b/core/src/test/java/org/apache/carbondata/core/scan/expression/logical/TrueExpressionTest.java
new file mode 100644
index 0000000..77afc85
--- /dev/null
+++ b/core/src/test/java/org/apache/carbondata/core/scan/expression/logical/TrueExpressionTest.java
@@ -0,0 +1,57 @@
+/*
+ * 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.logical;
+
+import org.apache.carbondata.core.metadata.datatype.DataTypes;
+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.ExpressionType;
+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 TrueExpressionTest {
+  private TrueExpression trueExpression;
+
+  @Before public void setUp() {
+    ColumnExpression columnExpression = new ColumnExpression("IMEI", DataTypes.BOOLEAN);
+    trueExpression = new TrueExpression(columnExpression);
+  }
+
+  @Test public void testEvaluate() throws FilterUnsupportedException, FilterIllegalMemberException {
+    RowImpl rowImpl = new RowImpl();
+    rowImpl.setValues(new Boolean[] { true });
+    ExpressionResult actualValue = trueExpression.evaluate(rowImpl);
+    assertEquals(new ExpressionResult(DataTypes.BOOLEAN, true), actualValue);
+  }
+
+  @Test public void testGetString() {
+    String actualValue = trueExpression.getString();
+    String expectedValue = "True(ColumnExpression(IMEI)";
+    assertEquals(expectedValue, actualValue);
+  }
+
+  @Test public void testFilterExpressionType() {
+    ExpressionType actualValue = trueExpression.getFilterExpressionType();
+    assertEquals(ExpressionType.TRUE, actualValue);
+  }
+}

http://git-wip-us.apache.org/repos/asf/carbondata/blob/f9114036/core/src/test/java/org/apache/carbondata/core/scan/filter/FilterExpressionProcessorTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/carbondata/core/scan/filter/FilterExpressionProcessorTest.java b/core/src/test/java/org/apache/carbondata/core/scan/filter/FilterExpressionProcessorTest.java
index f294454..74f9625 100644
--- a/core/src/test/java/org/apache/carbondata/core/scan/filter/FilterExpressionProcessorTest.java
+++ b/core/src/test/java/org/apache/carbondata/core/scan/filter/FilterExpressionProcessorTest.java
@@ -36,7 +36,6 @@ public class FilterExpressionProcessorTest extends AbstractDictionaryCacheTest {
         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(DataTypes.STRING);

http://git-wip-us.apache.org/repos/asf/carbondata/blob/f9114036/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
index 9c7c26c..cbc0203 100644
--- 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
@@ -66,7 +66,6 @@ public class FilterUtilTest extends AbstractDictionaryCacheTest {
         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(DataTypes.STRING);
@@ -232,17 +231,14 @@ public class FilterUtilTest extends AbstractDictionaryCacheTest {
         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(DataTypes.STRING);
     columnSchema.setDimensionColumn(true);
     CarbonDimension carbonDimension =
-        new CarbonDimension(columnSchema, ordinal, keyOrdinal, columnGroupOrdinal,
-            complexTypeOrdinal);
+        new CarbonDimension(columnSchema, ordinal, keyOrdinal, complexTypeOrdinal);
     byte[] expectedResult = new byte[] { 1 };
     byte[] actualResult =
         FilterUtil.getMaskKey(surrogate, carbonDimension, multiDimKeyVarLengthGenerator);
@@ -257,7 +253,6 @@ public class FilterUtilTest extends AbstractDictionaryCacheTest {
     boolean isIncludeFilter = true;
     int ordinal = 1;
     ColumnSchema dimColumn = new ColumnSchema();
-    dimColumn.setColumnar(true);
     dimColumn.setColumnName("IMEI");
     dimColumn.setColumnUniqueId(UUID.randomUUID().toString());
     dimColumn.setDataType(DataTypes.STRING);
@@ -288,7 +283,6 @@ public class FilterUtilTest extends AbstractDictionaryCacheTest {
     boolean isIncludeFilter = true;
     int ordinal = 1;
     ColumnSchema dimColumn = new ColumnSchema();
-    dimColumn.setColumnar(true);
     dimColumn.setColumnName("IMEI");
     dimColumn.setColumnUniqueId(UUID.randomUUID().toString());
     dimColumn.setDataType(DataTypes.STRING);

http://git-wip-us.apache.org/repos/asf/carbondata/blob/f9114036/core/src/test/java/org/apache/carbondata/core/scan/filter/executer/IncludeFilterExecuterImplTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/carbondata/core/scan/filter/executer/IncludeFilterExecuterImplTest.java b/core/src/test/java/org/apache/carbondata/core/scan/filter/executer/IncludeFilterExecuterImplTest.java
index 92c2e85..b9e90d6 100644
--- a/core/src/test/java/org/apache/carbondata/core/scan/filter/executer/IncludeFilterExecuterImplTest.java
+++ b/core/src/test/java/org/apache/carbondata/core/scan/filter/executer/IncludeFilterExecuterImplTest.java
@@ -194,7 +194,7 @@ public class IncludeFilterExecuterImplTest extends TestCase {
       oldTime = oldTime + System.currentTimeMillis() - start;
 
       start = System.currentTimeMillis();
-      BitSet bitNew = this.setFilterdIndexToBitSetNew((FixedLengthDimensionColumnPage) dimensionColumnDataChunk, dataChunkSize,
+      BitSet bitNew = this.setFilterdIndexToBitSetNew(dimensionColumnDataChunk, dataChunkSize,
           filterKeys);
       newTime = newTime + System.currentTimeMillis() - start;
 

http://git-wip-us.apache.org/repos/asf/carbondata/blob/f9114036/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
index e5104fa..78dca73 100644
--- 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
@@ -23,6 +23,7 @@ import org.junit.Test;
 
 import static junit.framework.TestCase.assertEquals;
 import static junit.framework.TestCase.assertFalse;
+import static junit.framework.TestCase.assertNotSame;
 import static junit.framework.TestCase.assertTrue;
 
 public class ByteArrayWrapperTest {
@@ -30,6 +31,9 @@ public class ByteArrayWrapperTest {
   byte[] dictionaryKey = new byte[] { 1 };
   byte[][] complexTypesKeys = { { 1 }, { 1 } };
   byte[][] noDictionaryKeys = new byte[][] { { 1 }, { 1 } };
+  byte[] dictionaryKey1 = new byte[] { 2 };
+  byte[][] complexTypesKeys1 = { { 2 }, { 1 } };
+  byte[][] noDictionaryKeys1 = new byte[][] { { 2 }, { 1 } };
 
   @BeforeClass
 
@@ -91,6 +95,33 @@ public class ByteArrayWrapperTest {
     assertTrue(result);
   }
 
+  @Test
+
+  public void testEqualsForFirstElementComplexTypesKeysAndOther1() {
+    ByteArrayWrapper other = new ByteArrayWrapper();
+    other.setComplexTypesKeys(complexTypesKeys);
+    other.setDictionaryKey(dictionaryKey);
+    other.setNoDictionaryKeys(noDictionaryKeys);
+    byteArrayWrapper.setComplexTypesKeys(complexTypesKeys);
+    byteArrayWrapper.setDictionaryKey(dictionaryKey);
+    byteArrayWrapper.setNoDictionaryKeys(noDictionaryKeys1);
+    boolean result = byteArrayWrapper.equals(other);
+    assertFalse(result);
+  }
+
+  @Test
+  public void testEqualsForFirstElementComplexTypesKeysAndOther2() {
+    ByteArrayWrapper other = new ByteArrayWrapper();
+    other.setComplexTypesKeys(complexTypesKeys);
+    other.setDictionaryKey(dictionaryKey);
+    other.setNoDictionaryKeys(noDictionaryKeys);
+    byteArrayWrapper.setComplexTypesKeys(complexTypesKeys1);
+    byteArrayWrapper.setDictionaryKey(dictionaryKey);
+    byteArrayWrapper.setNoDictionaryKeys(noDictionaryKeys);
+    boolean result = byteArrayWrapper.equals(other);
+    assertFalse(result);
+  }
+
   @Test public void testCompareTo() {
     byteArrayWrapper.setDictionaryKey(dictionaryKey);
     ByteArrayWrapper other = new ByteArrayWrapper();
@@ -103,4 +134,30 @@ public class ByteArrayWrapperTest {
     int expectedResult = 0;
     assertEquals(expectedResult, actualResult);
   }
+
+  @Test public void testCompareTo1() {
+    byteArrayWrapper.setDictionaryKey(dictionaryKey1);
+    ByteArrayWrapper other = new ByteArrayWrapper();
+    other.setDictionaryKey(dictionaryKey1);
+    other.setNoDictionaryKeys(noDictionaryKeys);
+    other.setComplexTypesKeys(complexTypesKeys);
+    byteArrayWrapper.setNoDictionaryKeys(noDictionaryKeys);
+    byteArrayWrapper.setComplexTypesKeys(complexTypesKeys1);
+    int actualResult = byteArrayWrapper.compareTo(other);
+    int expectedResult = 0;
+    assertNotSame(expectedResult, actualResult);
+  }
+
+  @Test public void testCompareTo2() {
+    byteArrayWrapper.setDictionaryKey(dictionaryKey);
+    ByteArrayWrapper other = new ByteArrayWrapper();
+    other.setDictionaryKey(dictionaryKey);
+    other.setNoDictionaryKeys(noDictionaryKeys);
+    other.setComplexTypesKeys(complexTypesKeys);
+    byteArrayWrapper.setNoDictionaryKeys(noDictionaryKeys1);
+    byteArrayWrapper.setComplexTypesKeys(complexTypesKeys1);
+    int actualResult = byteArrayWrapper.compareTo(other);
+    int expectedResult = 0;
+    assertNotSame(expectedResult, actualResult);
+  }
 }

http://git-wip-us.apache.org/repos/asf/carbondata/blob/f9114036/core/src/test/java/org/apache/carbondata/core/util/CarbonMergerUtilTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/carbondata/core/util/CarbonMergerUtilTest.java b/core/src/test/java/org/apache/carbondata/core/util/CarbonMergerUtilTest.java
deleted file mode 100644
index 53d425f..0000000
--- a/core/src/test/java/org/apache/carbondata/core/util/CarbonMergerUtilTest.java
+++ /dev/null
@@ -1,41 +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.core.util;
-
-import static junit.framework.TestCase.*;
-
-import mockit.Mock;
-import mockit.MockUp;
-import org.junit.Test;
-
-import static org.apache.carbondata.core.util.CarbonMergerUtil.getCardinalityFromLevelMetadata;
-
-public class CarbonMergerUtilTest {
-
-  @Test public void testGetCardinalityFromLevelMetadata() throws Exception {
-    final int[] localCardinality = { 1, 2, 3, 4, 5, 6 };
-    new MockUp<CarbonUtil>() {
-      @SuppressWarnings("unused") @Mock
-      public int[] getCardinalityFromLevelMetadataFile(String levelPath) {
-        return localCardinality;
-      }
-    };
-    int[] result = getCardinalityFromLevelMetadata("STORE_PATH", "table1");
-    assertEquals(result, localCardinality);
-  }
-}

http://git-wip-us.apache.org/repos/asf/carbondata/blob/f9114036/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 d75f323..5520bfb 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
@@ -32,7 +32,6 @@ import java.util.Map;
 import org.apache.carbondata.core.datamap.Segment;
 import org.apache.carbondata.core.datastore.block.TableBlockInfo;
 import org.apache.carbondata.core.datastore.chunk.impl.FixedLengthDimensionColumnPage;
-import org.apache.carbondata.core.datastore.columnar.ColumnGroupModel;
 import org.apache.carbondata.core.datastore.filesystem.LocalCarbonFile;
 import org.apache.carbondata.core.datastore.impl.FileFactory;
 import org.apache.carbondata.core.metadata.ColumnarFormatVersion;
@@ -104,16 +103,6 @@ public class CarbonUtilTest {
     }
   }
 
-  @Test public void testToGetColGroupModel() {
-    int[][] cardinality = { { 10, 20, 30 }, { 20, 30 }, {} };
-    ColumnGroupModel actualResult = CarbonUtil.getColGroupModel(cardinality);
-    assertEquals(actualResult.getNoOfColumnStore(), 3);
-    int[] expectedResult = { 3, 2, 0 };
-    for (int i = 0; i < actualResult.getColumnSplit().length; i++) {
-      assertEquals(actualResult.getColumnSplit()[i], expectedResult[i]);
-    }
-  }
-
   @Test public void testToGetIncrementedCardinalityFullyFilled() {
     int[] cardinality = { 200, 20, 0, 10 };
     int[] actualResult = CarbonUtil.getIncrementedCardinalityFullyFilled(cardinality);
@@ -298,17 +287,6 @@ public class CarbonUtilTest {
     assertEquals(result, 5);
   }
 
-
-  @Test public void testToGetCardinalityFromLevelMetadataFileForInvalidPath()
-      throws IOException, InterruptedException {
-    try {
-      int[] cardinality = CarbonUtil.getCardinalityFromLevelMetadataFile("");
-      assertTrue(false);
-    } catch (Exception e) {
-      assertTrue(true);
-    }
-  }
-
   @Test public void testToUnescapeChar() {
     String[] input = { "\\001", "\\t", "\\r", "\\b", "\\n", "\\f" };
     String[] output = { "\001", "\t", "\r", "\b", "\n", "\f" };
@@ -522,14 +500,14 @@ public class CarbonUtilTest {
     encoding.add(Encoding.DICTIONARY);
     column1Schema.setEncodingList(encoding);
     ProjectionDimension
-        column1 = new ProjectionDimension(new CarbonDimension(column1Schema, 1, 1, 1, 1));
+        column1 = new ProjectionDimension(new CarbonDimension(column1Schema, 1, 1, 1));
 
     column2Schema.setColumnName("Column2");
     List<Encoding> encoding2 = new ArrayList<>();
     encoding2.add(Encoding.DELTA);
     column2Schema.setEncodingList(encoding2);
     ProjectionDimension
-        column2 = new ProjectionDimension(new CarbonDimension(column2Schema, 1, 1, 1, 1));
+        column2 = new ProjectionDimension(new CarbonDimension(column2Schema, 1, 1, 1));
 
     ProjectionDimension[] queryDimensions = { column1, column2 };
 
@@ -548,14 +526,14 @@ public class CarbonUtilTest {
     encoding.add(Encoding.DIRECT_DICTIONARY);
     column1Schema.setEncodingList(encoding);
     ProjectionDimension
-        column1 = new ProjectionDimension(new CarbonDimension(column1Schema, 1, 1, 1, 1));
+        column1 = new ProjectionDimension(new CarbonDimension(column1Schema, 1, 1, 1));
 
     column2Schema.setColumnName("Column2");
     List<Encoding> encoding2 = new ArrayList<>();
     encoding2.add(Encoding.DELTA);
     column2Schema.setEncodingList(encoding2);
     ProjectionDimension
-        column2 = new ProjectionDimension(new CarbonDimension(column2Schema, 1, 1, 1, 1));
+        column2 = new ProjectionDimension(new CarbonDimension(column2Schema, 1, 1, 1));
 
     ProjectionDimension[] queryDimensions = { column1, column2 };
 
@@ -572,12 +550,12 @@ public class CarbonUtilTest {
     column1Schema.setColumnName("Column1");
     column1Schema.setDataType(DataTypes.DATE);
     ProjectionDimension
-        column1 = new ProjectionDimension(new CarbonDimension(column1Schema, 1, 1, 1, 1));
+        column1 = new ProjectionDimension(new CarbonDimension(column1Schema, 1, 1, 1));
 
     column2Schema.setColumnName("Column2");
     column2Schema.setDataType(DataTypes.createDefaultArrayType());
     ProjectionDimension
-        column2 = new ProjectionDimension(new CarbonDimension(column2Schema, 1, 1, 1, 1));
+        column2 = new ProjectionDimension(new CarbonDimension(column2Schema, 1, 1, 1));
 
     ProjectionDimension[] queryDimensions = { column1, column2 };
 
@@ -617,10 +595,10 @@ public class CarbonUtilTest {
     column1Schema.setColumnName("Column1");
     column2Schema.setColumnName("Column2");
     List<CarbonDimension> carbonDimension = new ArrayList<>();
-    carbonDimension.add(new CarbonDimension(column1Schema, 1, 1, 1, 1));
-    carbonDimension.add(new CarbonDimension(column2Schema, 2, 1, 2, 1));
+    carbonDimension.add(new CarbonDimension(column1Schema, 1, 1, 1));
+    carbonDimension.add(new CarbonDimension(column2Schema, 2, 1, 1));
     assertEquals(CarbonUtil.findDimension(carbonDimension, "Column1"),
-        new CarbonDimension(column1Schema, 1, 1, 1, 1));
+        new CarbonDimension(column1Schema, 1, 1, 1));
   }
 
   @Test public void testToGetFormattedCardinality() {
@@ -649,8 +627,8 @@ public class CarbonUtilTest {
     column1Schema.setColumnName("Column1");
     column2Schema.setColumnName("Column2");
     List<CarbonDimension> carbonDimension = new ArrayList<>();
-    carbonDimension.add(new CarbonDimension(column1Schema, 1, 1, 1, 1));
-    carbonDimension.add(new CarbonDimension(column2Schema, 2, 2, 2, 1));
+    carbonDimension.add(new CarbonDimension(column1Schema, 1, 1, 1));
+    carbonDimension.add(new CarbonDimension(column2Schema, 2, 2, 1));
 
     List<CarbonMeasure> carbonMeasure = new ArrayList<>();
     carbonMeasure.add(new CarbonMeasure(column1Schema, 1));
@@ -776,17 +754,14 @@ public class CarbonUtilTest {
     ColumnSchema column2Schema = new ColumnSchema();
     ColumnSchema column3Schema = new ColumnSchema();
     column1Schema.setColumnName("Column1");
-    column1Schema.setColumnar(true);
     column1Schema.setEncodingList(Arrays.asList(Encoding.DELTA, Encoding.DICTIONARY));
     column2Schema.setColumnName("Column2");
-    column2Schema.setColumnar(false);
     column2Schema.setEncodingList(Arrays.asList(Encoding.DELTA, Encoding.DICTIONARY));
     column3Schema.setColumnName("Column3");
-    column3Schema.setColumnar(true);
     column3Schema.setEncodingList(Arrays.asList(Encoding.DELTA, Encoding.INVERTED_INDEX));
-    CarbonDimension carbonDimension = new CarbonDimension(column1Schema, 1, 1, 1, 1);
-    CarbonDimension carbonDimension2 = new CarbonDimension(column2Schema, 2, 2, 2, 2);
-    CarbonDimension carbonDimension3 = new CarbonDimension(column3Schema, 3, 3, 3, 3);
+    CarbonDimension carbonDimension = new CarbonDimension(column1Schema, 1, 1, 1);
+    CarbonDimension carbonDimension2 = new CarbonDimension(column2Schema, 2, 2, 2);
+    CarbonDimension carbonDimension3 = new CarbonDimension(column3Schema, 3, 3, 3);
     List<CarbonDimension> carbonDimensions =
         Arrays.asList(carbonDimension, carbonDimension2, carbonDimension3);
     boolean[] result = CarbonUtil.identifyDimensionType(carbonDimensions);

http://git-wip-us.apache.org/repos/asf/carbondata/blob/f9114036/core/src/test/java/org/apache/carbondata/core/util/RangeFilterProcessorTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/carbondata/core/util/RangeFilterProcessorTest.java b/core/src/test/java/org/apache/carbondata/core/util/RangeFilterProcessorTest.java
index 4fb5dcc..9b8be79 100644
--- a/core/src/test/java/org/apache/carbondata/core/util/RangeFilterProcessorTest.java
+++ b/core/src/test/java/org/apache/carbondata/core/util/RangeFilterProcessorTest.java
@@ -82,7 +82,7 @@ public class RangeFilterProcessorTest {
     empColumnSchema.setDimensionColumn(true);
     empColumnSchema.setEncodingList(Arrays.asList(Encoding.DICTIONARY));
     empColumnSchema.setDataType(DataTypes.STRING);
-    CarbonDimension empDimension = new CarbonDimension(empColumnSchema, 0, 0, 0, 0, 0);
+    CarbonDimension empDimension = new CarbonDimension(empColumnSchema, 0, 0, 0, 0);
     cola.setDimension(empDimension);
 
     Expression greaterThan =
@@ -123,7 +123,7 @@ public class RangeFilterProcessorTest {
     empColumnSchema.setDimensionColumn(true);
     empColumnSchema.setEncodingList(Arrays.asList(Encoding.DICTIONARY));
     empColumnSchema.setDataType(DataTypes.STRING);
-    CarbonDimension empDimension = new CarbonDimension(empColumnSchema, 0, 0, 0, 0, 0);
+    CarbonDimension empDimension = new CarbonDimension(empColumnSchema, 0, 0, 0, 0);
     cola.setDimension(empDimension);
 
     Expression greaterThan =
@@ -162,7 +162,7 @@ public class RangeFilterProcessorTest {
     empColumnSchema.setDimensionColumn(true);
     empColumnSchema.setEncodingList(Arrays.asList(Encoding.DICTIONARY));
     empColumnSchema.setDataType(DataTypes.STRING);
-    CarbonDimension empDimension = new CarbonDimension(empColumnSchema, 0, 0, 0, 0, 0);
+    CarbonDimension empDimension = new CarbonDimension(empColumnSchema, 0, 0, 0, 0);
 
     ColumnExpression cola1 = new ColumnExpression("a", DataTypes.STRING);
     cola1.setDimension(true);
@@ -237,7 +237,7 @@ public class RangeFilterProcessorTest {
     empColumnSchema.setDimensionColumn(true);
     empColumnSchema.setEncodingList(Arrays.asList(Encoding.DICTIONARY));
     empColumnSchema.setDataType(DataTypes.STRING);
-    CarbonDimension empDimension = new CarbonDimension(empColumnSchema, 0, 0, 0, 0, 0);
+    CarbonDimension empDimension = new CarbonDimension(empColumnSchema, 0, 0, 0, 0);
 
     ColumnExpression cola1 = new ColumnExpression("a", DataTypes.STRING);
     cola1.setDimension(true);

http://git-wip-us.apache.org/repos/asf/carbondata/blob/f9114036/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 d5500e1..9f2dc8e 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
@@ -119,9 +119,9 @@ public class CarbonDictionaryWriterImplTest {
    * prepare the dataset required for running test cases
    */
   private void prepareDataSet() {
-    dataSet1 = Arrays.asList(new String[] { "a", "b" });
-    dataSet2 = Arrays.asList(new String[] { "c", "d" });
-    dataSet3 = Arrays.asList(new String[] { "e", "f" });
+    dataSet1 = Arrays.asList("a", "b");
+    dataSet2 = Arrays.asList("c", "d");
+    dataSet3 = Arrays.asList("e", "f");
   }
 
   /**


Mime
View raw message