From 24fbc247a29aa2cf54375dc14e08235ed8f98342 Mon Sep 17 00:00:00 2001 From: summerji Date: Fri, 11 Sep 2020 12:25:24 -0700 Subject: [PATCH 01/15] add assignment operation expr, todo validate for the type --- .../engine/ast/AssignmentOperationExpr.java | 67 +++++++++++++++++++ .../generator/engine/ast/AstNodeVisitor.java | 2 + .../generator/engine/ast/OperatorKind.java | 2 + .../engine/writer/ImportWriterVisitor.java | 7 ++ .../engine/writer/JavaWriterVisitor.java | 21 ++++++ 5 files changed, 99 insertions(+) create mode 100644 src/main/java/com/google/api/generator/engine/ast/AssignmentOperationExpr.java diff --git a/src/main/java/com/google/api/generator/engine/ast/AssignmentOperationExpr.java b/src/main/java/com/google/api/generator/engine/ast/AssignmentOperationExpr.java new file mode 100644 index 0000000000..d6da9d2b28 --- /dev/null +++ b/src/main/java/com/google/api/generator/engine/ast/AssignmentOperationExpr.java @@ -0,0 +1,67 @@ +package com.google.api.generator.engine.ast; + +import com.google.auto.value.AutoValue; + +@AutoValue +public abstract class AssignmentOperationExpr implements OperationExpr { + public abstract Expr lhsExpr(); + + public abstract Expr rhsExpr(); + + public abstract OperatorKind operatorKind(); + + public abstract TypeNode type(); + + @Override + public void accept(AstNodeVisitor visitor) { + visitor.visit(this); + } + + public static AssignmentOperationExpr bitwiseExclusiveOrAndAssignmentWithExprs( + Expr lhsExpr, Expr rhsExpr) { + return builder() + .setLhsExpr(lhsExpr) + .setRhsExpr(rhsExpr) + .setOperatorKind(OperatorKind.ASSIGNMENT_BITWISE_EXCLUSIVE_OR_AND_ASSIGNMENT) + .build(); + } + + private static Builder builder() { + return new AutoValue_AssignmentOperationExpr.Builder(); + } + + @AutoValue.Builder + abstract static class Builder { + long a = (long) 129840234; + char c = 'r'; + byte e = (byte) 232341; + double f = 23.2; + double y = c ^= e; + // Private setter. + abstract Builder setLhsExpr(Expr expr); + + // Private setter. + abstract Builder setRhsExpr(Expr expr); + + // Private setter. + abstract Builder setOperatorKind(OperatorKind operator); + + // Private setter. + abstract Builder setType(TypeNode type); + + abstract AssignmentOperationExpr autoBuild(); + + private AssignmentOperationExpr build() { + AssignmentOperationExpr assignmentOperationExpr = autoBuild(); + TypeNode lhsExprType = assignmentOperationExpr.lhsExpr().type(); + TypeNode rhsExprType = assignmentOperationExpr.rhsExpr().type(); + OperatorKind operator = assignmentOperationExpr.operatorKind(); + final String errorMsg = + String.format( + "Assignment operator %s can not be applied to %s, %s.", + operator, lhsExprType.toString(), rhsExprType.toString()); + // TODO: valid type + return assignmentOperationExpr; + } + } +} diff --git a/src/main/java/com/google/api/generator/engine/ast/AstNodeVisitor.java b/src/main/java/com/google/api/generator/engine/ast/AstNodeVisitor.java index 193ac553c2..32b0642619 100644 --- a/src/main/java/com/google/api/generator/engine/ast/AstNodeVisitor.java +++ b/src/main/java/com/google/api/generator/engine/ast/AstNodeVisitor.java @@ -59,6 +59,8 @@ public interface AstNodeVisitor { public void visit(LogicalOperationExpr logicalOperationExpr); + public void visit(AssignmentOperationExpr assignmentOperationExpr); + /** =============================== COMMENT =============================== */ public void visit(LineComment lineComment); diff --git a/src/main/java/com/google/api/generator/engine/ast/OperatorKind.java b/src/main/java/com/google/api/generator/engine/ast/OperatorKind.java index 5c5a6a4642..60964f90a6 100644 --- a/src/main/java/com/google/api/generator/engine/ast/OperatorKind.java +++ b/src/main/java/com/google/api/generator/engine/ast/OperatorKind.java @@ -20,6 +20,8 @@ public enum OperatorKind { ARITHMETIC_ADDITION, LOGICAL_AND, LOGICAL_OR, + ASSIGNMENT_BITWISE_EXCLUSIVE_OR_AND_ASSIGNMENT, + ASSIGNMENT_MULTIPLY_AND_ASSIGNMENT, RELATIONAL_EQUAL_TO, RELATIONAL_NOT_EQUAL_TO, UNARY_LOGICAL_NOT, diff --git a/src/main/java/com/google/api/generator/engine/writer/ImportWriterVisitor.java b/src/main/java/com/google/api/generator/engine/writer/ImportWriterVisitor.java index e59067ec0c..e1712427c1 100644 --- a/src/main/java/com/google/api/generator/engine/writer/ImportWriterVisitor.java +++ b/src/main/java/com/google/api/generator/engine/writer/ImportWriterVisitor.java @@ -18,6 +18,7 @@ import com.google.api.generator.engine.ast.AnonymousClassExpr; import com.google.api.generator.engine.ast.ArithmeticOperationExpr; import com.google.api.generator.engine.ast.AssignmentExpr; +import com.google.api.generator.engine.ast.AssignmentOperationExpr; import com.google.api.generator.engine.ast.AstNodeVisitor; import com.google.api.generator.engine.ast.BlockComment; import com.google.api.generator.engine.ast.BlockStatement; @@ -240,6 +241,12 @@ public void visit(LogicalOperationExpr logicalOperationExpr) { logicalOperationExpr.rhsExpr().accept(this); } + @Override + public void visit(AssignmentOperationExpr assignmentOperationExpr) { + assignmentOperationExpr.lhsExpr().accept(this); + assignmentOperationExpr.rhsExpr().accept(this); + } + /** =============================== STATEMENTS =============================== */ @Override public void visit(ExprStatement exprStatement) { diff --git a/src/main/java/com/google/api/generator/engine/writer/JavaWriterVisitor.java b/src/main/java/com/google/api/generator/engine/writer/JavaWriterVisitor.java index 5ffed7bdc2..9f62a731b0 100644 --- a/src/main/java/com/google/api/generator/engine/writer/JavaWriterVisitor.java +++ b/src/main/java/com/google/api/generator/engine/writer/JavaWriterVisitor.java @@ -18,6 +18,7 @@ import com.google.api.generator.engine.ast.AnonymousClassExpr; import com.google.api.generator.engine.ast.ArithmeticOperationExpr; import com.google.api.generator.engine.ast.AssignmentExpr; +import com.google.api.generator.engine.ast.AssignmentOperationExpr; import com.google.api.generator.engine.ast.AstNodeVisitor; import com.google.api.generator.engine.ast.BlockComment; import com.google.api.generator.engine.ast.BlockStatement; @@ -114,6 +115,8 @@ public class JavaWriterVisitor implements AstNodeVisitor { private static final String OPERATOR_LOGICAL_NOT = "!"; private static final String OPERATOR_LOGICAL_AND = "&&"; private static final String OPERATOR_LOGICAL_OR = "||"; + private static final String OPERATOR_BITWISE_EXCLUSIVE_OR_AND_ASSIGNMENT = "^="; + private static final String OPERATOR_MULTIPLE_AND_ASSIGNMENT = "*="; private final StringBuffer buffer = new StringBuffer(); private final ImportWriterVisitor importWriterVisitor = new ImportWriterVisitor(); @@ -429,6 +432,15 @@ public void visit(LogicalOperationExpr logicalOperationExpr) { logicalOperationExpr.rhsExpr().accept(this); } + @Override + public void visit(AssignmentOperationExpr assignmentOperationExpr) { + assignmentOperationExpr.lhsExpr().accept(this); + space(); + operator(assignmentOperationExpr.operatorKind()); + space(); + assignmentOperationExpr.rhsExpr().accept(this); + } + /** =============================== STATEMENTS =============================== */ @Override public void visit(ExprStatement exprStatement) { @@ -912,6 +924,15 @@ private void semicolon() { private void operator(OperatorKind kind) { switch (kind) { + case ARITHMETIC_ADDITION: + buffer.append(OPERATOR_ADDITION); + break; + case ASSIGNMENT_BITWISE_EXCLUSIVE_OR_AND_ASSIGNMENT: + buffer.append(OPERATOR_BITWISE_EXCLUSIVE_OR_AND_ASSIGNMENT); + break; + case ASSIGNMENT_MULTIPLY_AND_ASSIGNMENT: + buffer.append(OPERATOR_MULTIPLE_AND_ASSIGNMENT); + break; case RELATIONAL_EQUAL_TO: buffer.append(OPERATOR_EQUAL_TO); break; From f3812cd3e34da3e9932c3f2ae1a3940428a7769b Mon Sep 17 00:00:00 2001 From: summerji Date: Mon, 14 Sep 2020 15:43:27 -0700 Subject: [PATCH 02/15] add initial unit test --- .../engine/ast/AssignmentOperationExpr.java | 15 +++-- .../engine/writer/JavaWriterVisitor.java | 3 - .../ast/AssignmentOperationExprTest.java | 55 +++++++++++++++++++ .../api/generator/engine/ast/BUILD.bazel | 1 + .../engine/writer/JavaWriterVisitorTest.java | 31 +++++++++++ 5 files changed, 97 insertions(+), 8 deletions(-) create mode 100644 src/test/java/com/google/api/generator/engine/ast/AssignmentOperationExprTest.java diff --git a/src/main/java/com/google/api/generator/engine/ast/AssignmentOperationExpr.java b/src/main/java/com/google/api/generator/engine/ast/AssignmentOperationExpr.java index d6da9d2b28..6815d6a467 100644 --- a/src/main/java/com/google/api/generator/engine/ast/AssignmentOperationExpr.java +++ b/src/main/java/com/google/api/generator/engine/ast/AssignmentOperationExpr.java @@ -23,6 +23,16 @@ public static AssignmentOperationExpr bitwiseExclusiveOrAndAssignmentWithExprs( .setLhsExpr(lhsExpr) .setRhsExpr(rhsExpr) .setOperatorKind(OperatorKind.ASSIGNMENT_BITWISE_EXCLUSIVE_OR_AND_ASSIGNMENT) + .setType(lhsExpr.type()) + .build(); + } + + public static AssignmentOperationExpr multiplyAndAssignmentWithExprs(Expr lhsExpr, Expr rhsExpr) { + return builder() + .setLhsExpr(lhsExpr) + .setRhsExpr(rhsExpr) + .setOperatorKind(OperatorKind.ASSIGNMENT_MULTIPLY_AND_ASSIGNMENT) + .setType(lhsExpr.type()) .build(); } @@ -32,11 +42,6 @@ private static Builder builder() { @AutoValue.Builder abstract static class Builder { - long a = (long) 129840234; - char c = 'r'; - byte e = (byte) 232341; - double f = 23.2; - double y = c ^= e; // Private setter. abstract Builder setLhsExpr(Expr expr); diff --git a/src/main/java/com/google/api/generator/engine/writer/JavaWriterVisitor.java b/src/main/java/com/google/api/generator/engine/writer/JavaWriterVisitor.java index 9f62a731b0..078d0bca87 100644 --- a/src/main/java/com/google/api/generator/engine/writer/JavaWriterVisitor.java +++ b/src/main/java/com/google/api/generator/engine/writer/JavaWriterVisitor.java @@ -945,9 +945,6 @@ private void operator(OperatorKind kind) { case UNARY_LOGICAL_NOT: buffer.append(OPERATOR_LOGICAL_NOT); break; - case ARITHMETIC_ADDITION: - buffer.append(OPERATOR_ADDITION); - break; case LOGICAL_AND: buffer.append(OPERATOR_LOGICAL_AND); break; diff --git a/src/test/java/com/google/api/generator/engine/ast/AssignmentOperationExprTest.java b/src/test/java/com/google/api/generator/engine/ast/AssignmentOperationExprTest.java new file mode 100644 index 0000000000..263a4177d2 --- /dev/null +++ b/src/test/java/com/google/api/generator/engine/ast/AssignmentOperationExprTest.java @@ -0,0 +1,55 @@ +package com.google.api.generator.engine.ast; + +import org.junit.Test; + +public class AssignmentOperationExprTest { + /** ==================== Multiply And Assignment Operators: LHS data type is numeric ======================= */ + @Test + public void multiplyAndAssignmentOperationExpr_validNumericMatched() { + int a = 1; + double b = 2; + char c = 'e'; + float f = 5.99f; + short s = 5000; + long l = 15000000000L; + boolean bool = false; + a *= new Integer(4); + int we = a; + VariableExpr lhsExpr = createVariableExpr(TypeNode.INT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.INT, "y"); + AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + // No exception thrown, so we succeeded. + } + + @Test + public void multiplyAndAssignmentOperationExpr_validNumericUnmatched() { + VariableExpr lhsExpr = createVariableExpr(TypeNode.INT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.LONG, "y"); + AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + // No exception thrown, so we succeeded. + } + + @Test + public void multiplyAndAssignmentOperationExpr_validNumericMatchedBoxedType() { + VariableExpr lhsExpr = createVariableExpr(TypeNode.INT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "y"); + AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + // No exception thrown, so we succeeded. + } + + @Test + public void multiplyAndAssignmentOperationExpr_validNumericUnmatchedBoxedType() { + VariableExpr lhsExpr = createVariableExpr(TypeNode.INT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "y"); + AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + // No exception thrown, so we succeeded. + } + + + private VariableExpr createVariableExpr(TypeNode type, String name) { + Variable variable = Variable.builder().setName(name).setType(type).build(); + VariableExpr variableExpr = VariableExpr.withVariable(variable); + return variableExpr; + } + +} diff --git a/src/test/java/com/google/api/generator/engine/ast/BUILD.bazel b/src/test/java/com/google/api/generator/engine/ast/BUILD.bazel index 323b5e1dc1..dda0ab0ac3 100644 --- a/src/test/java/com/google/api/generator/engine/ast/BUILD.bazel +++ b/src/test/java/com/google/api/generator/engine/ast/BUILD.bazel @@ -38,6 +38,7 @@ TESTS = [ "UnaryOperationExprTest", "RelationalOperationExprTest", "LogicalOperationExprTest", + "AssignmentOperationExprTest", ] filegroup( diff --git a/src/test/java/com/google/api/generator/engine/writer/JavaWriterVisitorTest.java b/src/test/java/com/google/api/generator/engine/writer/JavaWriterVisitorTest.java index 408f905bd9..ed0f141a01 100644 --- a/src/test/java/com/google/api/generator/engine/writer/JavaWriterVisitorTest.java +++ b/src/test/java/com/google/api/generator/engine/writer/JavaWriterVisitorTest.java @@ -21,6 +21,7 @@ import com.google.api.generator.engine.ast.AnonymousClassExpr; import com.google.api.generator.engine.ast.ArithmeticOperationExpr; import com.google.api.generator.engine.ast.AssignmentExpr; +import com.google.api.generator.engine.ast.AssignmentOperationExpr; import com.google.api.generator.engine.ast.BlockComment; import com.google.api.generator.engine.ast.BlockStatement; import com.google.api.generator.engine.ast.CastExpr; @@ -2130,6 +2131,36 @@ public void writeLogicalOperationExpr_logicalOr() { assertThat(writerVisitor.write()).isEqualTo("isGood || isValid()"); } + @Test + public void writeAssignmentOperationExpr_multiplyAndAssignment() { + VariableExpr lhsExpr = VariableExpr.withVariable(createVariable("h", TypeNode.INT)); + ValueExpr rhsExpr = ValueExpr.withValue(PrimitiveValue.builder().setType(TypeNode.INT).setValue("1000003").build()); + AssignmentOperationExpr assignmentOperationExpr = AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + assignmentOperationExpr.accept(writerVisitor); + assertThat(writerVisitor.write()).isEqualTo("h *= 1000003"); + } + + @Test + public void writeAssignmentOperationExpr_bitwiseExclusiveOrAndAssignment() { + VariableExpr lhsExpr = VariableExpr.withVariable(createVariable("h", TypeNode.INT)); + TypeNode objectType = TypeNode.withReference( + VaporReference.builder() + .setName("Objects") + .setPakkage("java.lang.Object") + .build()); + MethodInvocationExpr rhsExpr = MethodInvocationExpr + .builder() + .setReturnType(TypeNode.INT) + .setMethodName("hashCode") + .setStaticReferenceType(objectType) + .setArguments(Arrays.asList(VariableExpr.withVariable(createVariable("fixedValue", TypeNode.OBJECT)))) + .build(); + AssignmentOperationExpr assignmentOperationExpr = AssignmentOperationExpr.bitwiseExclusiveOrAndAssignmentWithExprs(lhsExpr, rhsExpr); + assignmentOperationExpr.accept(writerVisitor); + assertThat(writerVisitor.write()).isEqualTo("h ^= Objects.hashCode(fixedValue)"); + } + + private static String createLines(int numLines) { return new String(new char[numLines]).replace("\0", "%s"); } From 6e24221d39da20f35545f0006495c97da50a76d9 Mon Sep 17 00:00:00 2001 From: summerji Date: Tue, 15 Sep 2020 13:38:20 -0700 Subject: [PATCH 03/15] Add more unit test --- .../ast/AssignmentOperationExprTest.java | 127 +++++++++++++++++- 1 file changed, 124 insertions(+), 3 deletions(-) diff --git a/src/test/java/com/google/api/generator/engine/ast/AssignmentOperationExprTest.java b/src/test/java/com/google/api/generator/engine/ast/AssignmentOperationExprTest.java index 263a4177d2..bbd89a0b6b 100644 --- a/src/test/java/com/google/api/generator/engine/ast/AssignmentOperationExprTest.java +++ b/src/test/java/com/google/api/generator/engine/ast/AssignmentOperationExprTest.java @@ -3,7 +3,8 @@ import org.junit.Test; public class AssignmentOperationExprTest { - /** ==================== Multiply And Assignment Operators: LHS data type is numeric ======================= */ + /** ========================= Multiply And Assignment Operators =============================== */ + /** =========== Multiply And Assignment Operators: LHS data type is numeric ================= */ @Test public void multiplyAndAssignmentOperationExpr_validNumericMatched() { int a = 1; @@ -13,8 +14,13 @@ public void multiplyAndAssignmentOperationExpr_validNumericMatched() { short s = 5000; long l = 15000000000L; boolean bool = false; - a *= new Integer(4); - int we = a; + Integer ao = new Integer(4); + Float fo = new Float(f); + Boolean bo = new Boolean(false); + int[] ar = new int[3]; + String word = "avc"; + boolean we = a < word; + // No need swap test case. VariableExpr lhsExpr = createVariableExpr(TypeNode.INT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.INT, "y"); AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); @@ -23,6 +29,7 @@ public void multiplyAndAssignmentOperationExpr_validNumericMatched() { @Test public void multiplyAndAssignmentOperationExpr_validNumericUnmatched() { + // No need swap test case. VariableExpr lhsExpr = createVariableExpr(TypeNode.INT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.LONG, "y"); AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); @@ -31,6 +38,7 @@ public void multiplyAndAssignmentOperationExpr_validNumericUnmatched() { @Test public void multiplyAndAssignmentOperationExpr_validNumericMatchedBoxedType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_validNumericBoxedWithMatchType". VariableExpr lhsExpr = createVariableExpr(TypeNode.INT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "y"); AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); @@ -39,12 +47,125 @@ public void multiplyAndAssignmentOperationExpr_validNumericMatchedBoxedType() { @Test public void multiplyAndAssignmentOperationExpr_validNumericUnmatchedBoxedType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_validNumericBoxedWithUnmatchedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.INT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "y"); AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); // No exception thrown, so we succeeded. } + @Test + public void multiplyAndAssignmentOperationExpr_invalidNumericWithBooleanBoxedType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_invalidBooleanBoxedWithNumericType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.INT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.BOOLEAN_OBJECT, "y"); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + @Test + public void multiplyAndAssignmentOperationExpr_invalidNumericWithBooleanType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_invalidNumericWithBooleanType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.INT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.BOOLEAN, "y"); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + @Test + public void multiplyAndAssignmentOperationExpr_invalidNumericWithReferenceType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_invalidReferencedWithNumericType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.INT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.STRING, "y"); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + @Test + public void multiplyAndAssignmentOperationExpr_invalidNumericWithNewObject() { + // Swap test case in "multiplyAndAssignmentOperationExpr_invalidNewObjectWithNumeric". + VariableExpr lhsExpr = createVariableExpr(TypeNode.INT, "x"); + NewObjectExpr rhsExpr = NewObjectExpr.withType(TypeNode.OBJECT); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + /** ==== Multiply And Assignment Operators: LHS data type is boolean and its boxed type ===== */ + + @Test + public void multiplyAndAssignmentOperationExpr_invalidNumericWithBooleanType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_invalidNumericWithBooleanType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.INT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.BOOLEAN, "y"); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + @Test + public void multiplyAndAssignmentOperationExpr_invalidBooleanBoxedWithNumericType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_invalidNumericWithBooleanBoxedType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.BOOLEAN_OBJECT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.INT, "y"); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + /** ======== Multiply And Assignment Operators: LHS data type is Numeric Box Type ============ */ + @Test + public void multiplyAndAssignmentOperationExpr_validNumericBoxedWithMatchType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_validNumericMatchedBoxedType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.INT, "y"); + AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + // No exception thrown, so we succeeded. + } + + @Test + public void multiplyAndAssignmentOperationExpr_validNumericBoxedWithUnmatchedType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_validNumericUnmatchedBoxedType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.SHORT, "y"); + AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + // No exception thrown, so we succeeded. + } + + /** ======== Multiply And Assignment Operators: LHS data type is Reference Type ============ */ + @Test + public void multiplyAndAssignmentOperationExpr_invalidReferencedWithNumericType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_invalidNumericWithReferenceType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.STRING, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.DOUBLE, "y"); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + /** ======== Multiply And Assignment Operators: LHS data type is Object Type ============ */ + @Test + public void multiplyAndAssignmentOperationExpr_invalidNumericWithNewObject() { + // Swap test case in "multiplyAndAssignmentOperationExpr_invalidNumericWithNewObject". + NewObjectExpr lhsExpr = NewObjectExpr.withType(TypeNode.OBJECT); + VariableExpr rhsExpr = createVariableExpr(TypeNode.INT, "x"); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + /** ======== Multiply And Assignment Operators: LHS data type is Null Type ============ */ + @Test + public void multiplyAndAssignmentOperationExpr_invalidNullWithNumericType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_invalidNumericWithNullType". + ValueExpr lhsExpr = ValueExpr.withValue(NullObjectValue.create()); + VariableExpr rhsExpr = createVariableExpr(TypeNode.FLOAT, "y"); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + private VariableExpr createVariableExpr(TypeNode type, String name) { Variable variable = Variable.builder().setName(name).setType(type).build(); From 8334fd38d7302e01ab80d37c26c6756d6c9221c2 Mon Sep 17 00:00:00 2001 From: summerji Date: Tue, 15 Sep 2020 14:50:57 -0700 Subject: [PATCH 04/15] add type-checking for *= --- .../engine/ast/AssignmentOperationExpr.java | 19 +++++++++- .../ast/AssignmentOperationExprTest.java | 38 +++++++++---------- .../engine/writer/JavaWriterVisitorTest.java | 35 +++++++++-------- 3 files changed, 56 insertions(+), 36 deletions(-) diff --git a/src/main/java/com/google/api/generator/engine/ast/AssignmentOperationExpr.java b/src/main/java/com/google/api/generator/engine/ast/AssignmentOperationExpr.java index 6815d6a467..5c5b81dd9e 100644 --- a/src/main/java/com/google/api/generator/engine/ast/AssignmentOperationExpr.java +++ b/src/main/java/com/google/api/generator/engine/ast/AssignmentOperationExpr.java @@ -1,6 +1,7 @@ package com.google.api.generator.engine.ast; import com.google.auto.value.AutoValue; +import com.google.common.base.Preconditions; @AutoValue public abstract class AssignmentOperationExpr implements OperationExpr { @@ -65,8 +66,24 @@ private AssignmentOperationExpr build() { String.format( "Assignment operator %s can not be applied to %s, %s.", operator, lhsExprType.toString(), rhsExprType.toString()); - // TODO: valid type + if (operator.equals(OperatorKind.ASSIGNMENT_MULTIPLY_AND_ASSIGNMENT)) { + Preconditions.checkState( + isValidMultiplyAndAssignmentType(lhsExprType, rhsExprType), errorMsg); + } return assignmentOperationExpr; } + + private boolean isValidMultiplyAndAssignmentType(TypeNode lhsType, TypeNode rhsType) { + if (lhsType.equals(rhsType)) { + return true; + } + if (TypeNode.isNumericType(lhsType)) { + return TypeNode.isNumericType(rhsType); + } + if (TypeNode.isBoxedType(lhsType)) { + return rhsType.equals(TypeNode.NULL); + } + return false; + } } } diff --git a/src/test/java/com/google/api/generator/engine/ast/AssignmentOperationExprTest.java b/src/test/java/com/google/api/generator/engine/ast/AssignmentOperationExprTest.java index bbd89a0b6b..34e476777d 100644 --- a/src/test/java/com/google/api/generator/engine/ast/AssignmentOperationExprTest.java +++ b/src/test/java/com/google/api/generator/engine/ast/AssignmentOperationExprTest.java @@ -1,5 +1,7 @@ package com.google.api.generator.engine.ast; +import static org.junit.Assert.assertThrows; + import org.junit.Test; public class AssignmentOperationExprTest { @@ -7,20 +9,21 @@ public class AssignmentOperationExprTest { /** =========== Multiply And Assignment Operators: LHS data type is numeric ================= */ @Test public void multiplyAndAssignmentOperationExpr_validNumericMatched() { - int a = 1; - double b = 2; - char c = 'e'; - float f = 5.99f; - short s = 5000; - long l = 15000000000L; - boolean bool = false; - Integer ao = new Integer(4); - Float fo = new Float(f); + // int a = 1; + // double b = 2; + // char c = 'e'; + // float f = 5.99f; + // short s = 5000; + // long l = 15000000000L; + // boolean bool = false; + // Integer ao = new Integer(4); + // Float fo = new Float(f); Boolean bo = new Boolean(false); - int[] ar = new int[3]; - String word = "avc"; - boolean we = a < word; + // int[] ar = new int[3]; + // String word = "avc"; + // boolean we = a < word; // No need swap test case. + // boolean c = bo < new Object(); VariableExpr lhsExpr = createVariableExpr(TypeNode.INT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.INT, "y"); AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); @@ -95,12 +98,11 @@ public void multiplyAndAssignmentOperationExpr_invalidNumericWithNewObject() { } /** ==== Multiply And Assignment Operators: LHS data type is boolean and its boxed type ===== */ - @Test - public void multiplyAndAssignmentOperationExpr_invalidNumericWithBooleanType() { + public void multiplyAndAssignmentOperationExpr_invalidBooleanWithNumericType() { // Swap test case in "multiplyAndAssignmentOperationExpr_invalidNumericWithBooleanType". - VariableExpr lhsExpr = createVariableExpr(TypeNode.INT, "x"); - VariableExpr rhsExpr = createVariableExpr(TypeNode.BOOLEAN, "y"); + VariableExpr lhsExpr = createVariableExpr(TypeNode.BOOLEAN, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.INT, "y"); assertThrows( IllegalStateException.class, () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); @@ -147,7 +149,7 @@ public void multiplyAndAssignmentOperationExpr_invalidReferencedWithNumericType( } /** ======== Multiply And Assignment Operators: LHS data type is Object Type ============ */ @Test - public void multiplyAndAssignmentOperationExpr_invalidNumericWithNewObject() { + public void multiplyAndAssignmentOperationExpr_invalidNewObjectWithNumeric() { // Swap test case in "multiplyAndAssignmentOperationExpr_invalidNumericWithNewObject". NewObjectExpr lhsExpr = NewObjectExpr.withType(TypeNode.OBJECT); VariableExpr rhsExpr = createVariableExpr(TypeNode.INT, "x"); @@ -166,11 +168,9 @@ public void multiplyAndAssignmentOperationExpr_invalidNullWithNumericType() { () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); } - private VariableExpr createVariableExpr(TypeNode type, String name) { Variable variable = Variable.builder().setName(name).setType(type).build(); VariableExpr variableExpr = VariableExpr.withVariable(variable); return variableExpr; } - } diff --git a/src/test/java/com/google/api/generator/engine/writer/JavaWriterVisitorTest.java b/src/test/java/com/google/api/generator/engine/writer/JavaWriterVisitorTest.java index ed0f141a01..31f640dc32 100644 --- a/src/test/java/com/google/api/generator/engine/writer/JavaWriterVisitorTest.java +++ b/src/test/java/com/google/api/generator/engine/writer/JavaWriterVisitorTest.java @@ -2134,8 +2134,11 @@ public void writeLogicalOperationExpr_logicalOr() { @Test public void writeAssignmentOperationExpr_multiplyAndAssignment() { VariableExpr lhsExpr = VariableExpr.withVariable(createVariable("h", TypeNode.INT)); - ValueExpr rhsExpr = ValueExpr.withValue(PrimitiveValue.builder().setType(TypeNode.INT).setValue("1000003").build()); - AssignmentOperationExpr assignmentOperationExpr = AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + ValueExpr rhsExpr = + ValueExpr.withValue( + PrimitiveValue.builder().setType(TypeNode.INT).setValue("1000003").build()); + AssignmentOperationExpr assignmentOperationExpr = + AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); assignmentOperationExpr.accept(writerVisitor); assertThat(writerVisitor.write()).isEqualTo("h *= 1000003"); } @@ -2143,24 +2146,24 @@ public void writeAssignmentOperationExpr_multiplyAndAssignment() { @Test public void writeAssignmentOperationExpr_bitwiseExclusiveOrAndAssignment() { VariableExpr lhsExpr = VariableExpr.withVariable(createVariable("h", TypeNode.INT)); - TypeNode objectType = TypeNode.withReference( - VaporReference.builder() - .setName("Objects") - .setPakkage("java.lang.Object") - .build()); - MethodInvocationExpr rhsExpr = MethodInvocationExpr - .builder() - .setReturnType(TypeNode.INT) - .setMethodName("hashCode") - .setStaticReferenceType(objectType) - .setArguments(Arrays.asList(VariableExpr.withVariable(createVariable("fixedValue", TypeNode.OBJECT)))) - .build(); - AssignmentOperationExpr assignmentOperationExpr = AssignmentOperationExpr.bitwiseExclusiveOrAndAssignmentWithExprs(lhsExpr, rhsExpr); + TypeNode objectType = + TypeNode.withReference( + VaporReference.builder().setName("Objects").setPakkage("java.lang.Object").build()); + MethodInvocationExpr rhsExpr = + MethodInvocationExpr.builder() + .setReturnType(TypeNode.INT) + .setMethodName("hashCode") + .setStaticReferenceType(objectType) + .setArguments( + Arrays.asList( + VariableExpr.withVariable(createVariable("fixedValue", TypeNode.OBJECT)))) + .build(); + AssignmentOperationExpr assignmentOperationExpr = + AssignmentOperationExpr.bitwiseExclusiveOrAndAssignmentWithExprs(lhsExpr, rhsExpr); assignmentOperationExpr.accept(writerVisitor); assertThat(writerVisitor.write()).isEqualTo("h ^= Objects.hashCode(fixedValue)"); } - private static String createLines(int numLines) { return new String(new char[numLines]).replace("\0", "%s"); } From c24a9d677e957d1a17553974359f6ecada2b993d Mon Sep 17 00:00:00 2001 From: summerji Date: Tue, 15 Sep 2020 18:46:55 -0700 Subject: [PATCH 05/15] Complete for *= tests --- .../engine/ast/AssignmentOperationExpr.java | 31 +- .../api/generator/engine/ast/TypeNode.java | 3 +- .../ast/AssignmentOperationExprTest.java | 683 +++++++++++++++++- 3 files changed, 702 insertions(+), 15 deletions(-) diff --git a/src/main/java/com/google/api/generator/engine/ast/AssignmentOperationExpr.java b/src/main/java/com/google/api/generator/engine/ast/AssignmentOperationExpr.java index 5c5b81dd9e..55fe804416 100644 --- a/src/main/java/com/google/api/generator/engine/ast/AssignmentOperationExpr.java +++ b/src/main/java/com/google/api/generator/engine/ast/AssignmentOperationExpr.java @@ -70,20 +70,39 @@ private AssignmentOperationExpr build() { Preconditions.checkState( isValidMultiplyAndAssignmentType(lhsExprType, rhsExprType), errorMsg); } + if (operator.equals(OperatorKind.ASSIGNMENT_BITWISE_EXCLUSIVE_OR_AND_ASSIGNMENT)) { + Preconditions.checkState( + isValidBitwiseExclusiveOrAndAssignmentType(lhsExprType, rhsExprType), errorMsg); + } return assignmentOperationExpr; } private boolean isValidMultiplyAndAssignmentType(TypeNode lhsType, TypeNode rhsType) { - if (lhsType.equals(rhsType)) { - return true; - } - if (TypeNode.isNumericType(lhsType)) { + if (TypeNode.isNumericType(lhsType) && !TypeNode.isBoxedType(lhsType)) { return TypeNode.isNumericType(rhsType); } - if (TypeNode.isBoxedType(lhsType)) { - return rhsType.equals(TypeNode.NULL); + if (lhsType.equals(TypeNode.INT_OBJECT)) { + return TypeNode.isNumericType(rhsType) + && !(rhsType.equals(TypeNode.LONG) + || rhsType.equals(TypeNode.FLOAT) + || rhsType.equals(TypeNode.DOUBLE)); + } + if (lhsType.equals(TypeNode.LONG_OBJECT)) { + return TypeNode.isNumericType(rhsType) + && !(rhsType.equals(TypeNode.FLOAT) || rhsType.equals(TypeNode.DOUBLE)); + } + if (lhsType.equals(TypeNode.FLOAT_OBJECT)) { + return TypeNode.isNumericType(rhsType) && !rhsType.equals(TypeNode.DOUBLE); + } + if (lhsType.equals(TypeNode.DOUBLE_OBJECT)) { + return TypeNode.isNumericType(rhsType); } return false; } + + // TODO(summerji): Complete the type-checking for ^= and unit test. + private boolean isValidBitwiseExclusiveOrAndAssignmentType(TypeNode lhsType, TypeNode rhsType) { + return true; + } } } diff --git a/src/main/java/com/google/api/generator/engine/ast/TypeNode.java b/src/main/java/com/google/api/generator/engine/ast/TypeNode.java index fbebef1b5d..27396ffb85 100644 --- a/src/main/java/com/google/api/generator/engine/ast/TypeNode.java +++ b/src/main/java/com/google/api/generator/engine/ast/TypeNode.java @@ -145,7 +145,8 @@ public static boolean isNumericType(TypeNode type) { || type.equals(TypeNode.DOUBLE) || type.equals(TypeNode.SHORT) || type.equals(TypeNode.FLOAT) - || type.equals(TypeNode.CHAR); + || type.equals(TypeNode.CHAR) + || type.equals(TypeNode.BYTE); } public static boolean isBoxedType(TypeNode type) { diff --git a/src/test/java/com/google/api/generator/engine/ast/AssignmentOperationExprTest.java b/src/test/java/com/google/api/generator/engine/ast/AssignmentOperationExprTest.java index 34e476777d..afdc61a9be 100644 --- a/src/test/java/com/google/api/generator/engine/ast/AssignmentOperationExprTest.java +++ b/src/test/java/com/google/api/generator/engine/ast/AssignmentOperationExprTest.java @@ -16,14 +16,140 @@ public void multiplyAndAssignmentOperationExpr_validNumericMatched() { // short s = 5000; // long l = 15000000000L; // boolean bool = false; + // byte bbb = '1'; + // Byte bbbo = new Byte(bbb); // Integer ao = new Integer(4); // Float fo = new Float(f); - Boolean bo = new Boolean(false); + // Character co = new Character('c'); + // Double doo = new Double(122.3); + // Boolean bo = new Boolean(false); + // Long lo = new Long(4l); + // Short so = new Short(s); // int[] ar = new int[3]; // String word = "avc"; - // boolean we = a < word; + // a *= b; + // a *= c; + // a *= f; + // a *= s; + // a *= fo; + // a *= co; + // a *= doo; + // a *= ao; + // a *= bbb; + // a *= bbbo; + // // a *= bool; invalid + // l *= a; + // l *= b; + // l *= c; + // l *= f; + // l *= s; + // l *= ao; + // l *= co; + // l *= fo; + // l *= doo; + // s *= a; + // s *= l; + // s *= f; + // s *= c; + // s *= b; + // ao *= a; + // ao *= s; + // ao *= f; + // ao *= b; + // ao *= c; + // ao *= l; + // ao *= bbb; + // ao *= co; + // ao *= fo; + // ao *= doo; + // ao *= lo; + // ao *= bbbo; + // doo *= a; + // doo *= b; + // doo *= c; + // doo *= f; + // doo *= s; + // doo *= l; + // doo *= bbb; + // doo *= ao; + // doo *= fo; + // doo *= co; + // doo *= bbbo; + // co *= a; + // co *= b; + // co *= f; + // co *= s; + // co *= bbb; + // co *= l; + // co *= c; + // co *= ao; + // co *= bo; + // co *= fo; + // lo *= ao; + // lo *= a; + // lo *= l; + // lo *= c; + // lo *= s; + // lo *= bbb; + // lo *= doo; + // lo *= fo; + // lo *= f; + // lo *= b; + // lo *= co; + // lo *= bbbo; + // lo *= lo; + // lo *= co; + // lo *= so; + // so *= a; + // so *= b; + // so *= f; + // so *= l; + // so *= so; + // so *= s; + // so *= bbb; + // so *= ao; + // so *= fo; + // so *= doo; + // so *= co; + // so *= ao; + // bbbo *= a; + // bbbo *= f; + // bbbo *= b; + // bbbo *= c; + // bbbo *= s; + // bbbo *= l; + // bbbo *= ao; + // bbbo *= fo; + // bbbo *= doo; + // fo *= ao; + // fo *= fo; + // fo *= co; + // fo *= a; + // fo *= a; + // fo *= fo; + // fo *= c; + // fo *= co; + // fo *= bbbo; + // fo *= b; + // fo *= lo; + // fo *= doo; + // fo *= lo; + // fo *= co; + // fo *= so; + // fo *= a; + // doo *= a; + // doo *= b; + // doo *= f; + // doo *= s; + // doo *= c; + // doo *= l; + // doo *= bbb; + // doo *= ao; + // doo *= fo; + // doo *= so; + // doo *= bbbo; + // boolean wpeo = (fo *= co) instanceof Float; // No need swap test case. - // boolean c = bo < new Object(); VariableExpr lhsExpr = createVariableExpr(TypeNode.INT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.INT, "y"); AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); @@ -41,7 +167,7 @@ public void multiplyAndAssignmentOperationExpr_validNumericUnmatched() { @Test public void multiplyAndAssignmentOperationExpr_validNumericMatchedBoxedType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_validNumericBoxedWithMatchType". + // Swap test case in "multiplyAndAssignmentOperationExpr_validIntegerMatchedBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.INT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "y"); AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); @@ -50,13 +176,67 @@ public void multiplyAndAssignmentOperationExpr_validNumericMatchedBoxedType() { @Test public void multiplyAndAssignmentOperationExpr_validNumericUnmatchedBoxedType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_validNumericBoxedWithUnmatchedType". + // Swap test case in "multiplyAndAssignmentOperationExpr_validIntegerBoxedWithShortType". VariableExpr lhsExpr = createVariableExpr(TypeNode.INT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "y"); AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); // No exception thrown, so we succeeded. } + @Test + public void multiplyAndAssignmentOperationExpr_validNumericWithFloatType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithFloatType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.FLOAT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "y"); + AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + // No exception thrown, so we succeeded. + } + + @Test + public void multiplyAndAssignmentOperationExpr_validDoubleWithIntegerBoxedType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithDoubleType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.DOUBLE, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "y"); + AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + // No exception thrown, so we succeeded. + } + + @Test + public void multiplyAndAssignmentOperationExpr_validDoubleWithLongBoxedType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_invalidLongBoxedWithDoubleType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.DOUBLE, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.LONG_OBJECT, "y"); + AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + // No exception thrown, so we succeeded. + } + + @Test + public void multiplyAndAssignmentOperationExpr_validLongWithIntegerBoxedType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithLongType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.LONG, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "y"); + AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + // No exception thrown, so we succeeded. + } + + @Test + public void multiplyAndAssignmentOperationExpr_validIntegerWithFloatBoxedType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_validFloatBoxedWithIntegerType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.INT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "y"); + AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + // No exception thrown, so we succeeded. + } + + @Test + public void multiplyAndAssignmentOperationExpr_validFloatWithLongBoxedType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_invalidLongBoxedWithFloatType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.FLOAT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.LONG_OBJECT, "y"); + AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + // No exception thrown, so we succeeded. + } + @Test public void multiplyAndAssignmentOperationExpr_invalidNumericWithBooleanBoxedType() { // Swap test case in "multiplyAndAssignmentOperationExpr_invalidBooleanBoxedWithNumericType". @@ -118,9 +298,10 @@ public void multiplyAndAssignmentOperationExpr_invalidBooleanBoxedWithNumericTyp () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); } - /** ======== Multiply And Assignment Operators: LHS data type is Numeric Box Type ============ */ + /** ======== Multiply And Assignment Operators: LHS data type is Integer Box Type ============ */ + // RHS should be int, char, short, byte or these types' boxed types. @Test - public void multiplyAndAssignmentOperationExpr_validNumericBoxedWithMatchType() { + public void multiplyAndAssignmentOperationExpr_validIntegerMatchedBoxedType() { // Swap test case in "multiplyAndAssignmentOperationExpr_validNumericMatchedBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.INT, "y"); @@ -129,7 +310,7 @@ public void multiplyAndAssignmentOperationExpr_validNumericBoxedWithMatchType() } @Test - public void multiplyAndAssignmentOperationExpr_validNumericBoxedWithUnmatchedType() { + public void multiplyAndAssignmentOperationExpr_validIntegerBoxedWithShortType() { // Swap test case in "multiplyAndAssignmentOperationExpr_validNumericUnmatchedBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.SHORT, "y"); @@ -137,6 +318,374 @@ public void multiplyAndAssignmentOperationExpr_validNumericBoxedWithUnmatchedTyp // No exception thrown, so we succeeded. } + @Test + public void multiplyAndAssignmentOperationExpr_validIntegerBoxedWithShortBoxedType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_validShortBoxedWithIntegerBoxedType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.SHORT_OBJECT, "y"); + AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + // No exception thrown, so we succeeded. + } + + @Test + public void multiplyAndAssignmentOperationExpr_validIntegerBoxedWithCharacterBoxedType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_validShortBoxedWithIntegerBoxedType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.CHAR_OBJECT, "y"); + AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + // No exception thrown, so we succeeded. + } + + @Test + public void multiplyAndAssignmentOperationExpr_validIntegerBoxedWithByteBoxedType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_validByteBoxedWithIntegerBoxedType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.BYTE_OBJECT, "y"); + AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + // No exception thrown, so we succeeded. + } + + @Test + public void multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithFloatType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_validNumericWithFloatType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.FLOAT, "y"); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + @Test + public void multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithFloatBoxedType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_validFloatBoxedWithIntegerBoxedType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "y"); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + @Test + public void multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithDoubleType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_validDoubleWithIntegerBoxedType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.DOUBLE, "y"); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + @Test + public void multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithDoubleBoxedType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_validDoubleBoxedWithIntegerBoxedType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.DOUBLE_OBJECT, "y"); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + @Test + public void multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithLongType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_validLongWithIntegerBoxedType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.LONG, "y"); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + @Test + public void multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithLongBoxedType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_validLongBoxedWithIntegerBoxedType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.LONG_OBJECT, "y"); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + /** ==== Multiply And Assignment Operators: LHS data type is Float boxed type ====== */ + // RHS could be numeric or numeric boxed type, beside double and its boxed type. + @Test + public void multiplyAndAssignmentOperationExpr_validFloatBoxedWithIntegerType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_validIntegerWithFloatBoxedType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.INT, "y"); + AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + // No exception thrown, so we succeeded. + } + + @Test + public void multiplyAndAssignmentOperationExpr_validFloatBoxedWithIntegerBoxedType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithFloatBoxedType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "y"); + AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + // No exception thrown, so we succeeded. + } + + @Test + public void multiplyAndAssignmentOperationExpr_validFloatBoxedWithCharBoxedType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_invalidCharBoxedWithFloatBoxedType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.CHAR_OBJECT, "y"); + AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + // No exception thrown, so we succeeded. + } + + @Test + public void multiplyAndAssignmentOperationExpr_validFloatBoxedWithByteBoxedType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_invalidByteBoxedWithFloatBoxedType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.BYTE_OBJECT, "y"); + AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + // No exception thrown, so we succeeded. + } + + @Test + public void multiplyAndAssignmentOperationExpr_validFloatBoxedWithLongBoxedType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_invalidLongBoxedWithFloatBoxedType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.LONG_OBJECT, "y"); + AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + // No exception thrown, so we succeeded. + } + + @Test + public void multiplyAndAssignmentOperationExpr_invalidFloatBoxedWithDoubleBoxedType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_validDoubleBoxedWithFloatBoxedType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.DOUBLE_OBJECT, "y"); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + @Test + public void multiplyAndAssignmentOperationExpr_invalidFloatBoxedWithObjectType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_invalidFloatBoxedWithObjectType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "x"); + NewObjectExpr rhsExpr = NewObjectExpr.withType(TypeNode.OBJECT); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + @Test + public void multiplyAndAssignmentOperationExpr_invalidFloatBoxedWithNullType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_invalidNullWithFloatBoxedType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "x"); + ValueExpr rhsExpr = ValueExpr.withValue(NullObjectValue.create()); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + @Test + public void multiplyAndAssignmentOperationExpr_invalidFloatBoxedWithReferenceType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_invalidReferenceWithFloatBoxedType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.STRING, "y"); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + /** ==== Multiply And Assignment Operators: LHS data type is Short/Char/Byte Boxed Type ====== */ + // RHS has no valid type. + @Test + public void multiplyAndAssignmentOperationExpr_invalidByteBoxedWithIntegerBoxedType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_validIntegerBoxedWithByteBoxedType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.BYTE_OBJECT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "y"); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + @Test + public void multiplyAndAssignmentOperationExpr_invalidShortBoxedWithIntegerBoxedType() { + // Swap test case in + // "multiplyAndAssignmentOperationExpr_validCharacterBoxedWithIntegerBoxedType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.SHORT_OBJECT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "y"); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + @Test + public void multiplyAndAssignmentOperationExpr_validCharacterBoxedWithIntegerBoxedType() { + // Swap test case in + // "multiplyAndAssignmentOperationExpr_validIntegerBoxedWithCharacterBoxedType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.CHAR_OBJECT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "y"); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + @Test + public void multiplyAndAssignmentOperationExpr_invalidCharBoxedWithFloatBoxedType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithFloatBoxedType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.CHAR_OBJECT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "y"); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + @Test + public void multiplyAndAssignmentOperationExpr_invalidByteBoxedWithFloatBoxedType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_validFloatBoxedWithByteBoxedType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.BYTE_OBJECT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "y"); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + /** ======== Multiply And Assignment Operators: LHS data type is Double Boxed Type ============ */ + // RHS could be any numeric type or numeric boxed type. + @Test + public void multiplyAndAssignmentOperationExpr_validDoubleBoxedWithIntegerBoxedType() { + // Swap test case in + // "multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithDoubleBoxedType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.DOUBLE_OBJECT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "y"); + AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + // No exception thrown, so we succeeded. + } + + @Test + public void multiplyAndAssignmentOperationExpr_validDoubleBoxedWithFloatBoxedType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_invalidFloatBoxedWithDoubleBoxedType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.DOUBLE_OBJECT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "y"); + AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + // No exception thrown, so we succeeded. + } + + @Test + public void multiplyAndAssignmentOperationExpr_validDoubleBoxedWithLongBoxedType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_invalidLongBoxedWithDoubleBoxedType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.DOUBLE_OBJECT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.LONG_OBJECT, "y"); + AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + // No exception thrown, so we succeeded. + } + + @Test + public void multiplyAndAssignmentOperationExpr_invalidDoubleBoxedWithReferenceType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_invalidReferenceWithDoubleBoxedType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.DOUBLE_OBJECT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.STRING, "y"); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + @Test + public void multiplyAndAssignmentOperationExpr_invalidDoubleBoxedWithNullType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_invalidNullWithDoubleBoxedType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.DOUBLE_OBJECT, "x"); + ValueExpr rhsExpr = ValueExpr.withValue(NullObjectValue.create()); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + @Test + public void multiplyAndAssignmentOperationExpr_invalidDoubleBoxedWithOjectType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_invalidObjectWithDoubleBoxedType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.DOUBLE_OBJECT, "x"); + NewObjectExpr rhsExpr = NewObjectExpr.withType(TypeNode.OBJECT); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + /** ======== Multiply And Assignment Operators: LHS data type is Long boxed type ============ */ + @Test + public void multiplyAndAssignmentOperationExpr_validLongBoxedWithIntegerBoxedType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithLongBoxedType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.LONG_OBJECT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "y"); + AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + // No exception thrown, so we succeeded. + } + + @Test + public void multiplyAndAssignmentOperationExpr_invalidLongBoxedWithFloatBoxedType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_validFloatBoxedWithLongBoxedType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.LONG_OBJECT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "y"); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + @Test + public void multiplyAndAssignmentOperationExpr_invalidLongBoxedWithFloatType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_validFloatWithLongBoxedType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.LONG_OBJECT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.FLOAT, "y"); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + @Test + public void multiplyAndAssignmentOperationExpr_invalidLongBoxedWithDoubleBoxedType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_validDoubleBoxedWithLongBoxedType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.LONG_OBJECT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.DOUBLE_OBJECT, "y"); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + @Test + public void multiplyAndAssignmentOperationExpr_invalidLongBoxedWithDoubleType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_validDoubleWithLongBoxedType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.LONG_OBJECT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.DOUBLE, "y"); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + @Test + public void multiplyAndAssignmentOperationExpr_invalidLongBoxedWithNullType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_invalidNullWithLongBoxedType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.LONG_OBJECT, "x"); + ValueExpr rhsExpr = ValueExpr.withValue(NullObjectValue.create()); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + @Test + public void multiplyAndAssignmentOperationExpr_invalidLongBoxedWithObjectType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_invalidObjectWithLongBoxedType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.LONG_OBJECT, "x"); + NewObjectExpr rhsExpr = NewObjectExpr.withType(TypeNode.OBJECT); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + @Test + public void multiplyAndAssignmentOperationExpr_invalidLongBoxedWithReferenceType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_invalidReferenceWithLongBoxedType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.LONG_OBJECT, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.STRING, "y"); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + /** ======== Multiply And Assignment Operators: LHS data type is Reference Type ============ */ @Test public void multiplyAndAssignmentOperationExpr_invalidReferencedWithNumericType() { @@ -147,6 +696,37 @@ public void multiplyAndAssignmentOperationExpr_invalidReferencedWithNumericType( IllegalStateException.class, () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); } + + @Test + public void multiplyAndAssignmentOperationExpr_invalidReferenceWithFloatBoxedType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_invalidFloatBoxedWithReferenceType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.STRING, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "y"); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + @Test + public void multiplyAndAssignmentOperationExpr_invalidReferenceWithLongBoxedType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_invalidLongBoxedWithReferenceType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.STRING, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.LONG_OBJECT, "y"); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + @Test + public void multiplyAndAssignmentOperationExpr_invalidReferenceWithDoubleBoxedType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_invalidDoubleBoxedWithReferenceType". + VariableExpr lhsExpr = createVariableExpr(TypeNode.STRING, "x"); + VariableExpr rhsExpr = createVariableExpr(TypeNode.DOUBLE_OBJECT, "y"); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + /** ======== Multiply And Assignment Operators: LHS data type is Object Type ============ */ @Test public void multiplyAndAssignmentOperationExpr_invalidNewObjectWithNumeric() { @@ -157,6 +737,37 @@ public void multiplyAndAssignmentOperationExpr_invalidNewObjectWithNumeric() { IllegalStateException.class, () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); } + + @Test + public void multiplyAndAssignmentOperationExpr_invalidObjectWithFloatBoxedType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_validDoubleBoxedWithFloatBoxedType". + NewObjectExpr lhsExpr = NewObjectExpr.withType(TypeNode.OBJECT); + VariableExpr rhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "x"); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + @Test + public void multiplyAndAssignmentOperationExpr_invalidObjectWithLongBoxedType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_invalidLongBoxedWithObjectType". + NewObjectExpr lhsExpr = NewObjectExpr.withType(TypeNode.OBJECT); + VariableExpr rhsExpr = createVariableExpr(TypeNode.LONG_OBJECT, "x"); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + @Test + public void multiplyAndAssignmentOperationExpr_invalidObjectWithDoubleBoxedType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_invalidDoubleBoxedWithOjectType". + NewObjectExpr lhsExpr = NewObjectExpr.withType(TypeNode.OBJECT); + VariableExpr rhsExpr = createVariableExpr(TypeNode.DOUBLE_OBJECT, "x"); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + /** ======== Multiply And Assignment Operators: LHS data type is Null Type ============ */ @Test public void multiplyAndAssignmentOperationExpr_invalidNullWithNumericType() { @@ -168,6 +779,62 @@ public void multiplyAndAssignmentOperationExpr_invalidNullWithNumericType() { () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); } + @Test + public void multiplyAndAssignmentOperationExpr_invalidNullWithLongBoxedType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_invalidLongBoxedWithNullType". + ValueExpr lhsExpr = ValueExpr.withValue(NullObjectValue.create()); + VariableExpr rhsExpr = createVariableExpr(TypeNode.LONG_OBJECT, "x"); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + @Test + public void multiplyAndAssignmentOperationExpr_invalidNullWithFloatBoxedType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_invalidFloatBoxedWithNullType". + ValueExpr lhsExpr = ValueExpr.withValue(NullObjectValue.create()); + VariableExpr rhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "x"); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + @Test + public void multiplyAndAssignmentOperationExpr_invalidNullWithDoubleBoxedType() { + // Swap test case in "multiplyAndAssignmentOperationExpr_invalidDoubleBoxedWithNullType". + ValueExpr lhsExpr = ValueExpr.withValue(NullObjectValue.create()); + VariableExpr rhsExpr = createVariableExpr(TypeNode.DOUBLE_OBJECT, "x"); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + /** ======== Multiply And Assignment Operators: Void type ============ */ + @Test + public void multiplyAndAssignmentOperationExpr_invalidVoidType() { + // No need swap case. + MethodInvocationExpr lhsExpr = + MethodInvocationExpr.builder().setMethodName("x").setReturnType(TypeNode.VOID).build(); + MethodInvocationExpr rhsExpr = + MethodInvocationExpr.builder().setMethodName("y").setReturnType(TypeNode.VOID).build(); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + @Test + public void multiplyAndAssignmentOperationExpr_invalidWithOneVoidType() { + // No need swap case. + MethodInvocationExpr lhsExpr = + MethodInvocationExpr.builder().setMethodName("x").setReturnType(TypeNode.VOID).build(); + VariableExpr rhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "x"); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + // TODO(summerji): Complete the type-checking for ^= and unit test. + /** ======== Bitwise Exclusive Or And Assignment Operators: ============ */ private VariableExpr createVariableExpr(TypeNode type, String name) { Variable variable = Variable.builder().setName(name).setType(type).build(); VariableExpr variableExpr = VariableExpr.withVariable(variable); From 2245040c57c9ca9a51841c40ee957a9718231139 Mon Sep 17 00:00:00 2001 From: summerji Date: Tue, 15 Sep 2020 18:56:16 -0700 Subject: [PATCH 06/15] add license --- .../ast/AssignmentOperationExprTest.java | 155 ++---------------- 1 file changed, 15 insertions(+), 140 deletions(-) diff --git a/src/test/java/com/google/api/generator/engine/ast/AssignmentOperationExprTest.java b/src/test/java/com/google/api/generator/engine/ast/AssignmentOperationExprTest.java index afdc61a9be..7c8282f866 100644 --- a/src/test/java/com/google/api/generator/engine/ast/AssignmentOperationExprTest.java +++ b/src/test/java/com/google/api/generator/engine/ast/AssignmentOperationExprTest.java @@ -1,3 +1,17 @@ +// Copyright 2020 Google LLC +// +// Licensed 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 com.google.api.generator.engine.ast; import static org.junit.Assert.assertThrows; @@ -9,146 +23,6 @@ public class AssignmentOperationExprTest { /** =========== Multiply And Assignment Operators: LHS data type is numeric ================= */ @Test public void multiplyAndAssignmentOperationExpr_validNumericMatched() { - // int a = 1; - // double b = 2; - // char c = 'e'; - // float f = 5.99f; - // short s = 5000; - // long l = 15000000000L; - // boolean bool = false; - // byte bbb = '1'; - // Byte bbbo = new Byte(bbb); - // Integer ao = new Integer(4); - // Float fo = new Float(f); - // Character co = new Character('c'); - // Double doo = new Double(122.3); - // Boolean bo = new Boolean(false); - // Long lo = new Long(4l); - // Short so = new Short(s); - // int[] ar = new int[3]; - // String word = "avc"; - // a *= b; - // a *= c; - // a *= f; - // a *= s; - // a *= fo; - // a *= co; - // a *= doo; - // a *= ao; - // a *= bbb; - // a *= bbbo; - // // a *= bool; invalid - // l *= a; - // l *= b; - // l *= c; - // l *= f; - // l *= s; - // l *= ao; - // l *= co; - // l *= fo; - // l *= doo; - // s *= a; - // s *= l; - // s *= f; - // s *= c; - // s *= b; - // ao *= a; - // ao *= s; - // ao *= f; - // ao *= b; - // ao *= c; - // ao *= l; - // ao *= bbb; - // ao *= co; - // ao *= fo; - // ao *= doo; - // ao *= lo; - // ao *= bbbo; - // doo *= a; - // doo *= b; - // doo *= c; - // doo *= f; - // doo *= s; - // doo *= l; - // doo *= bbb; - // doo *= ao; - // doo *= fo; - // doo *= co; - // doo *= bbbo; - // co *= a; - // co *= b; - // co *= f; - // co *= s; - // co *= bbb; - // co *= l; - // co *= c; - // co *= ao; - // co *= bo; - // co *= fo; - // lo *= ao; - // lo *= a; - // lo *= l; - // lo *= c; - // lo *= s; - // lo *= bbb; - // lo *= doo; - // lo *= fo; - // lo *= f; - // lo *= b; - // lo *= co; - // lo *= bbbo; - // lo *= lo; - // lo *= co; - // lo *= so; - // so *= a; - // so *= b; - // so *= f; - // so *= l; - // so *= so; - // so *= s; - // so *= bbb; - // so *= ao; - // so *= fo; - // so *= doo; - // so *= co; - // so *= ao; - // bbbo *= a; - // bbbo *= f; - // bbbo *= b; - // bbbo *= c; - // bbbo *= s; - // bbbo *= l; - // bbbo *= ao; - // bbbo *= fo; - // bbbo *= doo; - // fo *= ao; - // fo *= fo; - // fo *= co; - // fo *= a; - // fo *= a; - // fo *= fo; - // fo *= c; - // fo *= co; - // fo *= bbbo; - // fo *= b; - // fo *= lo; - // fo *= doo; - // fo *= lo; - // fo *= co; - // fo *= so; - // fo *= a; - // doo *= a; - // doo *= b; - // doo *= f; - // doo *= s; - // doo *= c; - // doo *= l; - // doo *= bbb; - // doo *= ao; - // doo *= fo; - // doo *= so; - // doo *= bbbo; - // boolean wpeo = (fo *= co) instanceof Float; // No need swap test case. VariableExpr lhsExpr = createVariableExpr(TypeNode.INT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.INT, "y"); @@ -156,6 +30,7 @@ public void multiplyAndAssignmentOperationExpr_validNumericMatched() { // No exception thrown, so we succeeded. } + @Test public void multiplyAndAssignmentOperationExpr_validNumericUnmatched() { // No need swap test case. From 2df2c8dd6e424c44d551d3b6a84f521397c4a695 Mon Sep 17 00:00:00 2001 From: summerji Date: Tue, 15 Sep 2020 18:57:44 -0700 Subject: [PATCH 07/15] add license --- .../engine/ast/AssignmentOperationExpr.java | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/src/main/java/com/google/api/generator/engine/ast/AssignmentOperationExpr.java b/src/main/java/com/google/api/generator/engine/ast/AssignmentOperationExpr.java index 55fe804416..cc0b898231 100644 --- a/src/main/java/com/google/api/generator/engine/ast/AssignmentOperationExpr.java +++ b/src/main/java/com/google/api/generator/engine/ast/AssignmentOperationExpr.java @@ -1,3 +1,17 @@ +// Copyright 2020 Google LLC +// +// Licensed 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 com.google.api.generator.engine.ast; import com.google.auto.value.AutoValue; From 7f35ac48625341d84b21b0b979334c20f14a5ccd Mon Sep 17 00:00:00 2001 From: summerji Date: Tue, 15 Sep 2020 19:03:01 -0700 Subject: [PATCH 08/15] fix linter --- .../api/generator/engine/ast/AssignmentOperationExprTest.java | 1 - 1 file changed, 1 deletion(-) diff --git a/src/test/java/com/google/api/generator/engine/ast/AssignmentOperationExprTest.java b/src/test/java/com/google/api/generator/engine/ast/AssignmentOperationExprTest.java index 7c8282f866..bf7f3deb30 100644 --- a/src/test/java/com/google/api/generator/engine/ast/AssignmentOperationExprTest.java +++ b/src/test/java/com/google/api/generator/engine/ast/AssignmentOperationExprTest.java @@ -30,7 +30,6 @@ public void multiplyAndAssignmentOperationExpr_validNumericMatched() { // No exception thrown, so we succeeded. } - @Test public void multiplyAndAssignmentOperationExpr_validNumericUnmatched() { // No need swap test case. From 88c10622428f1828baae4a3186cefbc3aafa87e7 Mon Sep 17 00:00:00 2001 From: summerji Date: Fri, 18 Sep 2020 12:03:58 -0700 Subject: [PATCH 09/15] add check for variable declaration --- .../engine/ast/AssignmentOperationExpr.java | 111 ++++--- .../generator/engine/ast/OperatorKind.java | 4 +- .../api/generator/engine/ast/TypeNode.java | 4 + .../engine/writer/ImportWriterVisitor.java | 4 +- .../engine/writer/JavaWriterVisitor.java | 12 +- .../ast/AssignmentOperationExprTest.java | 293 +++++++----------- .../engine/writer/JavaWriterVisitorTest.java | 12 +- 7 files changed, 206 insertions(+), 234 deletions(-) diff --git a/src/main/java/com/google/api/generator/engine/ast/AssignmentOperationExpr.java b/src/main/java/com/google/api/generator/engine/ast/AssignmentOperationExpr.java index cc0b898231..6211b680a2 100644 --- a/src/main/java/com/google/api/generator/engine/ast/AssignmentOperationExpr.java +++ b/src/main/java/com/google/api/generator/engine/ast/AssignmentOperationExpr.java @@ -19,35 +19,37 @@ @AutoValue public abstract class AssignmentOperationExpr implements OperationExpr { - public abstract Expr lhsExpr(); + public abstract VariableExpr variableExpr(); - public abstract Expr rhsExpr(); + public abstract Expr valueExpr(); public abstract OperatorKind operatorKind(); - public abstract TypeNode type(); + @Override + public TypeNode type() { + return variableExpr().type(); + } @Override public void accept(AstNodeVisitor visitor) { visitor.visit(this); } - public static AssignmentOperationExpr bitwiseExclusiveOrAndAssignmentWithExprs( - Expr lhsExpr, Expr rhsExpr) { + public static AssignmentOperationExpr xorAssignmentWithExprs( + VariableExpr variableExpr, Expr valueExpr) { return builder() - .setLhsExpr(lhsExpr) - .setRhsExpr(rhsExpr) - .setOperatorKind(OperatorKind.ASSIGNMENT_BITWISE_EXCLUSIVE_OR_AND_ASSIGNMENT) - .setType(lhsExpr.type()) + .setVariableExpr(variableExpr) + .setValueExpr(valueExpr) + .setOperatorKind(OperatorKind.ASSIGNMENT_XOR) .build(); } - public static AssignmentOperationExpr multiplyAndAssignmentWithExprs(Expr lhsExpr, Expr rhsExpr) { + public static AssignmentOperationExpr multiplyAssignmentWithExprs( + VariableExpr variableExpr, Expr valueExpr) { return builder() - .setLhsExpr(lhsExpr) - .setRhsExpr(rhsExpr) - .setOperatorKind(OperatorKind.ASSIGNMENT_MULTIPLY_AND_ASSIGNMENT) - .setType(lhsExpr.type()) + .setVariableExpr(variableExpr) + .setValueExpr(valueExpr) + .setOperatorKind(OperatorKind.ASSIGNMENT_MULTIPLY) .build(); } @@ -58,64 +60,85 @@ private static Builder builder() { @AutoValue.Builder abstract static class Builder { // Private setter. - abstract Builder setLhsExpr(Expr expr); + abstract Builder setVariableExpr(VariableExpr variableExpr); // Private setter. - abstract Builder setRhsExpr(Expr expr); + abstract Builder setValueExpr(Expr valueExpr); // Private setter. abstract Builder setOperatorKind(OperatorKind operator); - // Private setter. - abstract Builder setType(TypeNode type); - abstract AssignmentOperationExpr autoBuild(); private AssignmentOperationExpr build() { AssignmentOperationExpr assignmentOperationExpr = autoBuild(); - TypeNode lhsExprType = assignmentOperationExpr.lhsExpr().type(); - TypeNode rhsExprType = assignmentOperationExpr.rhsExpr().type(); + TypeNode lhsType = assignmentOperationExpr.variableExpr().variable().type(); + TypeNode rhsType = + assignmentOperationExpr.valueExpr() instanceof VariableExpr + ? ((VariableExpr) assignmentOperationExpr.valueExpr()).variable().type() + : assignmentOperationExpr.valueExpr().type(); OperatorKind operator = assignmentOperationExpr.operatorKind(); - final String errorMsg = + + // Check if the variable exprs have been declared, if yes, throw error. + Preconditions.checkState( + !assignmentOperationExpr.variableExpr().isDecl() + && (assignmentOperationExpr.valueExpr() instanceof VariableExpr + ? !((VariableExpr) assignmentOperationExpr.valueExpr()).isDecl() + : true), + String.format( + "Variable `%s` should not be declaration in the variable expression.", + assignmentOperationExpr.variableExpr().variable().name())); + + // TYPE_CHECK_ERROR_MSG is type checking error message for operators. + final String TYPE_CHECK_ERROR_MSG = String.format( "Assignment operator %s can not be applied to %s, %s.", - operator, lhsExprType.toString(), rhsExprType.toString()); - if (operator.equals(OperatorKind.ASSIGNMENT_MULTIPLY_AND_ASSIGNMENT)) { + operator, lhsType.toString(), rhsType.toString()); + + // Check type for multiply and assignment operator (*=). + if (operator.equals(OperatorKind.ASSIGNMENT_MULTIPLY)) { Preconditions.checkState( - isValidMultiplyAndAssignmentType(lhsExprType, rhsExprType), errorMsg); + isValidMultiplyAssignmentType(lhsType, rhsType), TYPE_CHECK_ERROR_MSG); } - if (operator.equals(OperatorKind.ASSIGNMENT_BITWISE_EXCLUSIVE_OR_AND_ASSIGNMENT)) { - Preconditions.checkState( - isValidBitwiseExclusiveOrAndAssignmentType(lhsExprType, rhsExprType), errorMsg); + + // Check type for XOR and assignment operator (^=). + // TODO(summerji): Complete the type-checking for ^= and unit test. + if (operator.equals(OperatorKind.ASSIGNMENT_XOR)) { + Preconditions.checkState(isValidXORAssignmentType(lhsType, rhsType), TYPE_CHECK_ERROR_MSG); } return assignmentOperationExpr; } - private boolean isValidMultiplyAndAssignmentType(TypeNode lhsType, TypeNode rhsType) { - if (TypeNode.isNumericType(lhsType) && !TypeNode.isBoxedType(lhsType)) { - return TypeNode.isNumericType(rhsType); + // isValidMultiplyAssignmentType validates the types for LHS variable expr and RHS expr. + // *= can be only applied on Primitive numeric type. + private boolean isValidMultiplyAssignmentType(TypeNode variableType, TypeNode valueType) { + // LHS is numeric type, RHS should be any numeric type or any numeric boxed type. + if (TypeNode.isNumericType(variableType) && !TypeNode.isBoxedType(variableType)) { + return TypeNode.isNumericType(valueType); } - if (lhsType.equals(TypeNode.INT_OBJECT)) { - return TypeNode.isNumericType(rhsType) - && !(rhsType.equals(TypeNode.LONG) - || rhsType.equals(TypeNode.FLOAT) - || rhsType.equals(TypeNode.DOUBLE)); + // LHS is integer boxed type, RHS should be any numeric type except long, float, double. + if (variableType.equals(TypeNode.INT_OBJECT)) { + return TypeNode.isNumericType(valueType) + && !(valueType.equals(TypeNode.LONG) || TypeNode.isFloatingPointType(valueType)); } - if (lhsType.equals(TypeNode.LONG_OBJECT)) { - return TypeNode.isNumericType(rhsType) - && !(rhsType.equals(TypeNode.FLOAT) || rhsType.equals(TypeNode.DOUBLE)); + // LHS is long boxed type, RHS should be any numeric type except float, double. + if (variableType.equals(TypeNode.LONG_OBJECT)) { + return TypeNode.isNumericType(valueType) && !TypeNode.isFloatingPointType(valueType); } - if (lhsType.equals(TypeNode.FLOAT_OBJECT)) { - return TypeNode.isNumericType(rhsType) && !rhsType.equals(TypeNode.DOUBLE); + // LHS is integer boxed type, RHS should be any numeric type except double. + if (variableType.equals(TypeNode.FLOAT_OBJECT)) { + return TypeNode.isNumericType(valueType) && !valueType.equals(TypeNode.DOUBLE); } - if (lhsType.equals(TypeNode.DOUBLE_OBJECT)) { - return TypeNode.isNumericType(rhsType); + // LHS is integer boxed type, RHS should be any numeric type or any numeric boxed type. + if (variableType.equals(TypeNode.DOUBLE_OBJECT)) { + return TypeNode.isNumericType(valueType); } + // *= operator does not support boxed Short, Character, Byte, null, reference, void type. return false; } // TODO(summerji): Complete the type-checking for ^= and unit test. - private boolean isValidBitwiseExclusiveOrAndAssignmentType(TypeNode lhsType, TypeNode rhsType) { + private boolean isValidXORAssignmentType(TypeNode variableType, TypeNode valueType) { return true; } } diff --git a/src/main/java/com/google/api/generator/engine/ast/OperatorKind.java b/src/main/java/com/google/api/generator/engine/ast/OperatorKind.java index 60964f90a6..c5f9b1d158 100644 --- a/src/main/java/com/google/api/generator/engine/ast/OperatorKind.java +++ b/src/main/java/com/google/api/generator/engine/ast/OperatorKind.java @@ -20,8 +20,8 @@ public enum OperatorKind { ARITHMETIC_ADDITION, LOGICAL_AND, LOGICAL_OR, - ASSIGNMENT_BITWISE_EXCLUSIVE_OR_AND_ASSIGNMENT, - ASSIGNMENT_MULTIPLY_AND_ASSIGNMENT, + ASSIGNMENT_XOR, + ASSIGNMENT_MULTIPLY, RELATIONAL_EQUAL_TO, RELATIONAL_NOT_EQUAL_TO, UNARY_LOGICAL_NOT, diff --git a/src/main/java/com/google/api/generator/engine/ast/TypeNode.java b/src/main/java/com/google/api/generator/engine/ast/TypeNode.java index 27396ffb85..d7d368d650 100644 --- a/src/main/java/com/google/api/generator/engine/ast/TypeNode.java +++ b/src/main/java/com/google/api/generator/engine/ast/TypeNode.java @@ -149,6 +149,10 @@ public static boolean isNumericType(TypeNode type) { || type.equals(TypeNode.BYTE); } + public static boolean isFloatingPointType(TypeNode type) { + return type.equals(TypeNode.DOUBLE) || type.equals(TypeNode.FLOAT); + } + public static boolean isBoxedType(TypeNode type) { return isReferenceType(type) && BOXED_TYPE_MAP.containsValue(type); } diff --git a/src/main/java/com/google/api/generator/engine/writer/ImportWriterVisitor.java b/src/main/java/com/google/api/generator/engine/writer/ImportWriterVisitor.java index e1712427c1..94af63747e 100644 --- a/src/main/java/com/google/api/generator/engine/writer/ImportWriterVisitor.java +++ b/src/main/java/com/google/api/generator/engine/writer/ImportWriterVisitor.java @@ -243,8 +243,8 @@ public void visit(LogicalOperationExpr logicalOperationExpr) { @Override public void visit(AssignmentOperationExpr assignmentOperationExpr) { - assignmentOperationExpr.lhsExpr().accept(this); - assignmentOperationExpr.rhsExpr().accept(this); + assignmentOperationExpr.variableExpr().accept(this); + assignmentOperationExpr.valueExpr().accept(this); } /** =============================== STATEMENTS =============================== */ diff --git a/src/main/java/com/google/api/generator/engine/writer/JavaWriterVisitor.java b/src/main/java/com/google/api/generator/engine/writer/JavaWriterVisitor.java index 078d0bca87..90ed3c21ec 100644 --- a/src/main/java/com/google/api/generator/engine/writer/JavaWriterVisitor.java +++ b/src/main/java/com/google/api/generator/engine/writer/JavaWriterVisitor.java @@ -115,7 +115,7 @@ public class JavaWriterVisitor implements AstNodeVisitor { private static final String OPERATOR_LOGICAL_NOT = "!"; private static final String OPERATOR_LOGICAL_AND = "&&"; private static final String OPERATOR_LOGICAL_OR = "||"; - private static final String OPERATOR_BITWISE_EXCLUSIVE_OR_AND_ASSIGNMENT = "^="; + private static final String OPERATOR_XOR = "^="; private static final String OPERATOR_MULTIPLE_AND_ASSIGNMENT = "*="; private final StringBuffer buffer = new StringBuffer(); @@ -434,11 +434,11 @@ public void visit(LogicalOperationExpr logicalOperationExpr) { @Override public void visit(AssignmentOperationExpr assignmentOperationExpr) { - assignmentOperationExpr.lhsExpr().accept(this); + assignmentOperationExpr.variableExpr().accept(this); space(); operator(assignmentOperationExpr.operatorKind()); space(); - assignmentOperationExpr.rhsExpr().accept(this); + assignmentOperationExpr.valueExpr().accept(this); } /** =============================== STATEMENTS =============================== */ @@ -927,10 +927,10 @@ private void operator(OperatorKind kind) { case ARITHMETIC_ADDITION: buffer.append(OPERATOR_ADDITION); break; - case ASSIGNMENT_BITWISE_EXCLUSIVE_OR_AND_ASSIGNMENT: - buffer.append(OPERATOR_BITWISE_EXCLUSIVE_OR_AND_ASSIGNMENT); + case ASSIGNMENT_XOR: + buffer.append(OPERATOR_XOR); break; - case ASSIGNMENT_MULTIPLY_AND_ASSIGNMENT: + case ASSIGNMENT_MULTIPLY: buffer.append(OPERATOR_MULTIPLE_AND_ASSIGNMENT); break; case RELATIONAL_EQUAL_TO: diff --git a/src/test/java/com/google/api/generator/engine/ast/AssignmentOperationExprTest.java b/src/test/java/com/google/api/generator/engine/ast/AssignmentOperationExprTest.java index bf7f3deb30..5c0a48568f 100644 --- a/src/test/java/com/google/api/generator/engine/ast/AssignmentOperationExprTest.java +++ b/src/test/java/com/google/api/generator/engine/ast/AssignmentOperationExprTest.java @@ -19,14 +19,45 @@ import org.junit.Test; public class AssignmentOperationExprTest { - /** ========================= Multiply And Assignment Operators =============================== */ - /** =========== Multiply And Assignment Operators: LHS data type is numeric ================= */ + /** =========== Multiply And Assignment Operators: Variable is declaration ================ */ + @Test + public void multiplyAndAssignmentOperationExpr_invalidVariableExprIsDecl() { + Variable variable = Variable.builder().setName("x").setType(TypeNode.INT).build(); + VariableExpr lhsExpr = VariableExpr.builder().setVariable(variable).setIsDecl(true).build(); + VariableExpr rhsExpr = createVariableExpr(TypeNode.INT, "y"); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + @Test + public void multiplyAndAssignmentOperationExpr_invalidValueExprIsDecl() { + VariableExpr lhsExpr = createVariableExpr(TypeNode.INT, "x"); + Variable variable = Variable.builder().setName("x").setType(TypeNode.INT).build(); + VariableExpr rhsExpr = VariableExpr.builder().setVariable(variable).setIsDecl(true).build(); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + @Test + public void multiplyAndAssignmentOperationExpr_invalidVariableExprAndValueExprIsDecl() { + Variable lVariable = Variable.builder().setName("x").setType(TypeNode.INT).build(); + VariableExpr lhsExpr = VariableExpr.builder().setVariable(lVariable).setIsDecl(true).build(); + Variable rVariable = Variable.builder().setName("y").setType(TypeNode.INT).build(); + VariableExpr rhsExpr = VariableExpr.builder().setVariable(rVariable).setIsDecl(true).build(); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + /** ========= Multiply And Assignment Operators: VariableExpr is numeric types ============== */ @Test public void multiplyAndAssignmentOperationExpr_validNumericMatched() { // No need swap test case. VariableExpr lhsExpr = createVariableExpr(TypeNode.INT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.INT, "y"); - AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); // No exception thrown, so we succeeded. } @@ -34,8 +65,8 @@ public void multiplyAndAssignmentOperationExpr_validNumericMatched() { public void multiplyAndAssignmentOperationExpr_validNumericUnmatched() { // No need swap test case. VariableExpr lhsExpr = createVariableExpr(TypeNode.INT, "x"); - VariableExpr rhsExpr = createVariableExpr(TypeNode.LONG, "y"); - AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + ValueExpr rhsExpr = createValueExpr(TypeNode.INT, "5"); + AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); // No exception thrown, so we succeeded. } @@ -44,7 +75,7 @@ public void multiplyAndAssignmentOperationExpr_validNumericMatchedBoxedType() { // Swap test case in "multiplyAndAssignmentOperationExpr_validIntegerMatchedBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.INT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "y"); - AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); // No exception thrown, so we succeeded. } @@ -53,7 +84,7 @@ public void multiplyAndAssignmentOperationExpr_validNumericUnmatchedBoxedType() // Swap test case in "multiplyAndAssignmentOperationExpr_validIntegerBoxedWithShortType". VariableExpr lhsExpr = createVariableExpr(TypeNode.INT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "y"); - AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); // No exception thrown, so we succeeded. } @@ -62,7 +93,7 @@ public void multiplyAndAssignmentOperationExpr_validNumericWithFloatType() { // Swap test case in "multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithFloatType". VariableExpr lhsExpr = createVariableExpr(TypeNode.FLOAT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "y"); - AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); // No exception thrown, so we succeeded. } @@ -71,7 +102,7 @@ public void multiplyAndAssignmentOperationExpr_validDoubleWithIntegerBoxedType() // Swap test case in "multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithDoubleType". VariableExpr lhsExpr = createVariableExpr(TypeNode.DOUBLE, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "y"); - AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); // No exception thrown, so we succeeded. } @@ -80,7 +111,7 @@ public void multiplyAndAssignmentOperationExpr_validDoubleWithLongBoxedType() { // Swap test case in "multiplyAndAssignmentOperationExpr_invalidLongBoxedWithDoubleType". VariableExpr lhsExpr = createVariableExpr(TypeNode.DOUBLE, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.LONG_OBJECT, "y"); - AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); // No exception thrown, so we succeeded. } @@ -89,7 +120,7 @@ public void multiplyAndAssignmentOperationExpr_validLongWithIntegerBoxedType() { // Swap test case in "multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithLongType". VariableExpr lhsExpr = createVariableExpr(TypeNode.LONG, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "y"); - AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); // No exception thrown, so we succeeded. } @@ -98,7 +129,7 @@ public void multiplyAndAssignmentOperationExpr_validIntegerWithFloatBoxedType() // Swap test case in "multiplyAndAssignmentOperationExpr_validFloatBoxedWithIntegerType". VariableExpr lhsExpr = createVariableExpr(TypeNode.INT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "y"); - AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); // No exception thrown, so we succeeded. } @@ -107,7 +138,7 @@ public void multiplyAndAssignmentOperationExpr_validFloatWithLongBoxedType() { // Swap test case in "multiplyAndAssignmentOperationExpr_invalidLongBoxedWithFloatType". VariableExpr lhsExpr = createVariableExpr(TypeNode.FLOAT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.LONG_OBJECT, "y"); - AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); // No exception thrown, so we succeeded. } @@ -118,7 +149,7 @@ public void multiplyAndAssignmentOperationExpr_invalidNumericWithBooleanBoxedTyp VariableExpr rhsExpr = createVariableExpr(TypeNode.BOOLEAN_OBJECT, "y"); assertThrows( IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); } @Test @@ -128,7 +159,7 @@ public void multiplyAndAssignmentOperationExpr_invalidNumericWithBooleanType() { VariableExpr rhsExpr = createVariableExpr(TypeNode.BOOLEAN, "y"); assertThrows( IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); } @Test @@ -138,17 +169,17 @@ public void multiplyAndAssignmentOperationExpr_invalidNumericWithReferenceType() VariableExpr rhsExpr = createVariableExpr(TypeNode.STRING, "y"); assertThrows( IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); } @Test public void multiplyAndAssignmentOperationExpr_invalidNumericWithNewObject() { - // Swap test case in "multiplyAndAssignmentOperationExpr_invalidNewObjectWithNumeric". + // No Need swap case. VariableExpr lhsExpr = createVariableExpr(TypeNode.INT, "x"); NewObjectExpr rhsExpr = NewObjectExpr.withType(TypeNode.OBJECT); assertThrows( IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); } /** ==== Multiply And Assignment Operators: LHS data type is boolean and its boxed type ===== */ @@ -159,17 +190,17 @@ public void multiplyAndAssignmentOperationExpr_invalidBooleanWithNumericType() { VariableExpr rhsExpr = createVariableExpr(TypeNode.INT, "y"); assertThrows( IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); } @Test public void multiplyAndAssignmentOperationExpr_invalidBooleanBoxedWithNumericType() { // Swap test case in "multiplyAndAssignmentOperationExpr_invalidNumericWithBooleanBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.BOOLEAN_OBJECT, "x"); - VariableExpr rhsExpr = createVariableExpr(TypeNode.INT, "y"); + ValueExpr rhsExpr = createValueExpr(TypeNode.INT, "5"); assertThrows( IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); } /** ======== Multiply And Assignment Operators: LHS data type is Integer Box Type ============ */ @@ -178,8 +209,8 @@ public void multiplyAndAssignmentOperationExpr_invalidBooleanBoxedWithNumericTyp public void multiplyAndAssignmentOperationExpr_validIntegerMatchedBoxedType() { // Swap test case in "multiplyAndAssignmentOperationExpr_validNumericMatchedBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "x"); - VariableExpr rhsExpr = createVariableExpr(TypeNode.INT, "y"); - AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + ValueExpr rhsExpr = createValueExpr(TypeNode.INT, "5"); + AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); // No exception thrown, so we succeeded. } @@ -188,7 +219,7 @@ public void multiplyAndAssignmentOperationExpr_validIntegerBoxedWithShortType() // Swap test case in "multiplyAndAssignmentOperationExpr_validNumericUnmatchedBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.SHORT, "y"); - AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); // No exception thrown, so we succeeded. } @@ -197,7 +228,7 @@ public void multiplyAndAssignmentOperationExpr_validIntegerBoxedWithShortBoxedTy // Swap test case in "multiplyAndAssignmentOperationExpr_validShortBoxedWithIntegerBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.SHORT_OBJECT, "y"); - AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); // No exception thrown, so we succeeded. } @@ -206,7 +237,7 @@ public void multiplyAndAssignmentOperationExpr_validIntegerBoxedWithCharacterBox // Swap test case in "multiplyAndAssignmentOperationExpr_validShortBoxedWithIntegerBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.CHAR_OBJECT, "y"); - AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); // No exception thrown, so we succeeded. } @@ -215,7 +246,7 @@ public void multiplyAndAssignmentOperationExpr_validIntegerBoxedWithByteBoxedTyp // Swap test case in "multiplyAndAssignmentOperationExpr_validByteBoxedWithIntegerBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.BYTE_OBJECT, "y"); - AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); // No exception thrown, so we succeeded. } @@ -226,7 +257,7 @@ public void multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithFloatType( VariableExpr rhsExpr = createVariableExpr(TypeNode.FLOAT, "y"); assertThrows( IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); } @Test @@ -236,7 +267,7 @@ public void multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithFloatBoxed VariableExpr rhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "y"); assertThrows( IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); } @Test @@ -246,7 +277,7 @@ public void multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithDoubleType VariableExpr rhsExpr = createVariableExpr(TypeNode.DOUBLE, "y"); assertThrows( IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); } @Test @@ -256,7 +287,7 @@ public void multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithDoubleBoxe VariableExpr rhsExpr = createVariableExpr(TypeNode.DOUBLE_OBJECT, "y"); assertThrows( IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); } @Test @@ -266,7 +297,7 @@ public void multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithLongType() VariableExpr rhsExpr = createVariableExpr(TypeNode.LONG, "y"); assertThrows( IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); } @Test @@ -276,7 +307,7 @@ public void multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithLongBoxedT VariableExpr rhsExpr = createVariableExpr(TypeNode.LONG_OBJECT, "y"); assertThrows( IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); } /** ==== Multiply And Assignment Operators: LHS data type is Float boxed type ====== */ @@ -285,8 +316,8 @@ public void multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithLongBoxedT public void multiplyAndAssignmentOperationExpr_validFloatBoxedWithIntegerType() { // Swap test case in "multiplyAndAssignmentOperationExpr_validIntegerWithFloatBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "x"); - VariableExpr rhsExpr = createVariableExpr(TypeNode.INT, "y"); - AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + ValueExpr rhsExpr = createValueExpr(TypeNode.INT, "5"); + AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); // No exception thrown, so we succeeded. } @@ -295,7 +326,7 @@ public void multiplyAndAssignmentOperationExpr_validFloatBoxedWithIntegerBoxedTy // Swap test case in "multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithFloatBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "y"); - AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); // No exception thrown, so we succeeded. } @@ -304,7 +335,7 @@ public void multiplyAndAssignmentOperationExpr_validFloatBoxedWithCharBoxedType( // Swap test case in "multiplyAndAssignmentOperationExpr_invalidCharBoxedWithFloatBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.CHAR_OBJECT, "y"); - AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); // No exception thrown, so we succeeded. } @@ -313,7 +344,7 @@ public void multiplyAndAssignmentOperationExpr_validFloatBoxedWithByteBoxedType( // Swap test case in "multiplyAndAssignmentOperationExpr_invalidByteBoxedWithFloatBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.BYTE_OBJECT, "y"); - AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); // No exception thrown, so we succeeded. } @@ -322,7 +353,7 @@ public void multiplyAndAssignmentOperationExpr_validFloatBoxedWithLongBoxedType( // Swap test case in "multiplyAndAssignmentOperationExpr_invalidLongBoxedWithFloatBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.LONG_OBJECT, "y"); - AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); // No exception thrown, so we succeeded. } @@ -333,27 +364,27 @@ public void multiplyAndAssignmentOperationExpr_invalidFloatBoxedWithDoubleBoxedT VariableExpr rhsExpr = createVariableExpr(TypeNode.DOUBLE_OBJECT, "y"); assertThrows( IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); } @Test public void multiplyAndAssignmentOperationExpr_invalidFloatBoxedWithObjectType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_invalidFloatBoxedWithObjectType". + // No need swap case. VariableExpr lhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "x"); NewObjectExpr rhsExpr = NewObjectExpr.withType(TypeNode.OBJECT); assertThrows( IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); } @Test public void multiplyAndAssignmentOperationExpr_invalidFloatBoxedWithNullType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_invalidNullWithFloatBoxedType". + // No need swap case. VariableExpr lhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "x"); ValueExpr rhsExpr = ValueExpr.withValue(NullObjectValue.create()); assertThrows( IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); } @Test @@ -363,7 +394,7 @@ public void multiplyAndAssignmentOperationExpr_invalidFloatBoxedWithReferenceTyp VariableExpr rhsExpr = createVariableExpr(TypeNode.STRING, "y"); assertThrows( IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); } /** ==== Multiply And Assignment Operators: LHS data type is Short/Char/Byte Boxed Type ====== */ @@ -375,7 +406,7 @@ public void multiplyAndAssignmentOperationExpr_invalidByteBoxedWithIntegerBoxedT VariableExpr rhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "y"); assertThrows( IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); } @Test @@ -386,7 +417,7 @@ public void multiplyAndAssignmentOperationExpr_invalidShortBoxedWithIntegerBoxed VariableExpr rhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "y"); assertThrows( IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); } @Test @@ -397,7 +428,7 @@ public void multiplyAndAssignmentOperationExpr_validCharacterBoxedWithIntegerBox VariableExpr rhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "y"); assertThrows( IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); } @Test @@ -407,7 +438,7 @@ public void multiplyAndAssignmentOperationExpr_invalidCharBoxedWithFloatBoxedTyp VariableExpr rhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "y"); assertThrows( IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); } @Test @@ -417,7 +448,7 @@ public void multiplyAndAssignmentOperationExpr_invalidByteBoxedWithFloatBoxedTyp VariableExpr rhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "y"); assertThrows( IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); } /** ======== Multiply And Assignment Operators: LHS data type is Double Boxed Type ============ */ @@ -428,7 +459,7 @@ public void multiplyAndAssignmentOperationExpr_validDoubleBoxedWithIntegerBoxedT // "multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithDoubleBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.DOUBLE_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "y"); - AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); // No exception thrown, so we succeeded. } @@ -437,7 +468,7 @@ public void multiplyAndAssignmentOperationExpr_validDoubleBoxedWithFloatBoxedTyp // Swap test case in "multiplyAndAssignmentOperationExpr_invalidFloatBoxedWithDoubleBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.DOUBLE_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "y"); - AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); // No exception thrown, so we succeeded. } @@ -446,7 +477,7 @@ public void multiplyAndAssignmentOperationExpr_validDoubleBoxedWithLongBoxedType // Swap test case in "multiplyAndAssignmentOperationExpr_invalidLongBoxedWithDoubleBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.DOUBLE_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.LONG_OBJECT, "y"); - AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); // No exception thrown, so we succeeded. } @@ -454,30 +485,30 @@ public void multiplyAndAssignmentOperationExpr_validDoubleBoxedWithLongBoxedType public void multiplyAndAssignmentOperationExpr_invalidDoubleBoxedWithReferenceType() { // Swap test case in "multiplyAndAssignmentOperationExpr_invalidReferenceWithDoubleBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.DOUBLE_OBJECT, "x"); - VariableExpr rhsExpr = createVariableExpr(TypeNode.STRING, "y"); + ValueExpr valueExpr = ValueExpr.withValue(StringObjectValue.withValue("abc")); assertThrows( IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, valueExpr)); } @Test public void multiplyAndAssignmentOperationExpr_invalidDoubleBoxedWithNullType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_invalidNullWithDoubleBoxedType". + // No need swap case. VariableExpr lhsExpr = createVariableExpr(TypeNode.DOUBLE_OBJECT, "x"); - ValueExpr rhsExpr = ValueExpr.withValue(NullObjectValue.create()); + ValueExpr valueExprExpr = ValueExpr.withValue(NullObjectValue.create()); assertThrows( IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, valueExprExpr)); } @Test public void multiplyAndAssignmentOperationExpr_invalidDoubleBoxedWithOjectType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_invalidObjectWithDoubleBoxedType". + // No need swap test. VariableExpr lhsExpr = createVariableExpr(TypeNode.DOUBLE_OBJECT, "x"); NewObjectExpr rhsExpr = NewObjectExpr.withType(TypeNode.OBJECT); assertThrows( IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); } /** ======== Multiply And Assignment Operators: LHS data type is Long boxed type ============ */ @@ -486,7 +517,7 @@ public void multiplyAndAssignmentOperationExpr_validLongBoxedWithIntegerBoxedTyp // Swap test case in "multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithLongBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.LONG_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "y"); - AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); // No exception thrown, so we succeeded. } @@ -497,7 +528,7 @@ public void multiplyAndAssignmentOperationExpr_invalidLongBoxedWithFloatBoxedTyp VariableExpr rhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "y"); assertThrows( IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); } @Test @@ -507,7 +538,7 @@ public void multiplyAndAssignmentOperationExpr_invalidLongBoxedWithFloatType() { VariableExpr rhsExpr = createVariableExpr(TypeNode.FLOAT, "y"); assertThrows( IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); } @Test @@ -517,7 +548,7 @@ public void multiplyAndAssignmentOperationExpr_invalidLongBoxedWithDoubleBoxedTy VariableExpr rhsExpr = createVariableExpr(TypeNode.DOUBLE_OBJECT, "y"); assertThrows( IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); } @Test @@ -527,7 +558,7 @@ public void multiplyAndAssignmentOperationExpr_invalidLongBoxedWithDoubleType() VariableExpr rhsExpr = createVariableExpr(TypeNode.DOUBLE, "y"); assertThrows( IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); } @Test @@ -537,17 +568,17 @@ public void multiplyAndAssignmentOperationExpr_invalidLongBoxedWithNullType() { ValueExpr rhsExpr = ValueExpr.withValue(NullObjectValue.create()); assertThrows( IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); } @Test public void multiplyAndAssignmentOperationExpr_invalidLongBoxedWithObjectType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_invalidObjectWithLongBoxedType". + // No need swap case. VariableExpr lhsExpr = createVariableExpr(TypeNode.LONG_OBJECT, "x"); NewObjectExpr rhsExpr = NewObjectExpr.withType(TypeNode.OBJECT); assertThrows( IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); } @Test @@ -557,7 +588,7 @@ public void multiplyAndAssignmentOperationExpr_invalidLongBoxedWithReferenceType VariableExpr rhsExpr = createVariableExpr(TypeNode.STRING, "y"); assertThrows( IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); } /** ======== Multiply And Assignment Operators: LHS data type is Reference Type ============ */ @@ -568,7 +599,7 @@ public void multiplyAndAssignmentOperationExpr_invalidReferencedWithNumericType( VariableExpr rhsExpr = createVariableExpr(TypeNode.DOUBLE, "y"); assertThrows( IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); } @Test @@ -578,7 +609,7 @@ public void multiplyAndAssignmentOperationExpr_invalidReferenceWithFloatBoxedTyp VariableExpr rhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "y"); assertThrows( IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); } @Test @@ -588,7 +619,7 @@ public void multiplyAndAssignmentOperationExpr_invalidReferenceWithLongBoxedType VariableExpr rhsExpr = createVariableExpr(TypeNode.LONG_OBJECT, "y"); assertThrows( IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); } @Test @@ -598,120 +629,34 @@ public void multiplyAndAssignmentOperationExpr_invalidReferenceWithDoubleBoxedTy VariableExpr rhsExpr = createVariableExpr(TypeNode.DOUBLE_OBJECT, "y"); assertThrows( IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); - } - - /** ======== Multiply And Assignment Operators: LHS data type is Object Type ============ */ - @Test - public void multiplyAndAssignmentOperationExpr_invalidNewObjectWithNumeric() { - // Swap test case in "multiplyAndAssignmentOperationExpr_invalidNumericWithNewObject". - NewObjectExpr lhsExpr = NewObjectExpr.withType(TypeNode.OBJECT); - VariableExpr rhsExpr = createVariableExpr(TypeNode.INT, "x"); - assertThrows( - IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); - } - - @Test - public void multiplyAndAssignmentOperationExpr_invalidObjectWithFloatBoxedType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_validDoubleBoxedWithFloatBoxedType". - NewObjectExpr lhsExpr = NewObjectExpr.withType(TypeNode.OBJECT); - VariableExpr rhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "x"); - assertThrows( - IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); - } - - @Test - public void multiplyAndAssignmentOperationExpr_invalidObjectWithLongBoxedType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_invalidLongBoxedWithObjectType". - NewObjectExpr lhsExpr = NewObjectExpr.withType(TypeNode.OBJECT); - VariableExpr rhsExpr = createVariableExpr(TypeNode.LONG_OBJECT, "x"); - assertThrows( - IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); - } - - @Test - public void multiplyAndAssignmentOperationExpr_invalidObjectWithDoubleBoxedType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_invalidDoubleBoxedWithOjectType". - NewObjectExpr lhsExpr = NewObjectExpr.withType(TypeNode.OBJECT); - VariableExpr rhsExpr = createVariableExpr(TypeNode.DOUBLE_OBJECT, "x"); - assertThrows( - IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); - } - - /** ======== Multiply And Assignment Operators: LHS data type is Null Type ============ */ - @Test - public void multiplyAndAssignmentOperationExpr_invalidNullWithNumericType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_invalidNumericWithNullType". - ValueExpr lhsExpr = ValueExpr.withValue(NullObjectValue.create()); - VariableExpr rhsExpr = createVariableExpr(TypeNode.FLOAT, "y"); - assertThrows( - IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); - } - - @Test - public void multiplyAndAssignmentOperationExpr_invalidNullWithLongBoxedType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_invalidLongBoxedWithNullType". - ValueExpr lhsExpr = ValueExpr.withValue(NullObjectValue.create()); - VariableExpr rhsExpr = createVariableExpr(TypeNode.LONG_OBJECT, "x"); - assertThrows( - IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); - } - - @Test - public void multiplyAndAssignmentOperationExpr_invalidNullWithFloatBoxedType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_invalidFloatBoxedWithNullType". - ValueExpr lhsExpr = ValueExpr.withValue(NullObjectValue.create()); - VariableExpr rhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "x"); - assertThrows( - IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); - } - - @Test - public void multiplyAndAssignmentOperationExpr_invalidNullWithDoubleBoxedType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_invalidDoubleBoxedWithNullType". - ValueExpr lhsExpr = ValueExpr.withValue(NullObjectValue.create()); - VariableExpr rhsExpr = createVariableExpr(TypeNode.DOUBLE_OBJECT, "x"); - assertThrows( - IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); - } - - /** ======== Multiply And Assignment Operators: Void type ============ */ - @Test - public void multiplyAndAssignmentOperationExpr_invalidVoidType() { - // No need swap case. - MethodInvocationExpr lhsExpr = - MethodInvocationExpr.builder().setMethodName("x").setReturnType(TypeNode.VOID).build(); - MethodInvocationExpr rhsExpr = - MethodInvocationExpr.builder().setMethodName("y").setReturnType(TypeNode.VOID).build(); - assertThrows( - IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); } + /** ======================= Multiply And Assignment Operators: Void type ===================== */ @Test public void multiplyAndAssignmentOperationExpr_invalidWithOneVoidType() { // No need swap case. - MethodInvocationExpr lhsExpr = + VariableExpr lhsExprExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "x"); + MethodInvocationExpr rhsExpr = MethodInvocationExpr.builder().setMethodName("x").setReturnType(TypeNode.VOID).build(); - VariableExpr rhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "x"); assertThrows( IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr)); + () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExprExpr, rhsExpr)); } // TODO(summerji): Complete the type-checking for ^= and unit test. - /** ======== Bitwise Exclusive Or And Assignment Operators: ============ */ + /** ================== Bitwise Exclusive Or And Assignment Operators: ======================== */ + // createVariableExpr is help function to create a variable expr. private VariableExpr createVariableExpr(TypeNode type, String name) { Variable variable = Variable.builder().setName(name).setType(type).build(); - VariableExpr variableExpr = VariableExpr.withVariable(variable); - return variableExpr; + VariableExpr lhsExpr = VariableExpr.withVariable(variable); + return lhsExpr; + } + + // createValueExpr is help function to create a value expr. + private ValueExpr createValueExpr(TypeNode type, String value) { + PrimitiveValue primitiveValue = PrimitiveValue.builder().setType(type).setValue(value).build(); + ValueExpr valueExpr = ValueExpr.withValue(primitiveValue); + return valueExpr; } } diff --git a/src/test/java/com/google/api/generator/engine/writer/JavaWriterVisitorTest.java b/src/test/java/com/google/api/generator/engine/writer/JavaWriterVisitorTest.java index 31f640dc32..e796e39e37 100644 --- a/src/test/java/com/google/api/generator/engine/writer/JavaWriterVisitorTest.java +++ b/src/test/java/com/google/api/generator/engine/writer/JavaWriterVisitorTest.java @@ -2132,20 +2132,20 @@ public void writeLogicalOperationExpr_logicalOr() { } @Test - public void writeAssignmentOperationExpr_multiplyAndAssignment() { - VariableExpr lhsExpr = VariableExpr.withVariable(createVariable("h", TypeNode.INT)); + public void writeAssignmentOperationExpr_multiplyAssignment() { + VariableExpr lhsExpr = createVariableExpr("h", TypeNode.INT); ValueExpr rhsExpr = ValueExpr.withValue( PrimitiveValue.builder().setType(TypeNode.INT).setValue("1000003").build()); AssignmentOperationExpr assignmentOperationExpr = - AssignmentOperationExpr.multiplyAndAssignmentWithExprs(lhsExpr, rhsExpr); + AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); assignmentOperationExpr.accept(writerVisitor); assertThat(writerVisitor.write()).isEqualTo("h *= 1000003"); } @Test - public void writeAssignmentOperationExpr_bitwiseExclusiveOrAndAssignment() { - VariableExpr lhsExpr = VariableExpr.withVariable(createVariable("h", TypeNode.INT)); + public void writeAssignmentOperationExpr_xorAssignment() { + VariableExpr lhsExpr = createVariableExpr("h", TypeNode.INT); TypeNode objectType = TypeNode.withReference( VaporReference.builder().setName("Objects").setPakkage("java.lang.Object").build()); @@ -2159,7 +2159,7 @@ public void writeAssignmentOperationExpr_bitwiseExclusiveOrAndAssignment() { VariableExpr.withVariable(createVariable("fixedValue", TypeNode.OBJECT)))) .build(); AssignmentOperationExpr assignmentOperationExpr = - AssignmentOperationExpr.bitwiseExclusiveOrAndAssignmentWithExprs(lhsExpr, rhsExpr); + AssignmentOperationExpr.xorAssignmentWithExprs(lhsExpr, rhsExpr); assignmentOperationExpr.accept(writerVisitor); assertThat(writerVisitor.write()).isEqualTo("h ^= Objects.hashCode(fixedValue)"); } From 2083c82bc532e80cc86f82d7b8665ab63b1a1a0c Mon Sep 17 00:00:00 2001 From: summerji Date: Tue, 15 Sep 2020 14:50:57 -0700 Subject: [PATCH 10/15] add type-checking for *= --- .../engine/writer/JavaWriterVisitorTest.java | 40 ------------------- 1 file changed, 40 deletions(-) diff --git a/src/test/java/com/google/api/generator/engine/writer/JavaWriterVisitorTest.java b/src/test/java/com/google/api/generator/engine/writer/JavaWriterVisitorTest.java index e796e39e37..8fde78d31e 100644 --- a/src/test/java/com/google/api/generator/engine/writer/JavaWriterVisitorTest.java +++ b/src/test/java/com/google/api/generator/engine/writer/JavaWriterVisitorTest.java @@ -46,7 +46,6 @@ import com.google.api.generator.engine.ast.PrimitiveValue; import com.google.api.generator.engine.ast.Reference; import com.google.api.generator.engine.ast.ReferenceConstructorExpr; -import com.google.api.generator.engine.ast.RelationalOperationExpr; import com.google.api.generator.engine.ast.ReturnExpr; import com.google.api.generator.engine.ast.ScopeNode; import com.google.api.generator.engine.ast.Statement; @@ -2060,45 +2059,6 @@ public void writeUnaryOperationExpr_logicalNot() { assertThat(writerVisitor.write()).isEqualTo("!isEmpty()"); } - @Test - public void writeRelationalOperationExpr_equalTo() { - VariableExpr variableExprLHS = - VariableExpr.withVariable( - Variable.builder().setType(TypeNode.BOOLEAN_OBJECT).setName("isGood").build()); - MethodInvocationExpr methodInvocationExpr = - MethodInvocationExpr.builder() - .setMethodName("isBad") - .setReturnType(TypeNode.BOOLEAN) - .build(); - - RelationalOperationExpr equalToOperationExpr = - RelationalOperationExpr.equalToWithExprs(variableExprLHS, methodInvocationExpr); - equalToOperationExpr.accept(writerVisitor); - assertThat(writerVisitor.write()).isEqualTo("isGood == isBad()"); - } - - @Test - public void writeRelationOperationExpr_notEqualTo() { - TypeNode someType = - TypeNode.withReference( - VaporReference.builder() - .setName("SomeClass") - .setPakkage("com.google.api.generator.engine") - .build()); - MethodInvocationExpr lhsExpr = - MethodInvocationExpr.builder() - .setMethodName("getName") - .setStaticReferenceType(someType) - .setReturnType(TypeNode.STRING) - .build(); - ValueExpr rhsExpr = ValueExpr.withValue(NullObjectValue.create()); - - RelationalOperationExpr notEqualToOperationExpr = - RelationalOperationExpr.notEqualToWithExprs(lhsExpr, rhsExpr); - notEqualToOperationExpr.accept(writerVisitor); - assertThat(writerVisitor.write()).isEqualTo("SomeClass.getName() != null"); - } - @Test public void writeLogicalOperationExpr_logicalAnd() { VariableExpr lhsExpr = VariableExpr.withVariable(createVariable("isEmpty", TypeNode.BOOLEAN)); From ea2ce3ed48f7d5cee24fe094fd8c89542bf953e7 Mon Sep 17 00:00:00 2001 From: summerji Date: Tue, 15 Sep 2020 18:56:16 -0700 Subject: [PATCH 11/15] add license --- .../api/generator/engine/ast/AssignmentOperationExprTest.java | 1 + 1 file changed, 1 insertion(+) diff --git a/src/test/java/com/google/api/generator/engine/ast/AssignmentOperationExprTest.java b/src/test/java/com/google/api/generator/engine/ast/AssignmentOperationExprTest.java index 5c0a48568f..4b4d4b37b4 100644 --- a/src/test/java/com/google/api/generator/engine/ast/AssignmentOperationExprTest.java +++ b/src/test/java/com/google/api/generator/engine/ast/AssignmentOperationExprTest.java @@ -61,6 +61,7 @@ public void multiplyAndAssignmentOperationExpr_validNumericMatched() { // No exception thrown, so we succeeded. } + @Test public void multiplyAndAssignmentOperationExpr_validNumericUnmatched() { // No need swap test case. From f9a204485adbff791b16278507b441ec0eb89655 Mon Sep 17 00:00:00 2001 From: summerji Date: Tue, 15 Sep 2020 19:03:01 -0700 Subject: [PATCH 12/15] fix linter --- .../api/generator/engine/ast/AssignmentOperationExprTest.java | 1 - 1 file changed, 1 deletion(-) diff --git a/src/test/java/com/google/api/generator/engine/ast/AssignmentOperationExprTest.java b/src/test/java/com/google/api/generator/engine/ast/AssignmentOperationExprTest.java index 4b4d4b37b4..5c0a48568f 100644 --- a/src/test/java/com/google/api/generator/engine/ast/AssignmentOperationExprTest.java +++ b/src/test/java/com/google/api/generator/engine/ast/AssignmentOperationExprTest.java @@ -61,7 +61,6 @@ public void multiplyAndAssignmentOperationExpr_validNumericMatched() { // No exception thrown, so we succeeded. } - @Test public void multiplyAndAssignmentOperationExpr_validNumericUnmatched() { // No need swap test case. From d857d3841cbdb8def4e656f664a2925172656730 Mon Sep 17 00:00:00 2001 From: summerji Date: Mon, 21 Sep 2020 17:20:43 -0700 Subject: [PATCH 13/15] import package' --- .../api/generator/engine/writer/JavaWriterVisitorTest.java | 1 + 1 file changed, 1 insertion(+) diff --git a/src/test/java/com/google/api/generator/engine/writer/JavaWriterVisitorTest.java b/src/test/java/com/google/api/generator/engine/writer/JavaWriterVisitorTest.java index 3b6fb3f5e3..5745b8e01f 100644 --- a/src/test/java/com/google/api/generator/engine/writer/JavaWriterVisitorTest.java +++ b/src/test/java/com/google/api/generator/engine/writer/JavaWriterVisitorTest.java @@ -46,6 +46,7 @@ import com.google.api.generator.engine.ast.PrimitiveValue; import com.google.api.generator.engine.ast.Reference; import com.google.api.generator.engine.ast.ReferenceConstructorExpr; +import com.google.api.generator.engine.ast.RelationalOperationExpr; import com.google.api.generator.engine.ast.ReturnExpr; import com.google.api.generator.engine.ast.ScopeNode; import com.google.api.generator.engine.ast.Statement; From 08e8a44f955350a1bf597d7cbb73b06cb92317fe Mon Sep 17 00:00:00 2001 From: summerji Date: Mon, 21 Sep 2020 22:45:25 -0700 Subject: [PATCH 14/15] rename unit tests --- .../engine/ast/AssignmentOperationExpr.java | 19 +- .../ast/AssignmentOperationExprTest.java | 286 +++++++++--------- 2 files changed, 149 insertions(+), 156 deletions(-) diff --git a/src/main/java/com/google/api/generator/engine/ast/AssignmentOperationExpr.java b/src/main/java/com/google/api/generator/engine/ast/AssignmentOperationExpr.java index 6211b680a2..f4296c986f 100644 --- a/src/main/java/com/google/api/generator/engine/ast/AssignmentOperationExpr.java +++ b/src/main/java/com/google/api/generator/engine/ast/AssignmentOperationExpr.java @@ -73,38 +73,31 @@ abstract static class Builder { private AssignmentOperationExpr build() { AssignmentOperationExpr assignmentOperationExpr = autoBuild(); TypeNode lhsType = assignmentOperationExpr.variableExpr().variable().type(); - TypeNode rhsType = - assignmentOperationExpr.valueExpr() instanceof VariableExpr - ? ((VariableExpr) assignmentOperationExpr.valueExpr()).variable().type() - : assignmentOperationExpr.valueExpr().type(); + TypeNode rhsType = assignmentOperationExpr.valueExpr().type(); OperatorKind operator = assignmentOperationExpr.operatorKind(); // Check if the variable exprs have been declared, if yes, throw error. Preconditions.checkState( - !assignmentOperationExpr.variableExpr().isDecl() - && (assignmentOperationExpr.valueExpr() instanceof VariableExpr - ? !((VariableExpr) assignmentOperationExpr.valueExpr()).isDecl() - : true), + !assignmentOperationExpr.variableExpr().isDecl(), String.format( "Variable `%s` should not be declaration in the variable expression.", assignmentOperationExpr.variableExpr().variable().name())); - // TYPE_CHECK_ERROR_MSG is type checking error message for operators. - final String TYPE_CHECK_ERROR_MSG = + // errorMsg is type checking error message for operators. + final String errorMsg = String.format( "Assignment operator %s can not be applied to %s, %s.", operator, lhsType.toString(), rhsType.toString()); // Check type for multiply and assignment operator (*=). if (operator.equals(OperatorKind.ASSIGNMENT_MULTIPLY)) { - Preconditions.checkState( - isValidMultiplyAssignmentType(lhsType, rhsType), TYPE_CHECK_ERROR_MSG); + Preconditions.checkState(isValidMultiplyAssignmentType(lhsType, rhsType), errorMsg); } // Check type for XOR and assignment operator (^=). // TODO(summerji): Complete the type-checking for ^= and unit test. if (operator.equals(OperatorKind.ASSIGNMENT_XOR)) { - Preconditions.checkState(isValidXORAssignmentType(lhsType, rhsType), TYPE_CHECK_ERROR_MSG); + Preconditions.checkState(isValidXORAssignmentType(lhsType, rhsType), errorMsg); } return assignmentOperationExpr; } diff --git a/src/test/java/com/google/api/generator/engine/ast/AssignmentOperationExprTest.java b/src/test/java/com/google/api/generator/engine/ast/AssignmentOperationExprTest.java index 5c0a48568f..4ca573ce4d 100644 --- a/src/test/java/com/google/api/generator/engine/ast/AssignmentOperationExprTest.java +++ b/src/test/java/com/google/api/generator/engine/ast/AssignmentOperationExprTest.java @@ -19,41 +19,9 @@ import org.junit.Test; public class AssignmentOperationExprTest { - /** =========== Multiply And Assignment Operators: Variable is declaration ================ */ - @Test - public void multiplyAndAssignmentOperationExpr_invalidVariableExprIsDecl() { - Variable variable = Variable.builder().setName("x").setType(TypeNode.INT).build(); - VariableExpr lhsExpr = VariableExpr.builder().setVariable(variable).setIsDecl(true).build(); - VariableExpr rhsExpr = createVariableExpr(TypeNode.INT, "y"); - assertThrows( - IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); - } - - @Test - public void multiplyAndAssignmentOperationExpr_invalidValueExprIsDecl() { - VariableExpr lhsExpr = createVariableExpr(TypeNode.INT, "x"); - Variable variable = Variable.builder().setName("x").setType(TypeNode.INT).build(); - VariableExpr rhsExpr = VariableExpr.builder().setVariable(variable).setIsDecl(true).build(); - assertThrows( - IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); - } - - @Test - public void multiplyAndAssignmentOperationExpr_invalidVariableExprAndValueExprIsDecl() { - Variable lVariable = Variable.builder().setName("x").setType(TypeNode.INT).build(); - VariableExpr lhsExpr = VariableExpr.builder().setVariable(lVariable).setIsDecl(true).build(); - Variable rVariable = Variable.builder().setName("y").setType(TypeNode.INT).build(); - VariableExpr rhsExpr = VariableExpr.builder().setVariable(rVariable).setIsDecl(true).build(); - assertThrows( - IllegalStateException.class, - () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); - } - /** ========= Multiply And Assignment Operators: VariableExpr is numeric types ============== */ @Test - public void multiplyAndAssignmentOperationExpr_validNumericMatched() { + public void validMultiplyAndAssignmentOperationExpr_numericMatched() { // No need swap test case. VariableExpr lhsExpr = createVariableExpr(TypeNode.INT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.INT, "y"); @@ -62,7 +30,7 @@ public void multiplyAndAssignmentOperationExpr_validNumericMatched() { } @Test - public void multiplyAndAssignmentOperationExpr_validNumericUnmatched() { + public void validMultiplyAndAssignmentOperationExpr_numericUnmatched() { // No need swap test case. VariableExpr lhsExpr = createVariableExpr(TypeNode.INT, "x"); ValueExpr rhsExpr = createValueExpr(TypeNode.INT, "5"); @@ -71,8 +39,8 @@ public void multiplyAndAssignmentOperationExpr_validNumericUnmatched() { } @Test - public void multiplyAndAssignmentOperationExpr_validNumericMatchedBoxedType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_validIntegerMatchedBoxedType". + public void validMultiplyAndAssignmentOperationExpr_numericMatchedBoxedType() { + // Swap test case in "validMultiplyAndAssignmentOperationExpr_integerMatchedBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.INT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "y"); AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); @@ -80,8 +48,8 @@ public void multiplyAndAssignmentOperationExpr_validNumericMatchedBoxedType() { } @Test - public void multiplyAndAssignmentOperationExpr_validNumericUnmatchedBoxedType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_validIntegerBoxedWithShortType". + public void validMultiplyAndAssignmentOperationExpr_numericUnmatchedBoxedType() { + // Swap test case in "validMultiplyAndAssignmentOperationExpr_integerBoxedWithShortType". VariableExpr lhsExpr = createVariableExpr(TypeNode.INT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "y"); AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); @@ -89,8 +57,8 @@ public void multiplyAndAssignmentOperationExpr_validNumericUnmatchedBoxedType() } @Test - public void multiplyAndAssignmentOperationExpr_validNumericWithFloatType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithFloatType". + public void validMultiplyAndAssignmentOperationExpr_numericWithFloatType() { + // Swap test case in "validMultiplyAndAssignmentOperationExpr_integerBoxedWithFloatType". VariableExpr lhsExpr = createVariableExpr(TypeNode.FLOAT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "y"); AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); @@ -98,8 +66,8 @@ public void multiplyAndAssignmentOperationExpr_validNumericWithFloatType() { } @Test - public void multiplyAndAssignmentOperationExpr_validDoubleWithIntegerBoxedType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithDoubleType". + public void validMultiplyAndAssignmentOperationExpr_doubleWithIntegerBoxedType() { + // Swap test case in "validMultiplyAndAssignmentOperationExpr_integerBoxedWithDoubleType". VariableExpr lhsExpr = createVariableExpr(TypeNode.DOUBLE, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "y"); AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); @@ -107,8 +75,8 @@ public void multiplyAndAssignmentOperationExpr_validDoubleWithIntegerBoxedType() } @Test - public void multiplyAndAssignmentOperationExpr_validDoubleWithLongBoxedType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_invalidLongBoxedWithDoubleType". + public void validMultiplyAndAssignmentOperationExpr_doubleWithLongBoxedType() { + // Swap test case in "invalidMultiplyAndAssignmentOperationExpr_longBoxedWithDoubleType". VariableExpr lhsExpr = createVariableExpr(TypeNode.DOUBLE, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.LONG_OBJECT, "y"); AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); @@ -116,8 +84,8 @@ public void multiplyAndAssignmentOperationExpr_validDoubleWithLongBoxedType() { } @Test - public void multiplyAndAssignmentOperationExpr_validLongWithIntegerBoxedType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithLongType". + public void validMultiplyAndAssignmentOperationExpr_longWithIntegerBoxedType() { + // Swap test case in "invalidMultiplyAndAssignmentOperationExpr_integerBoxedWithLongType". VariableExpr lhsExpr = createVariableExpr(TypeNode.LONG, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "y"); AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); @@ -125,8 +93,8 @@ public void multiplyAndAssignmentOperationExpr_validLongWithIntegerBoxedType() { } @Test - public void multiplyAndAssignmentOperationExpr_validIntegerWithFloatBoxedType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_validFloatBoxedWithIntegerType". + public void validMultiplyAndAssignmentOperationExpr_integerWithFloatBoxedType() { + // Swap test case in "validMultiplyAndAssignmentOperationExpr_floatBoxedWithIntegerType". VariableExpr lhsExpr = createVariableExpr(TypeNode.INT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "y"); AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); @@ -134,8 +102,8 @@ public void multiplyAndAssignmentOperationExpr_validIntegerWithFloatBoxedType() } @Test - public void multiplyAndAssignmentOperationExpr_validFloatWithLongBoxedType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_invalidLongBoxedWithFloatType". + public void validMultiplyAndAssignmentOperationExpr_validFloatWithLongBoxedType() { + // Swap test case in "invalidMultiplyAndAssignmentOperationExpr_longBoxedWithFloatType". VariableExpr lhsExpr = createVariableExpr(TypeNode.FLOAT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.LONG_OBJECT, "y"); AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); @@ -143,8 +111,8 @@ public void multiplyAndAssignmentOperationExpr_validFloatWithLongBoxedType() { } @Test - public void multiplyAndAssignmentOperationExpr_invalidNumericWithBooleanBoxedType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_invalidBooleanBoxedWithNumericType". + public void invalidMultiplyAndAssignmentOperationExpr_numericWithBooleanBoxedType() { + // Swap test case in "invalidMultiplyAndAssignmentOperationExpr_booleanBoxedWithNumericType". VariableExpr lhsExpr = createVariableExpr(TypeNode.INT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.BOOLEAN_OBJECT, "y"); assertThrows( @@ -153,8 +121,8 @@ public void multiplyAndAssignmentOperationExpr_invalidNumericWithBooleanBoxedTyp } @Test - public void multiplyAndAssignmentOperationExpr_invalidNumericWithBooleanType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_invalidNumericWithBooleanType". + public void invalidMultiplyAndAssignmentOperationExpr_numericWithBooleanType() { + // Swap test case in "invalidMultiplyAndAssignmentOperationExpr_numericWithBooleanType". VariableExpr lhsExpr = createVariableExpr(TypeNode.INT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.BOOLEAN, "y"); assertThrows( @@ -163,8 +131,8 @@ public void multiplyAndAssignmentOperationExpr_invalidNumericWithBooleanType() { } @Test - public void multiplyAndAssignmentOperationExpr_invalidNumericWithReferenceType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_invalidReferencedWithNumericType". + public void invalidMultiplyAndAssignmentOperationExpr_numericWithReferenceType() { + // Swap test case in "invalidMultiplyAndAssignmentOperationExpr_feferencedWithNumericType". VariableExpr lhsExpr = createVariableExpr(TypeNode.INT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.STRING, "y"); assertThrows( @@ -173,7 +141,7 @@ public void multiplyAndAssignmentOperationExpr_invalidNumericWithReferenceType() } @Test - public void multiplyAndAssignmentOperationExpr_invalidNumericWithNewObject() { + public void invalidMultiplyAndAssignmentOperationExpr_NumericWithNewObject() { // No Need swap case. VariableExpr lhsExpr = createVariableExpr(TypeNode.INT, "x"); NewObjectExpr rhsExpr = NewObjectExpr.withType(TypeNode.OBJECT); @@ -184,8 +152,8 @@ public void multiplyAndAssignmentOperationExpr_invalidNumericWithNewObject() { /** ==== Multiply And Assignment Operators: LHS data type is boolean and its boxed type ===== */ @Test - public void multiplyAndAssignmentOperationExpr_invalidBooleanWithNumericType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_invalidNumericWithBooleanType". + public void invalidMultiplyAndAssignmentOperationExpr_booleanWithNumericType() { + // Swap test case in "invalidMultiplyAndAssignmentOperationExpr_numericWithBooleanType". VariableExpr lhsExpr = createVariableExpr(TypeNode.BOOLEAN, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.INT, "y"); assertThrows( @@ -194,8 +162,8 @@ public void multiplyAndAssignmentOperationExpr_invalidBooleanWithNumericType() { } @Test - public void multiplyAndAssignmentOperationExpr_invalidBooleanBoxedWithNumericType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_invalidNumericWithBooleanBoxedType". + public void invalidMultiplyAndAssignmentOperationExpr_booleanBoxedWithNumericType() { + // Swap test case in "invalidMultiplyAndAssignmentOperationExpr_numericWithBooleanBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.BOOLEAN_OBJECT, "x"); ValueExpr rhsExpr = createValueExpr(TypeNode.INT, "5"); assertThrows( @@ -206,8 +174,8 @@ public void multiplyAndAssignmentOperationExpr_invalidBooleanBoxedWithNumericTyp /** ======== Multiply And Assignment Operators: LHS data type is Integer Box Type ============ */ // RHS should be int, char, short, byte or these types' boxed types. @Test - public void multiplyAndAssignmentOperationExpr_validIntegerMatchedBoxedType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_validNumericMatchedBoxedType". + public void validMultiplyAndAssignmentOperationExpr_integerMatchedBoxedType() { + // Swap test case in "validMultiplyAndAssignmentOperationExpr_numericMatchedBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "x"); ValueExpr rhsExpr = createValueExpr(TypeNode.INT, "5"); AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); @@ -215,8 +183,8 @@ public void multiplyAndAssignmentOperationExpr_validIntegerMatchedBoxedType() { } @Test - public void multiplyAndAssignmentOperationExpr_validIntegerBoxedWithShortType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_validNumericUnmatchedBoxedType". + public void validMultiplyAndAssignmentOperationExpr_integerBoxedWithShortType() { + // Swap test case in "validMultiplyAndAssignmentOperationExpr_numericUnmatchedBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.SHORT, "y"); AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); @@ -224,8 +192,8 @@ public void multiplyAndAssignmentOperationExpr_validIntegerBoxedWithShortType() } @Test - public void multiplyAndAssignmentOperationExpr_validIntegerBoxedWithShortBoxedType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_validShortBoxedWithIntegerBoxedType". + public void validMultiplyAndAssignmentOperationExpr_integerBoxedWithShortBoxedType() { + // Swap test case in "validMultiplyAndAssignmentOperationExpr_shortBoxedWithIntegerBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.SHORT_OBJECT, "y"); AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); @@ -233,8 +201,8 @@ public void multiplyAndAssignmentOperationExpr_validIntegerBoxedWithShortBoxedTy } @Test - public void multiplyAndAssignmentOperationExpr_validIntegerBoxedWithCharacterBoxedType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_validShortBoxedWithIntegerBoxedType". + public void validMultiplyAndAssignmentOperationExpr_integerBoxedWithCharacterBoxedType() { + // Swap test case in "validMultiplyAndAssignmentOperationExpr_shortBoxedWithIntegerBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.CHAR_OBJECT, "y"); AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); @@ -242,8 +210,8 @@ public void multiplyAndAssignmentOperationExpr_validIntegerBoxedWithCharacterBox } @Test - public void multiplyAndAssignmentOperationExpr_validIntegerBoxedWithByteBoxedType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_validByteBoxedWithIntegerBoxedType". + public void validMultiplyAndAssignmentOperationExpr_integerBoxedWithByteBoxedType() { + // Swap test case in "validMultiplyAndAssignmentOperationExpr_byteBoxedWithIntegerBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.BYTE_OBJECT, "y"); AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); @@ -251,8 +219,8 @@ public void multiplyAndAssignmentOperationExpr_validIntegerBoxedWithByteBoxedTyp } @Test - public void multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithFloatType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_validNumericWithFloatType". + public void invalidMultiplyAndAssignmentOperationExpr_integerBoxedWithFloatType() { + // Swap test case in "validMultiplyAndAssignmentOperationExpr_numericWithFloatType". VariableExpr lhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.FLOAT, "y"); assertThrows( @@ -261,8 +229,8 @@ public void multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithFloatType( } @Test - public void multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithFloatBoxedType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_validFloatBoxedWithIntegerBoxedType". + public void invalidMultiplyAndAssignmentOperationExpr_integerBoxedWithFloatBoxedType() { + // Swap test case in "validMultiplyAndAssignmentOperationExpr_floatBoxedWithIntegerBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "y"); assertThrows( @@ -271,8 +239,8 @@ public void multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithFloatBoxed } @Test - public void multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithDoubleType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_validDoubleWithIntegerBoxedType". + public void invalidMultiplyAndAssignmentOperationExpr_integerBoxedWithDoubleType() { + // Swap test case in "validMultiplyAndAssignmentOperationExpr_doubleWithIntegerBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.DOUBLE, "y"); assertThrows( @@ -281,8 +249,8 @@ public void multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithDoubleType } @Test - public void multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithDoubleBoxedType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_validDoubleBoxedWithIntegerBoxedType". + public void invalidMultiplyAndAssignmentOperationExpr_integerBoxedWithDoubleBoxedType() { + // Swap test case in "validMultiplyAndAssignmentOperationExpr_doubleBoxedWithIntegerBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.DOUBLE_OBJECT, "y"); assertThrows( @@ -291,8 +259,8 @@ public void multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithDoubleBoxe } @Test - public void multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithLongType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_validLongWithIntegerBoxedType". + public void invalidMultiplyAndAssignmentOperationExpr_integerBoxedWithLongType() { + // Swap test case in "validMultiplyAndAssignmentOperationExpr_longWithIntegerBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.LONG, "y"); assertThrows( @@ -301,8 +269,8 @@ public void multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithLongType() } @Test - public void multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithLongBoxedType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_validLongBoxedWithIntegerBoxedType". + public void invalidMultiplyAndAssignmentOperationExpr_integerBoxedWithLongBoxedType() { + // Swap test case in "validMultiplyAndAssignmentOperationExpr_longBoxedWithIntegerBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.LONG_OBJECT, "y"); assertThrows( @@ -313,8 +281,8 @@ public void multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithLongBoxedT /** ==== Multiply And Assignment Operators: LHS data type is Float boxed type ====== */ // RHS could be numeric or numeric boxed type, beside double and its boxed type. @Test - public void multiplyAndAssignmentOperationExpr_validFloatBoxedWithIntegerType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_validIntegerWithFloatBoxedType". + public void validMultiplyAndAssignmentOperationExpr_floatBoxedWithIntegerType() { + // Swap test case in "validMultiplyAndAssignmentOperationExpr_integerWithFloatBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "x"); ValueExpr rhsExpr = createValueExpr(TypeNode.INT, "5"); AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); @@ -322,8 +290,8 @@ public void multiplyAndAssignmentOperationExpr_validFloatBoxedWithIntegerType() } @Test - public void multiplyAndAssignmentOperationExpr_validFloatBoxedWithIntegerBoxedType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithFloatBoxedType". + public void validMultiplyAndAssignmentOperationExpr_floatBoxedWithIntegerBoxedType() { + // Swap test case in "invalidMultiplyAndAssignmentOperationExpr_integerBoxedWithFloatBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "y"); AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); @@ -331,8 +299,8 @@ public void multiplyAndAssignmentOperationExpr_validFloatBoxedWithIntegerBoxedTy } @Test - public void multiplyAndAssignmentOperationExpr_validFloatBoxedWithCharBoxedType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_invalidCharBoxedWithFloatBoxedType". + public void validMultiplyAndAssignmentOperationExpr_floatBoxedWithCharBoxedType() { + // Swap test case in "invalidMultiplyAndAssignmentOperationExpr_charBoxedWithFloatBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.CHAR_OBJECT, "y"); AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); @@ -340,8 +308,8 @@ public void multiplyAndAssignmentOperationExpr_validFloatBoxedWithCharBoxedType( } @Test - public void multiplyAndAssignmentOperationExpr_validFloatBoxedWithByteBoxedType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_invalidByteBoxedWithFloatBoxedType". + public void validMultiplyAndAssignmentOperationExpr_floatBoxedWithByteBoxedType() { + // Swap test case in "invalidMultiplyAndAssignmentOperationExpr_byteBoxedWithFloatBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.BYTE_OBJECT, "y"); AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); @@ -349,8 +317,8 @@ public void multiplyAndAssignmentOperationExpr_validFloatBoxedWithByteBoxedType( } @Test - public void multiplyAndAssignmentOperationExpr_validFloatBoxedWithLongBoxedType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_invalidLongBoxedWithFloatBoxedType". + public void validMultiplyAndAssignmentOperationExpr_floatBoxedWithLongBoxedType() { + // Swap test case in "invalidMultiplyAndAssignmentOperationExpr_longBoxedWithFloatBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.LONG_OBJECT, "y"); AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); @@ -358,8 +326,8 @@ public void multiplyAndAssignmentOperationExpr_validFloatBoxedWithLongBoxedType( } @Test - public void multiplyAndAssignmentOperationExpr_invalidFloatBoxedWithDoubleBoxedType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_validDoubleBoxedWithFloatBoxedType". + public void validMultiplyAndAssignmentOperationExpr_floatBoxedWithDoubleBoxedType() { + // Swap test case in "validMultiplyAndAssignmentOperationExpr_doubleBoxedWithFloatBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.DOUBLE_OBJECT, "y"); assertThrows( @@ -368,7 +336,7 @@ public void multiplyAndAssignmentOperationExpr_invalidFloatBoxedWithDoubleBoxedT } @Test - public void multiplyAndAssignmentOperationExpr_invalidFloatBoxedWithObjectType() { + public void invalidMultiplyAndAssignmentOperationExpr_floatBoxedWithObjectType() { // No need swap case. VariableExpr lhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "x"); NewObjectExpr rhsExpr = NewObjectExpr.withType(TypeNode.OBJECT); @@ -378,7 +346,7 @@ public void multiplyAndAssignmentOperationExpr_invalidFloatBoxedWithObjectType() } @Test - public void multiplyAndAssignmentOperationExpr_invalidFloatBoxedWithNullType() { + public void invalidMultiplyAndAssignmentOperationExpr_floatBoxedWithNullType() { // No need swap case. VariableExpr lhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "x"); ValueExpr rhsExpr = ValueExpr.withValue(NullObjectValue.create()); @@ -388,8 +356,8 @@ public void multiplyAndAssignmentOperationExpr_invalidFloatBoxedWithNullType() { } @Test - public void multiplyAndAssignmentOperationExpr_invalidFloatBoxedWithReferenceType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_invalidReferenceWithFloatBoxedType". + public void invalidMultiplyAndAssignmentOperationExpr_floatBoxedWithReferenceType() { + // Swap test case in "invalidMultiplyAndAssignmentOperationExpr_referenceWithFloatBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.STRING, "y"); assertThrows( @@ -400,8 +368,8 @@ public void multiplyAndAssignmentOperationExpr_invalidFloatBoxedWithReferenceTyp /** ==== Multiply And Assignment Operators: LHS data type is Short/Char/Byte Boxed Type ====== */ // RHS has no valid type. @Test - public void multiplyAndAssignmentOperationExpr_invalidByteBoxedWithIntegerBoxedType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_validIntegerBoxedWithByteBoxedType". + public void invalidMultiplyAndAssignmentOperationExpr_byteBoxedWithIntegerBoxedType() { + // Swap test case in "validMultiplyAndAssignmentOperationExpr_integerBoxedWithByteBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.BYTE_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "y"); assertThrows( @@ -410,9 +378,9 @@ public void multiplyAndAssignmentOperationExpr_invalidByteBoxedWithIntegerBoxedT } @Test - public void multiplyAndAssignmentOperationExpr_invalidShortBoxedWithIntegerBoxedType() { + public void invalidMultiplyAndAssignmentOperationExpr_shortBoxedWithIntegerBoxedType() { // Swap test case in - // "multiplyAndAssignmentOperationExpr_validCharacterBoxedWithIntegerBoxedType". + // "validMultiplyAndAssignmentOperationExpr_validCharacterBoxedWithIntegerBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.SHORT_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "y"); assertThrows( @@ -421,9 +389,9 @@ public void multiplyAndAssignmentOperationExpr_invalidShortBoxedWithIntegerBoxed } @Test - public void multiplyAndAssignmentOperationExpr_validCharacterBoxedWithIntegerBoxedType() { + public void validMultiplyAndAssignmentOperationExpr_characterBoxedWithIntegerBoxedType() { // Swap test case in - // "multiplyAndAssignmentOperationExpr_validIntegerBoxedWithCharacterBoxedType". + // "validMultiplyAndAssignmentOperationExpr_integerBoxedWithCharacterBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.CHAR_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "y"); assertThrows( @@ -432,8 +400,8 @@ public void multiplyAndAssignmentOperationExpr_validCharacterBoxedWithIntegerBox } @Test - public void multiplyAndAssignmentOperationExpr_invalidCharBoxedWithFloatBoxedType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithFloatBoxedType". + public void invalidMultiplyAndAssignmentOperationExpr_charBoxedWithFloatBoxedType() { + // Swap test case in "invalidMultiplyAndAssignmentOperationExpr_integerBoxedWithFloatBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.CHAR_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "y"); assertThrows( @@ -442,8 +410,8 @@ public void multiplyAndAssignmentOperationExpr_invalidCharBoxedWithFloatBoxedTyp } @Test - public void multiplyAndAssignmentOperationExpr_invalidByteBoxedWithFloatBoxedType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_validFloatBoxedWithByteBoxedType". + public void invalidMultiplyAndAssignmentOperationExpr_byteBoxedWithFloatBoxedType() { + // Swap test case in "validMultiplyAndAssignmentOperationExpr_floatBoxedWithByteBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.BYTE_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "y"); assertThrows( @@ -454,9 +422,9 @@ public void multiplyAndAssignmentOperationExpr_invalidByteBoxedWithFloatBoxedTyp /** ======== Multiply And Assignment Operators: LHS data type is Double Boxed Type ============ */ // RHS could be any numeric type or numeric boxed type. @Test - public void multiplyAndAssignmentOperationExpr_validDoubleBoxedWithIntegerBoxedType() { + public void validMultiplyAndAssignmentOperationExpr_doubleBoxedWithIntegerBoxedType() { // Swap test case in - // "multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithDoubleBoxedType". + // "invalidMultiplyAndAssignmentOperationExpr_integerBoxedWithDoubleBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.DOUBLE_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "y"); AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); @@ -464,8 +432,8 @@ public void multiplyAndAssignmentOperationExpr_validDoubleBoxedWithIntegerBoxedT } @Test - public void multiplyAndAssignmentOperationExpr_validDoubleBoxedWithFloatBoxedType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_invalidFloatBoxedWithDoubleBoxedType". + public void validMultiplyAndAssignmentOperationExpr_doubleBoxedWithFloatBoxedType() { + // Swap test case in "invalidMultiplyAndAssignmentOperationExpr_floatBoxedWithDoubleBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.DOUBLE_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "y"); AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); @@ -473,8 +441,8 @@ public void multiplyAndAssignmentOperationExpr_validDoubleBoxedWithFloatBoxedTyp } @Test - public void multiplyAndAssignmentOperationExpr_validDoubleBoxedWithLongBoxedType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_invalidLongBoxedWithDoubleBoxedType". + public void validMultiplyAndAssignmentOperationExpr_doubleBoxedWithLongBoxedType() { + // Swap test case in "invalidMultiplyAndAssignmentOperationExpr_longBoxedWithDoubleBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.DOUBLE_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.LONG_OBJECT, "y"); AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); @@ -482,8 +450,8 @@ public void multiplyAndAssignmentOperationExpr_validDoubleBoxedWithLongBoxedType } @Test - public void multiplyAndAssignmentOperationExpr_invalidDoubleBoxedWithReferenceType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_invalidReferenceWithDoubleBoxedType". + public void invalidMultiplyAndAssignmentOperationExpr_doubleBoxedWithReferenceType() { + // Swap test case in "invalidMultiplyAndAssignmentOperationExpr_referenceWithDoubleBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.DOUBLE_OBJECT, "x"); ValueExpr valueExpr = ValueExpr.withValue(StringObjectValue.withValue("abc")); assertThrows( @@ -492,7 +460,7 @@ public void multiplyAndAssignmentOperationExpr_invalidDoubleBoxedWithReferenceTy } @Test - public void multiplyAndAssignmentOperationExpr_invalidDoubleBoxedWithNullType() { + public void invalidMultiplyAndAssignmentOperationExpr_doubleBoxedWithNullType() { // No need swap case. VariableExpr lhsExpr = createVariableExpr(TypeNode.DOUBLE_OBJECT, "x"); ValueExpr valueExprExpr = ValueExpr.withValue(NullObjectValue.create()); @@ -502,7 +470,7 @@ public void multiplyAndAssignmentOperationExpr_invalidDoubleBoxedWithNullType() } @Test - public void multiplyAndAssignmentOperationExpr_invalidDoubleBoxedWithOjectType() { + public void invalidMultiplyAndAssignmentOperationExpr_doubleBoxedWithOjectType() { // No need swap test. VariableExpr lhsExpr = createVariableExpr(TypeNode.DOUBLE_OBJECT, "x"); NewObjectExpr rhsExpr = NewObjectExpr.withType(TypeNode.OBJECT); @@ -513,8 +481,8 @@ public void multiplyAndAssignmentOperationExpr_invalidDoubleBoxedWithOjectType() /** ======== Multiply And Assignment Operators: LHS data type is Long boxed type ============ */ @Test - public void multiplyAndAssignmentOperationExpr_validLongBoxedWithIntegerBoxedType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_invalidIntegerBoxedWithLongBoxedType". + public void validMultiplyAndAssignmentOperationExpr_longBoxedWithIntegerBoxedType() { + // Swap test case in "invalidMultiplyAndAssignmentOperationExpr_integerBoxedWithLongBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.LONG_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.INT_OBJECT, "y"); AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr); @@ -522,8 +490,8 @@ public void multiplyAndAssignmentOperationExpr_validLongBoxedWithIntegerBoxedTyp } @Test - public void multiplyAndAssignmentOperationExpr_invalidLongBoxedWithFloatBoxedType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_validFloatBoxedWithLongBoxedType". + public void invalidMultiplyAndAssignmentOperationExpr_longBoxedWithFloatBoxedType() { + // Swap test case in "validMultiplyAndAssignmentOperationExpr_floatBoxedWithLongBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.LONG_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "y"); assertThrows( @@ -532,8 +500,8 @@ public void multiplyAndAssignmentOperationExpr_invalidLongBoxedWithFloatBoxedTyp } @Test - public void multiplyAndAssignmentOperationExpr_invalidLongBoxedWithFloatType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_validFloatWithLongBoxedType". + public void invalidMultiplyAndAssignmentOperationExpr_longBoxedWithFloatType() { + // Swap test case in "validMultiplyAndAssignmentOperationExpr_floatWithLongBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.LONG_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.FLOAT, "y"); assertThrows( @@ -542,8 +510,8 @@ public void multiplyAndAssignmentOperationExpr_invalidLongBoxedWithFloatType() { } @Test - public void multiplyAndAssignmentOperationExpr_invalidLongBoxedWithDoubleBoxedType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_validDoubleBoxedWithLongBoxedType". + public void invalidMultiplyAndAssignmentOperationExpr_longBoxedWithDoubleBoxedType() { + // Swap test case in "validMultiplyAndAssignmentOperationExpr_doubleBoxedWithLongBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.LONG_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.DOUBLE_OBJECT, "y"); assertThrows( @@ -552,8 +520,8 @@ public void multiplyAndAssignmentOperationExpr_invalidLongBoxedWithDoubleBoxedTy } @Test - public void multiplyAndAssignmentOperationExpr_invalidLongBoxedWithDoubleType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_validDoubleWithLongBoxedType". + public void invalidMultiplyAndAssignmentOperationExpr_longBoxedWithDoubleType() { + // Swap test case in "validMultiplyAndAssignmentOperationExpr_doubleWithLongBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.LONG_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.DOUBLE, "y"); assertThrows( @@ -562,8 +530,8 @@ public void multiplyAndAssignmentOperationExpr_invalidLongBoxedWithDoubleType() } @Test - public void multiplyAndAssignmentOperationExpr_invalidLongBoxedWithNullType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_invalidNullWithLongBoxedType". + public void invalidMultiplyAndAssignmentOperationExpr_longBoxedWithNullType() { + // Swap test case in "invalidMultiplyAndAssignmentOperationExpr_nullWithLongBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.LONG_OBJECT, "x"); ValueExpr rhsExpr = ValueExpr.withValue(NullObjectValue.create()); assertThrows( @@ -572,7 +540,7 @@ public void multiplyAndAssignmentOperationExpr_invalidLongBoxedWithNullType() { } @Test - public void multiplyAndAssignmentOperationExpr_invalidLongBoxedWithObjectType() { + public void invalidMultiplyAndAssignmentOperationExpr_longBoxedWithObjectType() { // No need swap case. VariableExpr lhsExpr = createVariableExpr(TypeNode.LONG_OBJECT, "x"); NewObjectExpr rhsExpr = NewObjectExpr.withType(TypeNode.OBJECT); @@ -582,8 +550,8 @@ public void multiplyAndAssignmentOperationExpr_invalidLongBoxedWithObjectType() } @Test - public void multiplyAndAssignmentOperationExpr_invalidLongBoxedWithReferenceType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_invalidReferenceWithLongBoxedType". + public void invalidMultiplyAndAssignmentOperationExpr_longBoxedWithReferenceType() { + // Swap test case in "invalidMultiplyAndAssignmentOperationExpr_referenceWithLongBoxedType". VariableExpr lhsExpr = createVariableExpr(TypeNode.LONG_OBJECT, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.STRING, "y"); assertThrows( @@ -593,8 +561,8 @@ public void multiplyAndAssignmentOperationExpr_invalidLongBoxedWithReferenceType /** ======== Multiply And Assignment Operators: LHS data type is Reference Type ============ */ @Test - public void multiplyAndAssignmentOperationExpr_invalidReferencedWithNumericType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_invalidNumericWithReferenceType". + public void invalidMultiplyAndAssignmentOperationExpr_referencedWithNumericType() { + // Swap test case in "invalidMultiplyAndAssignmentOperationExpr_numericWithReferenceType". VariableExpr lhsExpr = createVariableExpr(TypeNode.STRING, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.DOUBLE, "y"); assertThrows( @@ -603,8 +571,8 @@ public void multiplyAndAssignmentOperationExpr_invalidReferencedWithNumericType( } @Test - public void multiplyAndAssignmentOperationExpr_invalidReferenceWithFloatBoxedType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_invalidFloatBoxedWithReferenceType". + public void invalidMultiplyAndAssignmentOperationExpr_referenceWithFloatBoxedType() { + // Swap test case in "invalidMultiplyAndAssignmentOperationExpr_floatBoxedWithReferenceType". VariableExpr lhsExpr = createVariableExpr(TypeNode.STRING, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "y"); assertThrows( @@ -613,8 +581,8 @@ public void multiplyAndAssignmentOperationExpr_invalidReferenceWithFloatBoxedTyp } @Test - public void multiplyAndAssignmentOperationExpr_invalidReferenceWithLongBoxedType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_invalidLongBoxedWithReferenceType". + public void invalidMultiplyAndAssignmentOperationExpr_referenceWithLongBoxedType() { + // Swap test case in "invalidMultiplyAndAssignmentOperationExpr_longBoxedWithReferenceType". VariableExpr lhsExpr = createVariableExpr(TypeNode.STRING, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.LONG_OBJECT, "y"); assertThrows( @@ -623,8 +591,8 @@ public void multiplyAndAssignmentOperationExpr_invalidReferenceWithLongBoxedType } @Test - public void multiplyAndAssignmentOperationExpr_invalidReferenceWithDoubleBoxedType() { - // Swap test case in "multiplyAndAssignmentOperationExpr_invalidDoubleBoxedWithReferenceType". + public void invalidMultiplyAndAssignmentOperationExpr_referenceWithDoubleBoxedType() { + // Swap test case in "invalidMultiplyAndAssignmentOperationExpr_doubleBoxedWithReferenceType". VariableExpr lhsExpr = createVariableExpr(TypeNode.STRING, "x"); VariableExpr rhsExpr = createVariableExpr(TypeNode.DOUBLE_OBJECT, "y"); assertThrows( @@ -632,9 +600,41 @@ public void multiplyAndAssignmentOperationExpr_invalidReferenceWithDoubleBoxedTy () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); } + /** =========== Multiply And Assignment Operators: Variable is declaration ================ */ + @Test + public void invalidMultiplyAndAssignmentOperationExpr_variableExprIsDecl() { + Variable variable = Variable.builder().setName("x").setType(TypeNode.INT).build(); + VariableExpr lhsExpr = VariableExpr.builder().setVariable(variable).setIsDecl(true).build(); + VariableExpr rhsExpr = createVariableExpr(TypeNode.INT, "y"); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + @Test + public void invalidMultiplyAndAssignmentOperationExpr_valueExprIsDecl() { + VariableExpr lhsExpr = createVariableExpr(TypeNode.INT, "x"); + Variable variable = Variable.builder().setName("x").setType(TypeNode.INT).build(); + VariableExpr rhsExpr = VariableExpr.builder().setVariable(variable).setIsDecl(true).build(); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); + } + + @Test + public void invalidMultiplyAndAssignmentOperationExpr_variableExprAndValueExprIsDecl() { + Variable lVariable = Variable.builder().setName("x").setType(TypeNode.INT).build(); + VariableExpr lhsExpr = VariableExpr.builder().setVariable(lVariable).setIsDecl(true).build(); + Variable rVariable = Variable.builder().setName("y").setType(TypeNode.INT).build(); + VariableExpr rhsExpr = VariableExpr.builder().setVariable(rVariable).setIsDecl(true).build(); + assertThrows( + IllegalStateException.class, + () -> AssignmentOperationExpr.multiplyAssignmentWithExprs(lhsExpr, rhsExpr)); + } + /** ======================= Multiply And Assignment Operators: Void type ===================== */ @Test - public void multiplyAndAssignmentOperationExpr_invalidWithOneVoidType() { + public void invalidMultiplyAndAssignmentOperationExpr_voidType() { // No need swap case. VariableExpr lhsExprExpr = createVariableExpr(TypeNode.FLOAT_OBJECT, "x"); MethodInvocationExpr rhsExpr = From e424b0d7e5b0812fede5dc322ed5d2baa7ea30bb Mon Sep 17 00:00:00 2001 From: summerji Date: Tue, 22 Sep 2020 15:42:09 -0700 Subject: [PATCH 15/15] consistent with INT --- .../api/generator/engine/ast/AssignmentOperationExpr.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/main/java/com/google/api/generator/engine/ast/AssignmentOperationExpr.java b/src/main/java/com/google/api/generator/engine/ast/AssignmentOperationExpr.java index f4296c986f..8802465f98 100644 --- a/src/main/java/com/google/api/generator/engine/ast/AssignmentOperationExpr.java +++ b/src/main/java/com/google/api/generator/engine/ast/AssignmentOperationExpr.java @@ -110,20 +110,20 @@ private boolean isValidMultiplyAssignmentType(TypeNode variableType, TypeNode va return TypeNode.isNumericType(valueType); } // LHS is integer boxed type, RHS should be any numeric type except long, float, double. - if (variableType.equals(TypeNode.INT_OBJECT)) { + if (variableType.equals(TypeNode.INT)) { return TypeNode.isNumericType(valueType) && !(valueType.equals(TypeNode.LONG) || TypeNode.isFloatingPointType(valueType)); } // LHS is long boxed type, RHS should be any numeric type except float, double. - if (variableType.equals(TypeNode.LONG_OBJECT)) { + if (variableType.equals(TypeNode.LONG)) { return TypeNode.isNumericType(valueType) && !TypeNode.isFloatingPointType(valueType); } // LHS is integer boxed type, RHS should be any numeric type except double. - if (variableType.equals(TypeNode.FLOAT_OBJECT)) { + if (variableType.equals(TypeNode.FLOAT)) { return TypeNode.isNumericType(valueType) && !valueType.equals(TypeNode.DOUBLE); } // LHS is integer boxed type, RHS should be any numeric type or any numeric boxed type. - if (variableType.equals(TypeNode.DOUBLE_OBJECT)) { + if (variableType.equals(TypeNode.DOUBLE)) { return TypeNode.isNumericType(valueType); } // *= operator does not support boxed Short, Character, Byte, null, reference, void type.