From adb0775129150696b8ba845e327955bece1111a3 Mon Sep 17 00:00:00 2001 From: Petr Pytelka Date: Mon, 3 Feb 2020 16:13:39 +0100 Subject: [PATCH] Refactorized AbstractCompareOperator / improved comparison between different types. Do not prefer left operand over right operand. E.g.: newly 3.0=3 is same as 3=3.0 --- .../operators/AbstractCompareOperator.java | 88 ++++++++++--------- .../executors/operators/AbstractOperator.java | 81 +++++++++++++++++ .../executors/operators/EqualsOperator.java | 33 +------ .../operators/GreaterOrEqualOperator.java | 35 +------- .../operators/GreaterThanOperator.java | 35 +------- .../operators/LessOrEqualOperator.java | 35 +------- .../executors/operators/LessThanOperator.java | 35 +------- .../executors/operators/NotEqualOperator.java | 35 +------- .../operators/RightSideEqualsOperator.java | 1 - .../RightSideGreaterOrEqualOperator.java | 1 - .../RightSideLessOrEqualOperator.java | 1 - .../rightvalues/BasicBooleanValue.java | 7 +- .../rightvalues/BasicDoubleValue.java | 6 +- .../executors/rightvalues/BasicLongValue.java | 6 +- .../executors/operators/TestOperators.java | 12 ++- .../rightvalues/TestConversions.java | 8 +- 16 files changed, 168 insertions(+), 251 deletions(-) diff --git a/src/main/java/com/scriptbasic/executors/operators/AbstractCompareOperator.java b/src/main/java/com/scriptbasic/executors/operators/AbstractCompareOperator.java index 07234273..63a3e643 100644 --- a/src/main/java/com/scriptbasic/executors/operators/AbstractCompareOperator.java +++ b/src/main/java/com/scriptbasic/executors/operators/AbstractCompareOperator.java @@ -8,33 +8,20 @@ public abstract class AbstractCompareOperator extends AbstractBinaryFullCircuitOperator { - protected static int compareJavaObjectTo(final BasicJavaObjectValue f, - final RightValue op) throws BasicRuntimeException { - final var o = BasicJavaObjectValue.asObject(op); - if (f.getValue() instanceof Comparable && o instanceof Comparable) { - @SuppressWarnings("unchecked") final Comparable> a = (Comparable>) f - .getValue(); - final Comparable b = (Comparable) o; - return a.compareTo(b); - } - throw new BasicRuntimeException( - "Can not compare the java objects, at least one of them is not comparable"); - } - - protected abstract Boolean compareTo(BasicDoubleValue d, RightValue op) - throws BasicRuntimeException; - - protected abstract Boolean compareTo(BasicLongValue l, RightValue op) - throws BasicRuntimeException; + /** + * Get final decision from comparison result. + * + * @param comparisonResult + * Result from function compareTo + * @return final decision + */ + abstract protected boolean decide(final int comparisonResult); - protected abstract Boolean compareTo(BasicStringValue s, RightValue op) - throws BasicRuntimeException; - - protected abstract Boolean compareTo(BasicJavaObjectValue s, RightValue op) - throws BasicRuntimeException; - - protected abstract Boolean compareTo(BasicBooleanValue s, RightValue op) - ; + protected Boolean compareTo(Comparable l, T r) + throws BasicRuntimeException { + final int comparisonResult = l.compareTo(r); + return decide(comparisonResult); + } @Override protected RightValue evaluateOn(final RightValue leftOperand, @@ -45,26 +32,43 @@ protected RightValue evaluateOn(final RightValue leftOperand, if (leftOperand == null || rightOperand == null) { return BasicValue.FALSE; } - if (leftOperand.isDouble()) { - return new BasicBooleanValue(compareTo( - ((BasicDoubleValue) leftOperand), rightOperand)); + if (leftOperand.isLong() || rightOperand.isLong()) { + final Long leftValue = getAsLong(leftOperand); + final Long rightValue = getAsLong(rightOperand); + if (leftValue != null && rightValue != null) + return new BasicBooleanValue(compareTo(leftValue, rightValue)); } - if (leftOperand.isLong()) { - return new BasicBooleanValue(compareTo( - ((BasicLongValue) leftOperand), rightOperand)); + if (leftOperand.isLong() || rightOperand.isLong() || leftOperand.isDouble() || rightOperand.isDouble()) { + final Double leftValue = getAsDouble(leftOperand); + final Double rightValue = getAsDouble(rightOperand); + if (leftValue != null && rightValue != null) + return new BasicBooleanValue(compareTo(leftValue, rightValue)); } - if (leftOperand.isBoolean()) { - return new BasicBooleanValue(compareTo( - ((BasicBooleanValue) leftOperand), rightOperand)); + if (leftOperand.isBoolean() && rightOperand.isBoolean()) { + final Boolean leftValue = getAsBoolean(leftOperand); + final Boolean rightValue = getAsBoolean(rightOperand); + if (leftValue != null && rightValue != null) + return new BasicBooleanValue(compareTo(leftValue, rightValue)); } - if (leftOperand.isString()) { - return new BasicBooleanValue(compareTo( - ((BasicStringValue) leftOperand), rightOperand)); + if (leftOperand.isString() || rightOperand.isString()) { + final String leftValue = getAsString(leftOperand); + final String rightValue = getAsString(rightOperand); + if (leftValue != null && rightValue != null) + return new BasicBooleanValue(compareTo(leftValue, rightValue)); } - if (leftOperand.isJavaObject()) { - return new BasicBooleanValue(compareTo( - ((BasicJavaObjectValue) leftOperand), rightOperand)); + if (leftOperand.isJavaObject() || rightOperand.isJavaObject()) { + final Object leftValue = getAsObject(leftOperand); + final Object rightValue = getAsObject(rightOperand); + if (leftValue != null && rightValue != null) { + if (leftValue instanceof Comparable && rightValue instanceof Comparable) { + @SuppressWarnings("unchecked") + final Comparable> a = (Comparable>) leftValue; + final Comparable b = (Comparable) rightValue; + return new BasicBooleanValue(compareTo(a, b)); + } + } } - return null; + throw new BasicRuntimeException("Type mismatch, left operand: " + leftOperand + + ", right operand: " + rightOperand); } } diff --git a/src/main/java/com/scriptbasic/executors/operators/AbstractOperator.java b/src/main/java/com/scriptbasic/executors/operators/AbstractOperator.java index 6f1aa4cb..0c3274e7 100644 --- a/src/main/java/com/scriptbasic/executors/operators/AbstractOperator.java +++ b/src/main/java/com/scriptbasic/executors/operators/AbstractOperator.java @@ -1,7 +1,88 @@ package com.scriptbasic.executors.operators; import com.scriptbasic.executors.AbstractExpression; +import com.scriptbasic.executors.rightvalues.BasicBooleanValue; +import com.scriptbasic.executors.rightvalues.BasicDoubleValue; +import com.scriptbasic.executors.rightvalues.BasicJavaObjectValue; +import com.scriptbasic.executors.rightvalues.BasicLongValue; +import com.scriptbasic.executors.rightvalues.BasicStringValue; +import com.scriptbasic.interfaces.BasicRuntimeException; +import com.scriptbasic.spi.RightValue; public abstract class AbstractOperator extends AbstractExpression { + /** + * Try to convert operator to double + * + * @param op + * operator + * @return Return double or null if cannot be converted + */ + static protected Double getAsDouble(RightValue op) { + try { + return BasicDoubleValue.asDouble(op); + } catch (BasicRuntimeException e) { + return null; + } + } + + /** + * Try to convert operator to long + * + * @param op + * operator + * @return Return long or null if cannot be converted + */ + static protected Long getAsLong(RightValue op) { + try { + return BasicLongValue.asLong(op); + } catch (BasicRuntimeException e) { + return null; + } + } + + /** + * Try to convert operator to boolean + * + * @param op + * operator + * @return Return boolean or null if cannot be converted + */ + static protected Boolean getAsBoolean(RightValue op) { + try { + return BasicBooleanValue.asBoolean(op); + } catch (BasicRuntimeException e) { + return null; + } + } + + /** + * Try to convert operator to string + * + * @param op + * operator + * @return Return string or null if cannot be converted + */ + static protected String getAsString(RightValue op) { + try { + return BasicStringValue.asString(op); + } catch (BasicRuntimeException e) { + return null; + } + } + + /** + * Try to convert operator to java object + * + * @param op + * operator + * @return Return object or null if cannot be converted + */ + static protected Object getAsObject(RightValue op) { + try { + return BasicJavaObjectValue.asObject(op); + } catch (BasicRuntimeException e) { + return null; + } + } } diff --git a/src/main/java/com/scriptbasic/executors/operators/EqualsOperator.java b/src/main/java/com/scriptbasic/executors/operators/EqualsOperator.java index 4d905d08..226dd89b 100644 --- a/src/main/java/com/scriptbasic/executors/operators/EqualsOperator.java +++ b/src/main/java/com/scriptbasic/executors/operators/EqualsOperator.java @@ -1,38 +1,9 @@ package com.scriptbasic.executors.operators; -import com.scriptbasic.executors.rightvalues.*; -import com.scriptbasic.interfaces.BasicRuntimeException; -import com.scriptbasic.spi.RightValue; - public class EqualsOperator extends AbstractCompareOperator { @Override - protected Boolean compareTo(final BasicDoubleValue f, final RightValue op) - throws BasicRuntimeException { - return f.getValue().equals(BasicDoubleValue.asDouble(op)); - } - - @Override - protected Boolean compareTo(final BasicLongValue f, final RightValue op) - throws BasicRuntimeException { - return f.getValue().equals(BasicLongValue.asLong(op)); - } - - @Override - protected Boolean compareTo(final BasicStringValue f, final RightValue op) - throws BasicRuntimeException { - return f.getValue().equals(BasicStringValue.asString(op)); + protected boolean decide(int comparisonResult) { + return comparisonResult == 0; } - - @Override - protected Boolean compareTo(final BasicJavaObjectValue f, - final RightValue op) throws BasicRuntimeException { - return compareJavaObjectTo(f, op) == 0; - } - - @Override - protected Boolean compareTo(final BasicBooleanValue f, final RightValue op) { - return f.getValue().equals(BasicBooleanValue.asBoolean(op)); - } - } diff --git a/src/main/java/com/scriptbasic/executors/operators/GreaterOrEqualOperator.java b/src/main/java/com/scriptbasic/executors/operators/GreaterOrEqualOperator.java index e26ce088..41833d26 100644 --- a/src/main/java/com/scriptbasic/executors/operators/GreaterOrEqualOperator.java +++ b/src/main/java/com/scriptbasic/executors/operators/GreaterOrEqualOperator.java @@ -1,40 +1,9 @@ package com.scriptbasic.executors.operators; -import com.scriptbasic.executors.rightvalues.*; -import com.scriptbasic.interfaces.BasicRuntimeException; -import com.scriptbasic.spi.RightValue; - public class GreaterOrEqualOperator extends AbstractCompareOperator { @Override - protected Boolean compareTo(final BasicDoubleValue f, final RightValue op) - throws BasicRuntimeException { - return f.getValue() >= BasicDoubleValue.asDouble(op, "Cannot float compare >= on undef value"); - } - - @Override - protected Boolean compareTo(final BasicLongValue f, final RightValue op) - throws BasicRuntimeException { - return f.getValue() >= BasicLongValue.asLong(op, "Cannot integer compare >= undef value"); - } - - @Override - protected Boolean compareTo(final BasicStringValue f, final RightValue op) - throws BasicRuntimeException { - return f.getValue().compareTo(BasicStringValue.asString(op)) >= 0; + protected boolean decide(int comparisonResult) { + return comparisonResult >= 0; } - - @Override - protected Boolean compareTo(final BasicJavaObjectValue f, - final RightValue op) throws BasicRuntimeException { - return compareJavaObjectTo(f, op) >= 0; - } - - @Override - protected Boolean compareTo(final BasicBooleanValue f, final RightValue op) { - final var a = f.getValue() ? 1 : 0; - final var b = BasicBooleanValue.asBoolean(op) ? 1 : 0; - return a >= b; - } - } diff --git a/src/main/java/com/scriptbasic/executors/operators/GreaterThanOperator.java b/src/main/java/com/scriptbasic/executors/operators/GreaterThanOperator.java index 7ddbabee..ac9555bd 100644 --- a/src/main/java/com/scriptbasic/executors/operators/GreaterThanOperator.java +++ b/src/main/java/com/scriptbasic/executors/operators/GreaterThanOperator.java @@ -1,40 +1,9 @@ package com.scriptbasic.executors.operators; -import com.scriptbasic.executors.rightvalues.*; -import com.scriptbasic.interfaces.BasicRuntimeException; -import com.scriptbasic.spi.RightValue; - public class GreaterThanOperator extends AbstractCompareOperator { @Override - protected Boolean compareTo(final BasicDoubleValue f, final RightValue op) - throws BasicRuntimeException { - return f.getValue() > BasicDoubleValue.asDouble(op, "Cannot float compare > undef value"); - } - - @Override - protected Boolean compareTo(final BasicLongValue f, final RightValue op) - throws BasicRuntimeException { - return f.getValue() > BasicLongValue.asLong(op, "Cannot integer compare > undef value"); - } - - @Override - protected Boolean compareTo(final BasicStringValue f, final RightValue op) - throws BasicRuntimeException { - return f.getValue().compareTo(BasicStringValue.asString(op)) > 0; + protected boolean decide(int comparisonResult) { + return comparisonResult > 0; } - - @Override - protected Boolean compareTo(final BasicJavaObjectValue f, - final RightValue op) throws BasicRuntimeException { - return compareJavaObjectTo(f, op) > 0; - } - - @Override - protected Boolean compareTo(final BasicBooleanValue f, final RightValue op) { - final var a = f.getValue() ? 1 : 0; - final var b = BasicBooleanValue.asBoolean(op) ? 1 : 0; - return a > b; - } - } diff --git a/src/main/java/com/scriptbasic/executors/operators/LessOrEqualOperator.java b/src/main/java/com/scriptbasic/executors/operators/LessOrEqualOperator.java index c6f87077..a3ad009f 100644 --- a/src/main/java/com/scriptbasic/executors/operators/LessOrEqualOperator.java +++ b/src/main/java/com/scriptbasic/executors/operators/LessOrEqualOperator.java @@ -1,40 +1,9 @@ package com.scriptbasic.executors.operators; -import com.scriptbasic.executors.rightvalues.*; -import com.scriptbasic.interfaces.BasicRuntimeException; -import com.scriptbasic.spi.RightValue; - public class LessOrEqualOperator extends AbstractCompareOperator { @Override - protected Boolean compareTo(final BasicDoubleValue f, final RightValue op) - throws BasicRuntimeException { - return f.getValue() <= BasicDoubleValue.asDouble(op, "Cannot float compare <= undef value"); - } - - @Override - protected Boolean compareTo(final BasicLongValue f, final RightValue op) - throws BasicRuntimeException { - return f.getValue() <= BasicLongValue.asLong(op, "Cannot integer compare <= undef value"); - } - - @Override - protected Boolean compareTo(final BasicStringValue f, final RightValue op) - throws BasicRuntimeException { - return f.getValue().compareTo(BasicStringValue.asString(op)) <= 0; + protected boolean decide(int comparisonResult) { + return comparisonResult <= 0; } - - @Override - protected Boolean compareTo(final BasicJavaObjectValue f, - final RightValue op) throws BasicRuntimeException { - return compareJavaObjectTo(f, op) <= 0; - } - - @Override - protected Boolean compareTo(final BasicBooleanValue f, final RightValue op) { - final var a = f.getValue() ? 1 : 0; - final var b = BasicBooleanValue.asBoolean(op) ? 1 : 0; - return a <= b; - } - } diff --git a/src/main/java/com/scriptbasic/executors/operators/LessThanOperator.java b/src/main/java/com/scriptbasic/executors/operators/LessThanOperator.java index 7fc1e0d2..a1efbd9d 100644 --- a/src/main/java/com/scriptbasic/executors/operators/LessThanOperator.java +++ b/src/main/java/com/scriptbasic/executors/operators/LessThanOperator.java @@ -1,40 +1,9 @@ package com.scriptbasic.executors.operators; -import com.scriptbasic.executors.rightvalues.*; -import com.scriptbasic.interfaces.BasicRuntimeException; -import com.scriptbasic.spi.RightValue; - public class LessThanOperator extends AbstractCompareOperator { @Override - protected Boolean compareTo(final BasicDoubleValue f, final RightValue op) - throws BasicRuntimeException { - return f.getValue() < BasicDoubleValue.asDouble(op, "Cannot float compare < undef value"); - } - - @Override - protected Boolean compareTo(final BasicLongValue f, final RightValue op) - throws BasicRuntimeException { - return f.getValue() < BasicLongValue.asLong(op, "Cannot integer compare < undef value"); - } - - @Override - protected Boolean compareTo(final BasicStringValue f, final RightValue op) - throws BasicRuntimeException { - return f.getValue().compareTo(BasicStringValue.asString(op)) < 0; + protected boolean decide(int comparisonResult) { + return comparisonResult < 0; } - - @Override - protected Boolean compareTo(final BasicJavaObjectValue f, - final RightValue op) throws BasicRuntimeException { - return compareJavaObjectTo(f, op) < 0; - } - - @Override - protected Boolean compareTo(final BasicBooleanValue f, final RightValue op) { - final var a = f.getValue() ? 1 : 0; - final var b = BasicBooleanValue.asBoolean(op) ? 1 : 0; - return a < b; - } - } diff --git a/src/main/java/com/scriptbasic/executors/operators/NotEqualOperator.java b/src/main/java/com/scriptbasic/executors/operators/NotEqualOperator.java index eb7e2ec1..4d69c00e 100644 --- a/src/main/java/com/scriptbasic/executors/operators/NotEqualOperator.java +++ b/src/main/java/com/scriptbasic/executors/operators/NotEqualOperator.java @@ -1,40 +1,9 @@ package com.scriptbasic.executors.operators; -import com.scriptbasic.executors.rightvalues.*; -import com.scriptbasic.interfaces.BasicRuntimeException; -import com.scriptbasic.spi.RightValue; - public class NotEqualOperator extends AbstractCompareOperator { @Override - protected Boolean compareTo(final BasicDoubleValue f, final RightValue op) - throws BasicRuntimeException { - return !f.getValue().equals(BasicDoubleValue.asDouble(op)); - } - - @Override - protected Boolean compareTo(final BasicLongValue f, final RightValue op) - throws BasicRuntimeException { - return !f.getValue().equals(BasicLongValue.asLong(op)); - } - - @Override - protected Boolean compareTo(final BasicStringValue f, final RightValue op) - throws BasicRuntimeException { - return f.getValue().compareTo(BasicStringValue.asString(op)) != 0; + protected boolean decide(int comparisonResult) { + return comparisonResult != 0; } - - @Override - protected Boolean compareTo(final BasicJavaObjectValue f, - final RightValue op) throws BasicRuntimeException { - return compareJavaObjectTo(f, op) != 0; - } - - @Override - protected Boolean compareTo(final BasicBooleanValue f, final RightValue op) { - final var a = f.getValue() ? 1 : 0; - final var b = BasicBooleanValue.asBoolean(op) ? 1 : 0; - return a != b; - } - } diff --git a/src/main/java/com/scriptbasic/executors/operators/RightSideEqualsOperator.java b/src/main/java/com/scriptbasic/executors/operators/RightSideEqualsOperator.java index 7c07ac61..9456d518 100644 --- a/src/main/java/com/scriptbasic/executors/operators/RightSideEqualsOperator.java +++ b/src/main/java/com/scriptbasic/executors/operators/RightSideEqualsOperator.java @@ -1,6 +1,5 @@ package com.scriptbasic.executors.operators; -import com.scriptbasic.api.ScriptBasicException; import com.scriptbasic.spi.Interpreter; import com.scriptbasic.spi.RightValue; diff --git a/src/main/java/com/scriptbasic/executors/operators/RightSideGreaterOrEqualOperator.java b/src/main/java/com/scriptbasic/executors/operators/RightSideGreaterOrEqualOperator.java index eab744d8..cf4cef7e 100644 --- a/src/main/java/com/scriptbasic/executors/operators/RightSideGreaterOrEqualOperator.java +++ b/src/main/java/com/scriptbasic/executors/operators/RightSideGreaterOrEqualOperator.java @@ -1,6 +1,5 @@ package com.scriptbasic.executors.operators; -import com.scriptbasic.api.ScriptBasicException; import com.scriptbasic.spi.Interpreter; import com.scriptbasic.spi.RightValue; diff --git a/src/main/java/com/scriptbasic/executors/operators/RightSideLessOrEqualOperator.java b/src/main/java/com/scriptbasic/executors/operators/RightSideLessOrEqualOperator.java index eab7f802..b3286170 100644 --- a/src/main/java/com/scriptbasic/executors/operators/RightSideLessOrEqualOperator.java +++ b/src/main/java/com/scriptbasic/executors/operators/RightSideLessOrEqualOperator.java @@ -1,6 +1,5 @@ package com.scriptbasic.executors.operators; -import com.scriptbasic.api.ScriptBasicException; import com.scriptbasic.spi.Interpreter; import com.scriptbasic.spi.RightValue; diff --git a/src/main/java/com/scriptbasic/executors/rightvalues/BasicBooleanValue.java b/src/main/java/com/scriptbasic/executors/rightvalues/BasicBooleanValue.java index 273d3f04..b5e4e62e 100644 --- a/src/main/java/com/scriptbasic/executors/rightvalues/BasicBooleanValue.java +++ b/src/main/java/com/scriptbasic/executors/rightvalues/BasicBooleanValue.java @@ -1,5 +1,6 @@ package com.scriptbasic.executors.rightvalues; +import com.scriptbasic.interfaces.BasicRuntimeException; import com.scriptbasic.spi.RightValue; public final class BasicBooleanValue extends AbstractPrimitiveRightValue { @@ -23,7 +24,7 @@ private static Boolean convertNumeric( return convertedValue; } - public static Boolean asBoolean(final RightValue originalValue) { + public static Boolean asBoolean(final RightValue originalValue) throws BasicRuntimeException { final Boolean convertedValue; if (originalValue == null) { @@ -44,13 +45,13 @@ public static Boolean asBoolean(final RightValue originalValue) { convertedValue = o != null; } } else { - convertedValue = null; + throw new BasicRuntimeException("Can not convert value to boolean"); } return convertedValue; } @Override public String toString() { - return asBoolean(this).toString(); + return getValue().toString(); } } diff --git a/src/main/java/com/scriptbasic/executors/rightvalues/BasicDoubleValue.java b/src/main/java/com/scriptbasic/executors/rightvalues/BasicDoubleValue.java index 0821df93..c9a64142 100644 --- a/src/main/java/com/scriptbasic/executors/rightvalues/BasicDoubleValue.java +++ b/src/main/java/com/scriptbasic/executors/rightvalues/BasicDoubleValue.java @@ -28,7 +28,11 @@ public static Double asDouble(final RightValue rv) if (s == null) { return null; } - return Double.parseDouble(s); + try { + return Double.parseDouble(s); + } catch (NumberFormatException e) { + throw new BasicRuntimeException("Can not convert value to double", e); + } } if (rv.isLong()) { final var l = ((BasicLongValue) rv).getValue(); diff --git a/src/main/java/com/scriptbasic/executors/rightvalues/BasicLongValue.java b/src/main/java/com/scriptbasic/executors/rightvalues/BasicLongValue.java index e96103c5..0a5641b6 100644 --- a/src/main/java/com/scriptbasic/executors/rightvalues/BasicLongValue.java +++ b/src/main/java/com/scriptbasic/executors/rightvalues/BasicLongValue.java @@ -28,7 +28,11 @@ public static Long asLong(final RightValue rv) if (s == null) { return null; } - return Long.parseLong(s); + try { + return Long.parseLong(s); + } catch (NumberFormatException e) { + throw new BasicRuntimeException("Can not convert value to long", e); + } } if (rv.isLong()) { return ((BasicLongValue) rv).getValue(); diff --git a/src/test/java/com/scriptbasic/executors/operators/TestOperators.java b/src/test/java/com/scriptbasic/executors/operators/TestOperators.java index 2e852151..69e035f9 100644 --- a/src/test/java/com/scriptbasic/executors/operators/TestOperators.java +++ b/src/test/java/com/scriptbasic/executors/operators/TestOperators.java @@ -109,8 +109,18 @@ public void testOperators() throws AnalysisException, a("a= 3.0 >= 2.0", true); a("a= 3.0 <> 2.0", true); a("a= 3.0 = 2.0", false); - // c("a= 3.0 <> 3", false); + + // Comparison between different types + a("a= 3.0 <> 3", false); a("a= 3.0 = 3", true); + a("a= \"3.0\" = 3", true); + a("a= \"3\" = 3", true); + a("a= 3 = \"3\"", true); + a("a= 3.0 = \"3\"", true); + a("a= 3 <> \"a\"", true); + a("a= 3.0 <> \"a\"", true); + a("a= true = \"a\"", false); + a("a= \"x\" <> \"x\"", false); a("a= \"x\" <> \"y\"", true); a("a= \"x\" < \"y\"", true); diff --git a/src/test/java/com/scriptbasic/rightvalues/TestConversions.java b/src/test/java/com/scriptbasic/rightvalues/TestConversions.java index 6f205192..f8a70872 100644 --- a/src/test/java/com/scriptbasic/rightvalues/TestConversions.java +++ b/src/test/java/com/scriptbasic/rightvalues/TestConversions.java @@ -31,25 +31,25 @@ public void rightValueUtilityReturnsBasicArrayValue() { } @Test - public void nullBasicBooleanValueConvertsToFalse() { + public void nullBasicBooleanValueConvertsToFalse() throws BasicRuntimeException { final var rv = new BasicJavaObjectValue(null); assertFalse(BasicBooleanValue.asBoolean(rv)); } @Test - public void trueBasicBooleanValueConvertsToTrue() { + public void trueBasicBooleanValueConvertsToTrue() throws BasicRuntimeException { final var rv = new BasicJavaObjectValue(Boolean.TRUE); assertTrue(BasicBooleanValue.asBoolean(rv)); } @Test - public void nonZeroIntegerBasicBooleanValueConvertsToTrue() { + public void nonZeroIntegerBasicBooleanValueConvertsToTrue() throws BasicRuntimeException { final var rv = new BasicJavaObjectValue(6000); assertTrue(BasicBooleanValue.asBoolean(rv)); } @Test - public void emtyStringBasicBooleanValueConvertsToFalse() { + public void emtyStringBasicBooleanValueConvertsToFalse() throws BasicRuntimeException { final var rv = new BasicStringValue(""); assertFalse(BasicBooleanValue.asBoolean(rv)); }