diff --git a/src/test/java/com/caoccao/javet/buddy/ts2java/BaseTestTs2Java.java b/src/test/java/com/caoccao/javet/buddy/ts2java/BaseTestTs2Java.java index eb909bf..6856604 100644 --- a/src/test/java/com/caoccao/javet/buddy/ts2java/BaseTestTs2Java.java +++ b/src/test/java/com/caoccao/javet/buddy/ts2java/BaseTestTs2Java.java @@ -34,4 +34,5 @@ protected String getTsCode(String relativePath) throws IOException { .filter(line -> !line.startsWith("console.")) .collect(Collectors.joining("\n")); } + } diff --git a/src/test/java/com/caoccao/javet/buddy/ts2java/TsClass.java b/src/test/java/com/caoccao/javet/buddy/ts2java/TsClass.java new file mode 100644 index 0000000..e7e11e8 --- /dev/null +++ b/src/test/java/com/caoccao/javet/buddy/ts2java/TsClass.java @@ -0,0 +1,127 @@ +/* + * Copyright (c) 2024. caoccao.com Sam Cao + * + * 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.caoccao.javet.buddy.ts2java; + +import com.caoccao.javet.swc4j.exceptions.Swc4jCoreException; +import com.caoccao.javet.swc4j.utils.SimpleList; +import com.caoccao.javet.utils.SimpleFreeMarkerFormat; +import com.caoccao.javet.utils.SimpleMap; + +import java.lang.reflect.Method; +import java.lang.reflect.Parameter; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.IntStream; + +import static org.junit.jupiter.api.Assertions.*; + +public final class TsClass { + private final List arguments; + private final String body; + private final Class returnType; + private Object instance; + private Class testClass; + private Method testMethod; + + public TsClass(String body, Class returnType, TsMethodArgument... arguments) { + assertNotNull(body); + assertNotNull(returnType); + assertNotNull(arguments); + this.arguments = SimpleList.immutableOf(arguments); + this.body = body; + this.returnType = returnType; + instance = null; + testClass = null; + testMethod = null; + init(); + } + + public List getArguments() { + return arguments; + } + + public String getBody() { + return body; + } + + public Object getInstance() throws Exception { + if (instance == null) { + instance = testClass.getConstructor().newInstance(); + } + return instance; + } + + public Class getReturnType() { + return returnType; + } + + public Class getTestClass() { + return testClass; + } + + public Method getTestMethod() { + return testMethod; + } + + private void init() { + String argumentsString = arguments.stream() + .map(TsMethodArgument::toString) + .collect(Collectors.joining(", ")); + String codeString = SimpleFreeMarkerFormat.format( + "class Test {\n" + + " public test(${argumentsString}): ${returnType} {\n" + + " ${body}\n" + + " }\n" + + "}\n", + SimpleMap.of( + "argumentsString", argumentsString, + "returnType", returnType.getName(), + "body", body)); + Ts2Java ts2Java = new Ts2Java("com.test", codeString); + try { + ts2Java.transpile(); + } catch (Swc4jCoreException e) { + fail(e); + } + List> classes = ts2Java.getClasses(); + assertEquals(1, classes.size()); + testClass = classes.get(0); + assertEquals("Test", testClass.getSimpleName()); + assertEquals("com.test.Test", testClass.getName()); + try { + testMethod = testClass.getMethod( + "test", + arguments.stream().map(TsMethodArgument::getType).toArray(Class[]::new)); + assertEquals(returnType, testMethod.getReturnType()); + final int argumentsLength = arguments.size(); + final Parameter[] parameters = testMethod.getParameters(); + assertEquals(argumentsLength, testMethod.getParameterCount()); + assertEquals(argumentsLength, parameters.length); + IntStream.range(0, argumentsLength) + .forEach(i -> assertEquals( + arguments.get(i).getType(), + parameters[i].getType(), + "Argument[" + i + "] type mismatch")); + } catch (NoSuchMethodException e) { + fail(e); + } + } + + public Object invoke(Object... arguments) throws Exception { + return testMethod.invoke(getInstance(), arguments); + } +} diff --git a/src/test/java/com/caoccao/javet/buddy/ts2java/TsMethodArgument.java b/src/test/java/com/caoccao/javet/buddy/ts2java/TsMethodArgument.java new file mode 100644 index 0000000..41f1706 --- /dev/null +++ b/src/test/java/com/caoccao/javet/buddy/ts2java/TsMethodArgument.java @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2024. caoccao.com Sam Cao + * + * 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.caoccao.javet.buddy.ts2java; + +import static org.junit.jupiter.api.Assertions.assertNotNull; + +public final class TsMethodArgument { + private final String name; + private final Class type; + + public TsMethodArgument(String name, Class type) { + assertNotNull(name); + assertNotNull(type); + this.name = name; + this.type = type; + } + + public static TsMethodArgument of(String name, Class type) { + return new TsMethodArgument(name, type); + } + + public String getName() { + return name; + } + + public Class getType() { + return type; + } + + @Override + public String toString() { + return name + ": " + type.getName(); + } +} diff --git a/src/test/java/com/caoccao/javet/buddy/ts2java/ast/TestAssignments.java b/src/test/java/com/caoccao/javet/buddy/ts2java/ast/TestAssignments.java index 7c02e46..05b13b8 100644 --- a/src/test/java/com/caoccao/javet/buddy/ts2java/ast/TestAssignments.java +++ b/src/test/java/com/caoccao/javet/buddy/ts2java/ast/TestAssignments.java @@ -17,24 +17,13 @@ package com.caoccao.javet.buddy.ts2java.ast; import com.caoccao.javet.buddy.ts2java.BaseTestTs2Java; -import com.caoccao.javet.buddy.ts2java.Ts2Java; -import com.caoccao.javet.swc4j.exceptions.Swc4jCoreException; +import com.caoccao.javet.buddy.ts2java.TsClass; +import com.caoccao.javet.buddy.ts2java.TsMethodArgument; import org.junit.jupiter.api.Test; -import java.io.IOException; -import java.lang.reflect.Method; -import java.util.List; - -import static org.junit.jupiter.api.Assertions.*; +import static org.junit.jupiter.api.Assertions.assertEquals; public class TestAssignments extends BaseTestTs2Java { - protected static Class clazz = null; - - public TestAssignments() { - super(); - init(); - } - /* public assignAndCast(IJ)D L0 @@ -105,52 +94,29 @@ public long assignConst(int a, long b) { return a + b + c + d; } - protected void init() { - if (clazz == null) { - String tsCode = null; - try { - tsCode = getTsCode("test.assignments.ts"); - } catch (IOException e) { - fail(e); - } - assertNotNull(tsCode); - Ts2Java ts2Java = new Ts2Java("com.test", tsCode); - try { - ts2Java.transpile(); - } catch (Swc4jCoreException e) { - fail(e); - } - List> classes = ts2Java.getClasses(); - assertEquals(1, classes.size()); - clazz = classes.get(0); - assertEquals("Test", clazz.getSimpleName()); - assertEquals("com.test.Test", clazz.getName()); - } - } - @Test public void testAssignAndCast() throws Exception { assertEquals(3.0D, assignAndCast(1, 2L), 0.001D); - Method method = clazz.getMethod("assignAndCast", int.class, long.class); - assertNotNull(method); - assertEquals(double.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(int.class, method.getParameters()[0].getType()); - assertEquals(long.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertEquals(3.0D, (double) method.invoke(object, 1, 2L), 0.001D); + TsClass tsClass = new TsClass( + "let c: long = a;\n" + + "let d: long = b;\n" + + "return c + d;", + double.class, + TsMethodArgument.of("a", int.class), + TsMethodArgument.of("b", long.class)); + assertEquals(3.0D, (double) tsClass.invoke(1, 2L), 0.001D); } @Test public void testAssignConst() throws Exception { assertEquals(105L, assignConst(1, 2L)); - Method method = clazz.getMethod("assignConst", int.class, long.class); - assertNotNull(method); - assertEquals(long.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(int.class, method.getParameters()[0].getType()); - assertEquals(long.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertEquals(105L, method.invoke(object, 1, 2L)); + TsClass tsClass = new TsClass( + "const c: int = 100;\n" + + "const d: long = 2;\n" + + "return a + b + c + d;", + long.class, + TsMethodArgument.of("a", int.class), + TsMethodArgument.of("b", long.class)); + assertEquals(105L, tsClass.invoke(1, 2L)); } } diff --git a/src/test/java/com/caoccao/javet/buddy/ts2java/ast/TestBasicOperations.java b/src/test/java/com/caoccao/javet/buddy/ts2java/ast/TestBasicOperations.java index 5cae410..d58db57 100644 --- a/src/test/java/com/caoccao/javet/buddy/ts2java/ast/TestBasicOperations.java +++ b/src/test/java/com/caoccao/javet/buddy/ts2java/ast/TestBasicOperations.java @@ -17,24 +17,15 @@ package com.caoccao.javet.buddy.ts2java.ast; import com.caoccao.javet.buddy.ts2java.BaseTestTs2Java; -import com.caoccao.javet.buddy.ts2java.Ts2Java; -import com.caoccao.javet.swc4j.exceptions.Swc4jCoreException; +import com.caoccao.javet.buddy.ts2java.TsClass; +import com.caoccao.javet.buddy.ts2java.TsMethodArgument; import org.junit.jupiter.api.Test; -import java.io.IOException; import java.lang.reflect.Method; -import java.util.List; -import static org.junit.jupiter.api.Assertions.*; +import static org.junit.jupiter.api.Assertions.assertEquals; public class TestBasicOperations extends BaseTestTs2Java { - protected static Class clazz = null; - - public TestBasicOperations() { - super(); - init(); - } - /* public add(II)I L0 @@ -62,29 +53,6 @@ public long add(int a, long b) { return a + b; } - protected void init() { - if (clazz == null) { - String tsCode = null; - try { - tsCode = getTsCode("test.basic.operations.ts"); - } catch (IOException e) { - fail(e); - } - assertNotNull(tsCode); - Ts2Java ts2Java = new Ts2Java("com.test", tsCode); - try { - ts2Java.transpile(); - } catch (Swc4jCoreException e) { - fail(e); - } - List> classes = ts2Java.getClasses(); - assertEquals(1, classes.size()); - clazz = classes.get(0); - assertEquals("Test", clazz.getSimpleName()); - assertEquals("com.test.Test", clazz.getName()); - } - } - /* public minus(II)I L0 @@ -126,215 +94,183 @@ public double pow(double a, double b) { @Test public void testAdd_DD_I() throws Exception { - Method method = clazz.getMethod("add_DD_I", double.class, double.class); - assertNotNull(method); - assertEquals(double.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(double.class, method.getParameters()[0].getType()); - assertEquals(double.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertEquals(1D + 2D - 1D, (double) method.invoke(object, 1D, 2D), 0.001D); - assertEquals(1.23D + 2D - 1D, (double) method.invoke(object, 1.23D, 2D), 0.001D); + TsClass tsClass = new TsClass( + "return a + b + (-1);", + double.class, + TsMethodArgument.of("a", double.class), + TsMethodArgument.of("b", double.class)); + assertEquals(1D + 2D - 1D, (double) tsClass.invoke(1D, 2D), 0.001D); + assertEquals(1.23D + 2D - 1D, (double) tsClass.invoke(1.23D, 2D), 0.001D); } @Test public void testAdd_FF_I() throws Exception { - Method method = clazz.getMethod("add_FF_I", float.class, float.class); - assertNotNull(method); - assertEquals(float.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(float.class, method.getParameters()[0].getType()); - assertEquals(float.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertEquals(1F + 2F - 1F, (float) method.invoke(object, 1F, 2F), 0.001F); - assertEquals(1.23F + 2F - 1F, (float) method.invoke(object, 1.23F, 2F), 0.001F); + TsClass tsClass = new TsClass( + "return a + b + (-1);", + float.class, + TsMethodArgument.of("a", float.class), + TsMethodArgument.of("b", float.class)); + assertEquals(1F + 2F - 1F, (float) tsClass.invoke(1F, 2F), 0.001F); + assertEquals(1.23F + 2F - 1F, (float) tsClass.invoke(1.23F, 2F), 0.001F); } @Test public void testAdd_II_I() throws Exception { assertEquals(3, add(1, 2)); - Method method = clazz.getMethod("add_II_I", int.class, int.class); - assertNotNull(method); - assertEquals(int.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(int.class, method.getParameters()[0].getType()); - assertEquals(int.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertEquals(1 + 2, method.invoke(object, 1, 2)); - assertEquals(-1 + -2, method.invoke(object, -1, -2)); + TsClass tsClass = new TsClass( + "return a + b;", + int.class, + TsMethodArgument.of("a", int.class), + TsMethodArgument.of("b", int.class)); + assertEquals(1 + 2, tsClass.invoke(1, 2)); + assertEquals(-1 + -2, tsClass.invoke(-1, -2)); } @Test public void testAdd_II_J() throws Exception { assertEquals(3, add(1, 2)); - Method method = clazz.getMethod("add_II_J", int.class, int.class); - assertNotNull(method); - assertEquals(long.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(int.class, method.getParameters()[0].getType()); - assertEquals(int.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); + TsClass tsClass = new TsClass( + "return a + b;", + long.class, + TsMethodArgument.of("a", int.class), + TsMethodArgument.of("b", int.class)); + Method method = tsClass.getTestMethod(); + Object object = tsClass.getTestClass().getConstructor().newInstance(); assertEquals(1L + 2L, method.invoke(object, 1, 2)); } @Test public void testAdd_IJ_J() throws Exception { assertEquals(3, add(1, 2L)); - Method method = clazz.getMethod("add_IJ_J", int.class, long.class); - assertNotNull(method); - assertEquals(long.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(int.class, method.getParameters()[0].getType()); - assertEquals(long.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertEquals(1 + 2L, method.invoke(object, 1, 2L)); + TsClass tsClass = new TsClass( + "return a + b;", + long.class, + TsMethodArgument.of("a", int.class), + TsMethodArgument.of("b", long.class)); + assertEquals(1 + 2L, tsClass.invoke(1, 2L)); } @Test public void testAdd_JI_J() throws Exception { - Method method = clazz.getMethod("add_JI_J", long.class, int.class); - assertNotNull(method); - assertEquals(long.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(long.class, method.getParameters()[0].getType()); - assertEquals(int.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertEquals(1L + 2, method.invoke(object, 1L, 2)); + TsClass tsClass = new TsClass( + "return a + b;", + long.class, + TsMethodArgument.of("a", long.class), + TsMethodArgument.of("b", int.class)); + assertEquals(1L + 2, tsClass.invoke(1L, 2)); } @Test public void testDivide_II_I() throws Exception { - Method method = clazz.getMethod("divide_II_I", int.class, int.class); - assertNotNull(method); - assertEquals(int.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(int.class, method.getParameters()[0].getType()); - assertEquals(int.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertEquals(3 / 2, method.invoke(object, 3, 2)); + TsClass tsClass = new TsClass( + "return a / b;", + int.class, + TsMethodArgument.of("a", int.class), + TsMethodArgument.of("b", int.class)); + assertEquals(3 / 2, tsClass.invoke(3, 2)); } @Test public void testMinus_II_I() throws Exception { assertEquals(-5, minus(3, 2)); - Method method = clazz.getMethod("minus_II_I", int.class, int.class); - assertNotNull(method); - assertEquals(int.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(int.class, method.getParameters()[0].getType()); - assertEquals(int.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertEquals(-5, method.invoke(object, 3, 2)); + TsClass tsClass = new TsClass( + "return -(a + b);", + int.class, + TsMethodArgument.of("a", int.class), + TsMethodArgument.of("b", int.class)); + assertEquals(-5, tsClass.invoke(3, 2)); } @Test public void testMod_II_I() throws Exception { - Method method = clazz.getMethod("mod_II_I", int.class, int.class); - assertNotNull(method); - assertEquals(int.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(int.class, method.getParameters()[0].getType()); - assertEquals(int.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertEquals(3 % 2, method.invoke(object, 3, 2)); + TsClass tsClass = new TsClass( + "return a % b;", + int.class, + TsMethodArgument.of("a", int.class), + TsMethodArgument.of("b", int.class)); + assertEquals(3 % 2, tsClass.invoke(3, 2)); } @Test public void testMultiply_II_I() throws Exception { - Method method = clazz.getMethod("multiply_II_I", int.class, int.class); - assertNotNull(method); - assertEquals(int.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(int.class, method.getParameters()[0].getType()); - assertEquals(int.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertEquals(3 * 2, method.invoke(object, 3, 2)); + TsClass tsClass = new TsClass( + "return a * b;", + int.class, + TsMethodArgument.of("a", int.class), + TsMethodArgument.of("b", int.class)); + assertEquals(3 * 2, tsClass.invoke(3, 2)); } @Test public void testPow_DD_D() throws Exception { assertEquals(8D, pow(2D, 3D), 0.001D); - Method method = clazz.getMethod("pow_DD_D", double.class, double.class); - assertNotNull(method); - assertEquals(double.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(double.class, method.getParameters()[0].getType()); - assertEquals(double.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertEquals(8D, (double) method.invoke(object, 2D, 3D), 0.001D); + TsClass tsClass = new TsClass( + "return a ** b;", + double.class, + TsMethodArgument.of("a", double.class), + TsMethodArgument.of("b", double.class)); + assertEquals(8D, (double) tsClass.invoke(2D, 3D), 0.001D); } @Test public void testPow_II_D() throws Exception { - Method method = clazz.getMethod("pow_II_D", int.class, int.class); - assertNotNull(method); - assertEquals(double.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(int.class, method.getParameters()[0].getType()); - assertEquals(int.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertEquals(8D, (double) method.invoke(object, 2, 3), 0.001D); + TsClass tsClass = new TsClass( + "return a ** b;", + double.class, + TsMethodArgument.of("a", int.class), + TsMethodArgument.of("b", int.class)); + assertEquals(8D, (double) tsClass.invoke(2, 3), 0.001D); } @Test public void testShiftLeft_II_I() throws Exception { - Method method = clazz.getMethod("shiftLeft_II_I", int.class, int.class); - assertNotNull(method); - assertEquals(int.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(int.class, method.getParameters()[0].getType()); - assertEquals(int.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertEquals(3 << 2, method.invoke(object, 3, 2)); + TsClass tsClass = new TsClass( + "return a << b;", + int.class, + TsMethodArgument.of("a", int.class), + TsMethodArgument.of("b", int.class)); + assertEquals(3 << 2, tsClass.invoke(3, 2)); } @Test public void testShiftRight_II_I() throws Exception { - Method method = clazz.getMethod("shiftRight_II_I", int.class, int.class); - assertNotNull(method); - assertEquals(int.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(int.class, method.getParameters()[0].getType()); - assertEquals(int.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertEquals(3 >> 1, method.invoke(object, 3, 1)); + TsClass tsClass = new TsClass( + "return a >> b;", + int.class, + TsMethodArgument.of("a", int.class), + TsMethodArgument.of("b", int.class)); + assertEquals(3 >> 1, tsClass.invoke(3, 1)); } @Test public void testSubtract_II_I() throws Exception { - Method method = clazz.getMethod("subtract_II_I", int.class, int.class); - assertNotNull(method); - assertEquals(int.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(int.class, method.getParameters()[0].getType()); - assertEquals(int.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertEquals(3 - 2, method.invoke(object, 3, 2)); + TsClass tsClass = new TsClass( + "return a - b;", + int.class, + TsMethodArgument.of("a", int.class), + TsMethodArgument.of("b", int.class)); + assertEquals(3 - 2, tsClass.invoke(3, 2)); } @Test public void testZeroFillShiftRight_II_I() throws Exception { - Method method = clazz.getMethod("zeroFillShiftRight_II_I", int.class, int.class); - assertNotNull(method); - assertEquals(int.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(int.class, method.getParameters()[0].getType()); - assertEquals(int.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertEquals(3 >>> 2, method.invoke(object, 3, 2)); - assertEquals(-3 >>> 2, method.invoke(object, -3, 2)); + TsClass tsClass = new TsClass( + "return a >>> b;", + int.class, + TsMethodArgument.of("a", int.class), + TsMethodArgument.of("b", int.class)); + assertEquals(3 >>> 2, tsClass.invoke(3, 2)); + assertEquals(-3 >>> 2, tsClass.invoke(-3, 2)); } @Test public void testZeroFillShiftRight_JJ_J() throws Exception { - Method method = clazz.getMethod("zeroFillShiftRight_JJ_J", long.class, long.class); - assertNotNull(method); - assertEquals(long.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(long.class, method.getParameters()[0].getType()); - assertEquals(long.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertEquals(3L >>> 2L, method.invoke(object, 3L, 2L)); - assertEquals(-3L >>> 2L, method.invoke(object, -3L, 2L)); + TsClass tsClass = new TsClass( + "return a >>> b;", + long.class, + TsMethodArgument.of("a", long.class), + TsMethodArgument.of("b", long.class)); + assertEquals(3L >>> 2L, tsClass.invoke(3L, 2L)); + assertEquals(-3L >>> 2L, tsClass.invoke(-3L, 2L)); } } diff --git a/src/test/java/com/caoccao/javet/buddy/ts2java/ast/TestLogicalOperations.java b/src/test/java/com/caoccao/javet/buddy/ts2java/ast/TestLogicalOperations.java index a804e22..abaa2c5 100644 --- a/src/test/java/com/caoccao/javet/buddy/ts2java/ast/TestLogicalOperations.java +++ b/src/test/java/com/caoccao/javet/buddy/ts2java/ast/TestLogicalOperations.java @@ -17,47 +17,14 @@ package com.caoccao.javet.buddy.ts2java.ast; import com.caoccao.javet.buddy.ts2java.BaseTestTs2Java; -import com.caoccao.javet.buddy.ts2java.Ts2Java; -import com.caoccao.javet.swc4j.exceptions.Swc4jCoreException; +import com.caoccao.javet.buddy.ts2java.TsClass; +import com.caoccao.javet.buddy.ts2java.TsMethodArgument; import org.junit.jupiter.api.Test; -import java.io.IOException; -import java.lang.reflect.Method; -import java.util.List; - -import static org.junit.jupiter.api.Assertions.*; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; public class TestLogicalOperations extends BaseTestTs2Java { - protected static Class clazz = null; - - public TestLogicalOperations() { - super(); - init(); - } - - protected void init() { - if (clazz == null) { - String tsCode = null; - try { - tsCode = getTsCode("test.logical.operations.ts"); - } catch (IOException e) { - fail(e); - } - assertNotNull(tsCode); - Ts2Java ts2Java = new Ts2Java("com.test", tsCode); - try { - ts2Java.transpile(); - } catch (Swc4jCoreException e) { - fail(e); - } - List> classes = ts2Java.getClasses(); - assertEquals(1, classes.size()); - clazz = classes.get(0); - assertEquals("Test", clazz.getSimpleName()); - assertEquals("com.test.Test", clazz.getName()); - } - } - /* public logicalAndOrAnd_II_Z(II)Z L0 @@ -296,843 +263,745 @@ public boolean logicalOr_II_Z(int a, int b) { @Test public void testLogicalEQEQ_DD_Z() throws Exception { - Method method = clazz.getMethod("logicalEQEQ_DD_Z", double.class, double.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(double.class, method.getParameters()[0].getType()); - assertEquals(double.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertFalse((boolean) method.invoke(object, 1D, 2D)); - assertFalse((boolean) method.invoke(object, 2D, 1D)); - assertTrue((boolean) method.invoke(object, 1D, 1D)); - assertTrue((boolean) method.invoke(object, 1.23D, 1.23D)); + TsClass tsClass = new TsClass( + "return a === b;", + boolean.class, + TsMethodArgument.of("a", double.class), + TsMethodArgument.of("b", double.class)); + assertFalse((boolean) tsClass.invoke(1D, 2D)); + assertFalse((boolean) tsClass.invoke(2D, 1D)); + assertTrue((boolean) tsClass.invoke(1D, 1D)); + assertTrue((boolean) tsClass.invoke(1.23D, 1.23D)); } @Test public void testLogicalEQEQ_FF_Z() throws Exception { - Method method = clazz.getMethod("logicalEQEQ_FF_Z", float.class, float.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(float.class, method.getParameters()[0].getType()); - assertEquals(float.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertFalse((boolean) method.invoke(object, 1F, 2F)); - assertFalse((boolean) method.invoke(object, 2F, 1F)); - assertTrue((boolean) method.invoke(object, 1F, 1F)); - assertTrue((boolean) method.invoke(object, 1.23F, 1.23F)); + TsClass tsClass = new TsClass( + "return a === b;", + boolean.class, + TsMethodArgument.of("a", float.class), + TsMethodArgument.of("b", float.class)); + assertFalse((boolean) tsClass.invoke(1F, 2F)); + assertFalse((boolean) tsClass.invoke(2F, 1F)); + assertTrue((boolean) tsClass.invoke(1F, 1F)); + assertTrue((boolean) tsClass.invoke(1.23F, 1.23F)); } @Test public void testLogicalEQEQ_II_Z() throws Exception { - Method method = clazz.getMethod("logicalEQEQ_II_Z", int.class, int.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(int.class, method.getParameters()[0].getType()); - assertEquals(int.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertFalse((boolean) method.invoke(object, 1, 2)); - assertFalse((boolean) method.invoke(object, 2, 1)); - assertTrue((boolean) method.invoke(object, 1, 1)); + TsClass tsClass = new TsClass( + "return a === b;", + boolean.class, + TsMethodArgument.of("a", int.class), + TsMethodArgument.of("b", int.class)); + assertFalse((boolean) tsClass.invoke(1, 2)); + assertFalse((boolean) tsClass.invoke(2, 1)); + assertTrue((boolean) tsClass.invoke(1, 1)); } @Test public void testLogicalEQEQ_IJ_Z() throws Exception { - Method method = clazz.getMethod("logicalEQEQ_IJ_Z", int.class, long.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(int.class, method.getParameters()[0].getType()); - assertEquals(long.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertFalse((boolean) method.invoke(object, 1, 2L)); - assertFalse((boolean) method.invoke(object, 2, 1L)); - assertTrue((boolean) method.invoke(object, 1, 1L)); + TsClass tsClass = new TsClass( + "return a === b;", + boolean.class, + TsMethodArgument.of("a", int.class), + TsMethodArgument.of("b", long.class)); + assertFalse((boolean) tsClass.invoke(1, 2L)); + assertFalse((boolean) tsClass.invoke(2, 1L)); + assertTrue((boolean) tsClass.invoke(1, 1L)); } @Test public void testLogicalEQ_DD_Z() throws Exception { - Method method = clazz.getMethod("logicalEQ_DD_Z", double.class, double.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(double.class, method.getParameters()[0].getType()); - assertEquals(double.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertFalse((boolean) method.invoke(object, 1D, 2D)); - assertFalse((boolean) method.invoke(object, 2D, 1D)); - assertTrue((boolean) method.invoke(object, 1D, 1D)); - assertTrue((boolean) method.invoke(object, 1.23D, 1.23D)); + TsClass tsClass = new TsClass( + "return a == b;", + boolean.class, + TsMethodArgument.of("a", double.class), + TsMethodArgument.of("b", double.class)); + assertFalse((boolean) tsClass.invoke(1D, 2D)); + assertFalse((boolean) tsClass.invoke(2D, 1D)); + assertTrue((boolean) tsClass.invoke(1D, 1D)); + assertTrue((boolean) tsClass.invoke(1.23D, 1.23D)); } @Test public void testLogicalEQ_FF_Z() throws Exception { - Method method = clazz.getMethod("logicalEQ_FF_Z", float.class, float.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(float.class, method.getParameters()[0].getType()); - assertEquals(float.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertFalse((boolean) method.invoke(object, 1F, 2F)); - assertFalse((boolean) method.invoke(object, 2F, 1F)); - assertTrue((boolean) method.invoke(object, 1F, 1F)); - assertTrue((boolean) method.invoke(object, 1.23F, 1.23F)); + TsClass tsClass = new TsClass( + "return a == b;", + boolean.class, + TsMethodArgument.of("a", float.class), + TsMethodArgument.of("b", float.class)); + assertFalse((boolean) tsClass.invoke(1F, 2F)); + assertFalse((boolean) tsClass.invoke(2F, 1F)); + assertTrue((boolean) tsClass.invoke(1F, 1F)); + assertTrue((boolean) tsClass.invoke(1.23F, 1.23F)); } @Test public void testLogicalEQ_II_Z() throws Exception { assertFalse(logicalEQ_II_Z(1, 2)); - Method method = clazz.getMethod("logicalEQ_II_Z", int.class, int.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(int.class, method.getParameters()[0].getType()); - assertEquals(int.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertFalse((boolean) method.invoke(object, 1, 2)); - assertFalse((boolean) method.invoke(object, 2, 1)); - assertTrue((boolean) method.invoke(object, 1, 1)); + TsClass tsClass = new TsClass( + "return a == b;", + boolean.class, + TsMethodArgument.of("a", int.class), + TsMethodArgument.of("b", int.class)); + assertFalse((boolean) tsClass.invoke(1, 2)); + assertFalse((boolean) tsClass.invoke(2, 1)); + assertTrue((boolean) tsClass.invoke(1, 1)); } @Test public void testLogicalEQ_IJ_Z() throws Exception { - Method method = clazz.getMethod("logicalEQ_IJ_Z", int.class, long.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(int.class, method.getParameters()[0].getType()); - assertEquals(long.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertFalse((boolean) method.invoke(object, 1, 2L)); - assertFalse((boolean) method.invoke(object, 2, 1L)); - assertTrue((boolean) method.invoke(object, 1, 1L)); + TsClass tsClass = new TsClass( + "return a == b;", + boolean.class, + TsMethodArgument.of("a", int.class), + TsMethodArgument.of("b", long.class)); + assertFalse((boolean) tsClass.invoke(1, 2L)); + assertFalse((boolean) tsClass.invoke(2, 1L)); + assertTrue((boolean) tsClass.invoke(1, 1L)); } @Test public void testLogicalGE_BB_Z() throws Exception { - Method method = clazz.getMethod("logicalGE_BB_Z", byte.class, byte.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(byte.class, method.getParameters()[0].getType()); - assertEquals(byte.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertFalse((boolean) method.invoke(object, (byte) 1, (byte) 2)); - assertTrue((boolean) method.invoke(object, (byte) 2, (byte) 1)); - assertTrue((boolean) method.invoke(object, (byte) 1, (byte) 1)); + TsClass tsClass = new TsClass( + "return a >= b;", + boolean.class, + TsMethodArgument.of("a", byte.class), + TsMethodArgument.of("b", byte.class)); + assertFalse((boolean) tsClass.invoke((byte) 1, (byte) 2)); + assertTrue((boolean) tsClass.invoke((byte) 2, (byte) 1)); + assertTrue((boolean) tsClass.invoke((byte) 1, (byte) 1)); } @Test public void testLogicalGE_CC_Z() throws Exception { - Method method = clazz.getMethod("logicalGE_CC_Z", char.class, char.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(char.class, method.getParameters()[0].getType()); - assertEquals(char.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertFalse((boolean) method.invoke(object, (char) 1, (char) 2)); - assertTrue((boolean) method.invoke(object, (char) 2, (char) 1)); - assertTrue((boolean) method.invoke(object, (char) 1, (char) 1)); + TsClass tsClass = new TsClass( + "return a >= b;", + boolean.class, + TsMethodArgument.of("a", char.class), + TsMethodArgument.of("b", char.class)); + assertFalse((boolean) tsClass.invoke((char) 1, (char) 2)); + assertTrue((boolean) tsClass.invoke((char) 2, (char) 1)); + assertTrue((boolean) tsClass.invoke((char) 1, (char) 1)); } @Test public void testLogicalGE_DD_Z() throws Exception { - Method method = clazz.getMethod("logicalGE_DD_Z", double.class, double.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(double.class, method.getParameters()[0].getType()); - assertEquals(double.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertFalse((boolean) method.invoke(object, 1D, 2D)); - assertTrue((boolean) method.invoke(object, 2D, 1D)); - assertTrue((boolean) method.invoke(object, 1D, 1D)); - assertTrue((boolean) method.invoke(object, 1.23D, 1.23D)); + TsClass tsClass = new TsClass( + "return a >= b;", + boolean.class, + TsMethodArgument.of("a", double.class), + TsMethodArgument.of("b", double.class)); + assertFalse((boolean) tsClass.invoke(1D, 2D)); + assertTrue((boolean) tsClass.invoke(2D, 1D)); + assertTrue((boolean) tsClass.invoke(1D, 1D)); + assertTrue((boolean) tsClass.invoke(1.23D, 1.23D)); } @Test public void testLogicalGE_FF_Z() throws Exception { - Method method = clazz.getMethod("logicalGE_FF_Z", float.class, float.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(float.class, method.getParameters()[0].getType()); - assertEquals(float.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertFalse((boolean) method.invoke(object, 1F, 2F)); - assertTrue((boolean) method.invoke(object, 2F, 1F)); - assertTrue((boolean) method.invoke(object, 1F, 1F)); - assertTrue((boolean) method.invoke(object, 1.23F, 1.23F)); + TsClass tsClass = new TsClass( + "return a >= b;", + boolean.class, + TsMethodArgument.of("a", float.class), + TsMethodArgument.of("b", float.class)); + assertFalse((boolean) tsClass.invoke(1F, 2F)); + assertTrue((boolean) tsClass.invoke(2F, 1F)); + assertTrue((boolean) tsClass.invoke(1F, 1F)); + assertTrue((boolean) tsClass.invoke(1.23F, 1.23F)); } @Test public void testLogicalGE_II_Z() throws Exception { - Method method = clazz.getMethod("logicalGE_II_Z", int.class, int.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(int.class, method.getParameters()[0].getType()); - assertEquals(int.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertFalse((boolean) method.invoke(object, 1, 2)); - assertTrue((boolean) method.invoke(object, 2, 1)); - assertTrue((boolean) method.invoke(object, 1, 1)); + TsClass tsClass = new TsClass( + "return a >= b;", + boolean.class, + TsMethodArgument.of("a", int.class), + TsMethodArgument.of("b", int.class)); + assertFalse((boolean) tsClass.invoke(1, 2)); + assertTrue((boolean) tsClass.invoke(2, 1)); + assertTrue((boolean) tsClass.invoke(1, 1)); } @Test public void testLogicalGE_IJ_Z() throws Exception { assertFalse(logicalGE_IJ_Z(1, 2L)); - Method method = clazz.getMethod("logicalGE_IJ_Z", int.class, long.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(int.class, method.getParameters()[0].getType()); - assertEquals(long.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertFalse((boolean) method.invoke(object, 1, 2L)); - assertTrue((boolean) method.invoke(object, 2, 2L)); - assertTrue((boolean) method.invoke(object, 2, 1L)); + TsClass tsClass = new TsClass( + "return a >= b;", + boolean.class, + TsMethodArgument.of("a", int.class), + TsMethodArgument.of("b", long.class)); + assertFalse((boolean) tsClass.invoke(1, 2L)); + assertTrue((boolean) tsClass.invoke(2, 2L)); + assertTrue((boolean) tsClass.invoke(2, 1L)); } @Test public void testLogicalGE_SS_Z() throws Exception { - Method method = clazz.getMethod("logicalGE_SS_Z", short.class, short.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(short.class, method.getParameters()[0].getType()); - assertEquals(short.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertFalse((boolean) method.invoke(object, (short) 1, (short) 2)); - assertTrue((boolean) method.invoke(object, (short) 2, (short) 1)); - assertTrue((boolean) method.invoke(object, (short) 1, (short) 1)); + TsClass tsClass = new TsClass( + "return a >= b;", + boolean.class, + TsMethodArgument.of("a", short.class), + TsMethodArgument.of("b", short.class)); + assertFalse((boolean) tsClass.invoke((short) 1, (short) 2)); + assertTrue((boolean) tsClass.invoke((short) 2, (short) 1)); + assertTrue((boolean) tsClass.invoke((short) 1, (short) 1)); } @Test public void testLogicalGT_DD_Z() throws Exception { - Method method = clazz.getMethod("logicalGT_DD_Z", double.class, double.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(double.class, method.getParameters()[0].getType()); - assertEquals(double.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertFalse((boolean) method.invoke(object, 1D, 2D)); - assertFalse((boolean) method.invoke(object, 1.23D, 1.23D)); - assertTrue((boolean) method.invoke(object, 2D, 1D)); + TsClass tsClass = new TsClass( + "return a > b;", + boolean.class, + TsMethodArgument.of("a", double.class), + TsMethodArgument.of("b", double.class)); + assertFalse((boolean) tsClass.invoke(1D, 2D)); + assertFalse((boolean) tsClass.invoke(1.23D, 1.23D)); + assertTrue((boolean) tsClass.invoke(2D, 1D)); } @Test public void testLogicalGT_FF_Z() throws Exception { assertFalse(logicalGT_FF_Z(1F, 2F)); assertFalse(logicalGT_FF_Z(1.23F, 1.23F)); - Method method = clazz.getMethod("logicalGT_FF_Z", float.class, float.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(float.class, method.getParameters()[0].getType()); - assertEquals(float.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertFalse((boolean) method.invoke(object, 1F, 2F)); - assertFalse((boolean) method.invoke(object, 1.23F, 1.23F)); - assertTrue((boolean) method.invoke(object, 2F, 1F)); + TsClass tsClass = new TsClass( + "return a > b;", + boolean.class, + TsMethodArgument.of("a", float.class), + TsMethodArgument.of("b", float.class)); + assertFalse((boolean) tsClass.invoke(1F, 2F)); + assertFalse((boolean) tsClass.invoke(1.23F, 1.23F)); + assertTrue((boolean) tsClass.invoke(2F, 1F)); } @Test public void testLogicalGT_II_Z() throws Exception { assertFalse(logicalGT_II_Z(1, 2)); - Method method = clazz.getMethod("logicalGT_II_Z", int.class, int.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(int.class, method.getParameters()[0].getType()); - assertEquals(int.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertFalse((boolean) method.invoke(object, 1, 2)); - assertTrue((boolean) method.invoke(object, 2, 1)); + TsClass tsClass = new TsClass( + "return a > b;", + boolean.class, + TsMethodArgument.of("a", int.class), + TsMethodArgument.of("b", int.class)); + assertFalse((boolean) tsClass.invoke(1, 2)); + assertTrue((boolean) tsClass.invoke(2, 1)); } @Test public void testLogicalGT_IJ_Z() throws Exception { - Method method = clazz.getMethod("logicalGT_IJ_Z", int.class, long.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(int.class, method.getParameters()[0].getType()); - assertEquals(long.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertFalse((boolean) method.invoke(object, 1, 2L)); - assertFalse((boolean) method.invoke(object, 2, 2L)); - assertTrue((boolean) method.invoke(object, 2, 1L)); + TsClass tsClass = new TsClass( + "return a > b;", + boolean.class, + TsMethodArgument.of("a", int.class), + TsMethodArgument.of("b", long.class)); + assertFalse((boolean) tsClass.invoke(1, 2L)); + assertFalse((boolean) tsClass.invoke(2, 2L)); + assertTrue((boolean) tsClass.invoke(2, 1L)); + } + + @Test + public void testLogicalGT_I_Z() throws Exception { + TsClass tsClass = new TsClass( + "return a > 0;", + boolean.class, + TsMethodArgument.of("a", int.class)); + assertTrue((boolean) tsClass.invoke(1)); + assertFalse((boolean) tsClass.invoke(0)); + assertFalse((boolean) tsClass.invoke(-1)); + tsClass = new TsClass( + "return 0 > a;", + boolean.class, + TsMethodArgument.of("a", int.class)); + assertFalse((boolean) tsClass.invoke(1)); + assertFalse((boolean) tsClass.invoke(0)); + assertTrue((boolean) tsClass.invoke(-1)); } @Test public void testLogicalLE_DD_Z() throws Exception { - Method method = clazz.getMethod("logicalLE_DD_Z", double.class, double.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(double.class, method.getParameters()[0].getType()); - assertEquals(double.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertTrue((boolean) method.invoke(object, 1D, 2D)); - assertFalse((boolean) method.invoke(object, 2D, 1D)); - assertTrue((boolean) method.invoke(object, 1D, 1D)); - assertTrue((boolean) method.invoke(object, 1.23D, 1.23D)); + TsClass tsClass = new TsClass( + "return a <= b;", + boolean.class, + TsMethodArgument.of("a", double.class), + TsMethodArgument.of("b", double.class)); + assertTrue((boolean) tsClass.invoke(1D, 2D)); + assertFalse((boolean) tsClass.invoke(2D, 1D)); + assertTrue((boolean) tsClass.invoke(1D, 1D)); + assertTrue((boolean) tsClass.invoke(1.23D, 1.23D)); } @Test public void testLogicalLE_FF_Z() throws Exception { - Method method = clazz.getMethod("logicalLE_FF_Z", float.class, float.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(float.class, method.getParameters()[0].getType()); - assertEquals(float.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertTrue((boolean) method.invoke(object, 1F, 2F)); - assertFalse((boolean) method.invoke(object, 2F, 1F)); - assertTrue((boolean) method.invoke(object, 1F, 1F)); - assertTrue((boolean) method.invoke(object, 1.23F, 1.23F)); + TsClass tsClass = new TsClass( + "return a <= b;", + boolean.class, + TsMethodArgument.of("a", float.class), + TsMethodArgument.of("b", float.class)); + assertTrue((boolean) tsClass.invoke(1F, 2F)); + assertFalse((boolean) tsClass.invoke(2F, 1F)); + assertTrue((boolean) tsClass.invoke(1F, 1F)); + assertTrue((boolean) tsClass.invoke(1.23F, 1.23F)); } @Test public void testLogicalLE_II_Z() throws Exception { - Method method = clazz.getMethod("logicalLE_II_Z", int.class, int.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(int.class, method.getParameters()[0].getType()); - assertEquals(int.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertTrue((boolean) method.invoke(object, 1, 2)); - assertFalse((boolean) method.invoke(object, 2, 1)); - assertTrue((boolean) method.invoke(object, 1, 1)); + TsClass tsClass = new TsClass( + "return a <= b;", + boolean.class, + TsMethodArgument.of("a", int.class), + TsMethodArgument.of("b", int.class)); + assertTrue((boolean) tsClass.invoke(1, 2)); + assertFalse((boolean) tsClass.invoke(2, 1)); + assertTrue((boolean) tsClass.invoke(1, 1)); } @Test public void testLogicalLE_IJ_Z() throws Exception { - Method method = clazz.getMethod("logicalLE_IJ_Z", int.class, long.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(int.class, method.getParameters()[0].getType()); - assertEquals(long.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertTrue((boolean) method.invoke(object, 1, 2L)); - assertTrue((boolean) method.invoke(object, 2, 2L)); - assertFalse((boolean) method.invoke(object, 2, 1L)); + TsClass tsClass = new TsClass( + "return a <= b;", + boolean.class, + TsMethodArgument.of("a", int.class), + TsMethodArgument.of("b", long.class)); + assertTrue((boolean) tsClass.invoke(1, 2L)); + assertTrue((boolean) tsClass.invoke(2, 2L)); + assertFalse((boolean) tsClass.invoke(2, 1L)); } @Test public void testLogicalLT_DD_Z() throws Exception { - Method method = clazz.getMethod("logicalLT_DD_Z", double.class, double.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(double.class, method.getParameters()[0].getType()); - assertEquals(double.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertTrue((boolean) method.invoke(object, 1D, 2D)); - assertFalse((boolean) method.invoke(object, 2D, 1D)); - assertFalse((boolean) method.invoke(object, 1D, 1D)); - assertFalse((boolean) method.invoke(object, 1.23D, 1.23D)); + TsClass tsClass = new TsClass( + "return a < b;", + boolean.class, + TsMethodArgument.of("a", double.class), + TsMethodArgument.of("b", double.class)); + assertTrue((boolean) tsClass.invoke(1D, 2D)); + assertFalse((boolean) tsClass.invoke(2D, 1D)); + assertFalse((boolean) tsClass.invoke(1D, 1D)); + assertFalse((boolean) tsClass.invoke(1.23D, 1.23D)); } @Test public void testLogicalLT_FF_Z() throws Exception { - Method method = clazz.getMethod("logicalLT_FF_Z", float.class, float.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(float.class, method.getParameters()[0].getType()); - assertEquals(float.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertTrue((boolean) method.invoke(object, 1F, 2F)); - assertFalse((boolean) method.invoke(object, 2F, 1F)); - assertFalse((boolean) method.invoke(object, 1F, 1F)); - assertFalse((boolean) method.invoke(object, 1.23F, 1.23F)); + TsClass tsClass = new TsClass( + "return a < b;", + boolean.class, + TsMethodArgument.of("a", float.class), + TsMethodArgument.of("b", float.class)); + assertTrue((boolean) tsClass.invoke(1F, 2F)); + assertFalse((boolean) tsClass.invoke(2F, 1F)); + assertFalse((boolean) tsClass.invoke(1F, 1F)); + assertFalse((boolean) tsClass.invoke(1.23F, 1.23F)); } @Test public void testLogicalLT_II_Z() throws Exception { - Method method = clazz.getMethod("logicalLT_II_Z", int.class, int.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(int.class, method.getParameters()[0].getType()); - assertEquals(int.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertTrue((boolean) method.invoke(object, 1, 2)); - assertFalse((boolean) method.invoke(object, 2, 1)); - assertFalse((boolean) method.invoke(object, 1, 1)); + TsClass tsClass = new TsClass( + "return a < b;", + boolean.class, + TsMethodArgument.of("a", int.class), + TsMethodArgument.of("b", int.class)); + assertTrue((boolean) tsClass.invoke(1, 2)); + assertFalse((boolean) tsClass.invoke(2, 1)); + assertFalse((boolean) tsClass.invoke(1, 1)); } @Test public void testLogicalLT_IJ_Z() throws Exception { - Method method = clazz.getMethod("logicalLT_IJ_Z", int.class, long.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(int.class, method.getParameters()[0].getType()); - assertEquals(long.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertTrue((boolean) method.invoke(object, 1, 2L)); - assertFalse((boolean) method.invoke(object, 2, 2L)); - assertFalse((boolean) method.invoke(object, 2, 1L)); + TsClass tsClass = new TsClass( + "return a < b;", + boolean.class, + TsMethodArgument.of("a", int.class), + TsMethodArgument.of("b", long.class)); + assertTrue((boolean) tsClass.invoke(1, 2L)); + assertFalse((boolean) tsClass.invoke(2, 2L)); + assertFalse((boolean) tsClass.invoke(2, 1L)); } @Test public void testLogicalNotEQEQ_DD_Z() throws Exception { - Method method = clazz.getMethod("logicalNotEQEQ_DD_Z", double.class, double.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(double.class, method.getParameters()[0].getType()); - assertEquals(double.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertTrue((boolean) method.invoke(object, 1D, 2D)); - assertTrue((boolean) method.invoke(object, 2D, 1D)); - assertFalse((boolean) method.invoke(object, 1D, 1D)); - assertFalse((boolean) method.invoke(object, 1.23D, 1.23D)); + TsClass tsClass = new TsClass( + "return a !== b;", + boolean.class, + TsMethodArgument.of("a", double.class), + TsMethodArgument.of("b", double.class)); + assertTrue((boolean) tsClass.invoke(1D, 2D)); + assertTrue((boolean) tsClass.invoke(2D, 1D)); + assertFalse((boolean) tsClass.invoke(1D, 1D)); + assertFalse((boolean) tsClass.invoke(1.23D, 1.23D)); } @Test public void testLogicalNotEQEQ_FF_Z() throws Exception { - Method method = clazz.getMethod("logicalNotEQEQ_FF_Z", float.class, float.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(float.class, method.getParameters()[0].getType()); - assertEquals(float.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertTrue((boolean) method.invoke(object, 1F, 2F)); - assertTrue((boolean) method.invoke(object, 2F, 1F)); - assertFalse((boolean) method.invoke(object, 1F, 1F)); - assertFalse((boolean) method.invoke(object, 1.23F, 1.23F)); + TsClass tsClass = new TsClass( + "return a !== b;", + boolean.class, + TsMethodArgument.of("a", float.class), + TsMethodArgument.of("b", float.class)); + assertTrue((boolean) tsClass.invoke(1F, 2F)); + assertTrue((boolean) tsClass.invoke(2F, 1F)); + assertFalse((boolean) tsClass.invoke(1F, 1F)); + assertFalse((boolean) tsClass.invoke(1.23F, 1.23F)); } @Test public void testLogicalNotEQEQ_II_Z() throws Exception { - Method method = clazz.getMethod("logicalNotEQEQ_II_Z", int.class, int.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(int.class, method.getParameters()[0].getType()); - assertEquals(int.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertTrue((boolean) method.invoke(object, 1, 2)); - assertTrue((boolean) method.invoke(object, 2, 1)); - assertFalse((boolean) method.invoke(object, 1, 1)); + TsClass tsClass = new TsClass( + "return a !== b;", + boolean.class, + TsMethodArgument.of("a", int.class), + TsMethodArgument.of("b", int.class)); + assertTrue((boolean) tsClass.invoke(1, 2)); + assertTrue((boolean) tsClass.invoke(2, 1)); + assertFalse((boolean) tsClass.invoke(1, 1)); } @Test public void testLogicalNotEQEQ_IJ_Z() throws Exception { - Method method = clazz.getMethod("logicalNotEQEQ_IJ_Z", int.class, long.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(int.class, method.getParameters()[0].getType()); - assertEquals(long.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertTrue((boolean) method.invoke(object, 1, 2L)); - assertTrue((boolean) method.invoke(object, 2, 1L)); - assertFalse((boolean) method.invoke(object, 1, 1L)); + TsClass tsClass = new TsClass( + "return a !== b;", + boolean.class, + TsMethodArgument.of("a", int.class), + TsMethodArgument.of("b", long.class)); + assertTrue((boolean) tsClass.invoke(1, 2L)); + assertTrue((boolean) tsClass.invoke(2, 1L)); + assertFalse((boolean) tsClass.invoke(1, 1L)); } @Test public void testLogicalNotEQ_DD_Z() throws Exception { - Method method = clazz.getMethod("logicalNotEQ_DD_Z", double.class, double.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(double.class, method.getParameters()[0].getType()); - assertEquals(double.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertTrue((boolean) method.invoke(object, 1D, 2D)); - assertTrue((boolean) method.invoke(object, 2D, 1D)); - assertFalse((boolean) method.invoke(object, 1D, 1D)); - assertFalse((boolean) method.invoke(object, 1.23D, 1.23D)); + TsClass tsClass = new TsClass( + "return a != b;", + boolean.class, + TsMethodArgument.of("a", double.class), + TsMethodArgument.of("b", double.class)); + assertTrue((boolean) tsClass.invoke(1D, 2D)); + assertTrue((boolean) tsClass.invoke(2D, 1D)); + assertFalse((boolean) tsClass.invoke(1D, 1D)); + assertFalse((boolean) tsClass.invoke(1.23D, 1.23D)); } @Test public void testLogicalNotEQ_FF_Z() throws Exception { - Method method = clazz.getMethod("logicalNotEQ_FF_Z", float.class, float.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(float.class, method.getParameters()[0].getType()); - assertEquals(float.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertTrue((boolean) method.invoke(object, 1F, 2F)); - assertTrue((boolean) method.invoke(object, 2F, 1F)); - assertFalse((boolean) method.invoke(object, 1F, 1F)); - assertFalse((boolean) method.invoke(object, 1.23F, 1.23F)); + TsClass tsClass = new TsClass( + "return a != b;", + boolean.class, + TsMethodArgument.of("a", float.class), + TsMethodArgument.of("b", float.class)); + assertTrue((boolean) tsClass.invoke(1F, 2F)); + assertTrue((boolean) tsClass.invoke(2F, 1F)); + assertFalse((boolean) tsClass.invoke(1F, 1F)); + assertFalse((boolean) tsClass.invoke(1.23F, 1.23F)); } @Test public void testLogicalNotEQ_II_Z() throws Exception { - Method method = clazz.getMethod("logicalNotEQ_II_Z", int.class, int.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(int.class, method.getParameters()[0].getType()); - assertEquals(int.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertTrue((boolean) method.invoke(object, 1, 2)); - assertTrue((boolean) method.invoke(object, 2, 1)); - assertFalse((boolean) method.invoke(object, 1, 1)); + TsClass tsClass = new TsClass( + "return a != b;", + boolean.class, + TsMethodArgument.of("a", int.class), + TsMethodArgument.of("b", int.class)); + assertTrue((boolean) tsClass.invoke(1, 2)); + assertTrue((boolean) tsClass.invoke(2, 1)); + assertFalse((boolean) tsClass.invoke(1, 1)); } @Test public void testLogicalNotEQ_IJ_Z() throws Exception { - Method method = clazz.getMethod("logicalNotEQ_IJ_Z", int.class, long.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(int.class, method.getParameters()[0].getType()); - assertEquals(long.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertTrue((boolean) method.invoke(object, 1, 2L)); - assertTrue((boolean) method.invoke(object, 2, 1L)); - assertFalse((boolean) method.invoke(object, 1, 1L)); + TsClass tsClass = new TsClass( + "return a != b;", + boolean.class, + TsMethodArgument.of("a", int.class), + TsMethodArgument.of("b", long.class)); + assertTrue((boolean) tsClass.invoke(1, 2L)); + assertTrue((boolean) tsClass.invoke(2, 1L)); + assertFalse((boolean) tsClass.invoke(1, 1L)); } @Test public void testLogicalNot_EQEQ_DD_Z() throws Exception { - Method method = clazz.getMethod("logicalNot_EQEQ_DD_Z", double.class, double.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(double.class, method.getParameters()[0].getType()); - assertEquals(double.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertTrue((boolean) method.invoke(object, 1D, 2D)); - assertTrue((boolean) method.invoke(object, 2D, 1D)); - assertFalse((boolean) method.invoke(object, 1D, 1D)); - assertFalse((boolean) method.invoke(object, 1.23D, 1.23D)); + TsClass tsClass = new TsClass( + "return !(a === b);", + boolean.class, + TsMethodArgument.of("a", double.class), + TsMethodArgument.of("b", double.class)); + assertTrue((boolean) tsClass.invoke(1D, 2D)); + assertTrue((boolean) tsClass.invoke(2D, 1D)); + assertFalse((boolean) tsClass.invoke(1D, 1D)); + assertFalse((boolean) tsClass.invoke(1.23D, 1.23D)); } @Test public void testLogicalNot_EQEQ_FF_Z() throws Exception { - Method method = clazz.getMethod("logicalNot_EQEQ_FF_Z", float.class, float.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(float.class, method.getParameters()[0].getType()); - assertEquals(float.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertTrue((boolean) method.invoke(object, 1F, 2F)); - assertTrue((boolean) method.invoke(object, 2F, 1F)); - assertFalse((boolean) method.invoke(object, 1F, 1F)); - assertFalse((boolean) method.invoke(object, 1.23F, 1.23F)); + TsClass tsClass = new TsClass( + "return !(a === b);", + boolean.class, + TsMethodArgument.of("a", float.class), + TsMethodArgument.of("b", float.class)); + assertTrue((boolean) tsClass.invoke(1F, 2F)); + assertTrue((boolean) tsClass.invoke(2F, 1F)); + assertFalse((boolean) tsClass.invoke(1F, 1F)); + assertFalse((boolean) tsClass.invoke(1.23F, 1.23F)); } @Test public void testLogicalNot_EQEQ_II_Z() throws Exception { - Method method = clazz.getMethod("logicalNot_EQEQ_II_Z", int.class, int.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(int.class, method.getParameters()[0].getType()); - assertEquals(int.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertTrue((boolean) method.invoke(object, 1, 2)); - assertTrue((boolean) method.invoke(object, 2, 1)); - assertFalse((boolean) method.invoke(object, 1, 1)); + TsClass tsClass = new TsClass( + "return !(a === b);", + boolean.class, + TsMethodArgument.of("a", int.class), + TsMethodArgument.of("b", int.class)); + assertTrue((boolean) tsClass.invoke(1, 2)); + assertTrue((boolean) tsClass.invoke(2, 1)); + assertFalse((boolean) tsClass.invoke(1, 1)); } @Test public void testLogicalNot_EQEQ_IJ_Z() throws Exception { - Method method = clazz.getMethod("logicalNot_EQEQ_IJ_Z", int.class, long.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(int.class, method.getParameters()[0].getType()); - assertEquals(long.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertTrue((boolean) method.invoke(object, 1, 2L)); - assertTrue((boolean) method.invoke(object, 2, 1L)); - assertFalse((boolean) method.invoke(object, 1, 1L)); + TsClass tsClass = new TsClass( + "return !(a === b);", + boolean.class, + TsMethodArgument.of("a", int.class), + TsMethodArgument.of("b", long.class)); + assertTrue((boolean) tsClass.invoke(1, 2L)); + assertTrue((boolean) tsClass.invoke(2, 1L)); + assertFalse((boolean) tsClass.invoke(1, 1L)); } @Test public void testLogicalNot_EQ_DD_Z() throws Exception { - Method method = clazz.getMethod("logicalNot_EQ_DD_Z", double.class, double.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(double.class, method.getParameters()[0].getType()); - assertEquals(double.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertTrue((boolean) method.invoke(object, 1D, 2D)); - assertTrue((boolean) method.invoke(object, 2D, 1D)); - assertFalse((boolean) method.invoke(object, 1D, 1D)); - assertFalse((boolean) method.invoke(object, 1.23D, 1.23D)); + TsClass tsClass = new TsClass( + "return !(a == b);", + boolean.class, + TsMethodArgument.of("a", double.class), + TsMethodArgument.of("b", double.class)); + assertTrue((boolean) tsClass.invoke(1D, 2D)); + assertTrue((boolean) tsClass.invoke(2D, 1D)); + assertFalse((boolean) tsClass.invoke(1D, 1D)); + assertFalse((boolean) tsClass.invoke(1.23D, 1.23D)); } @Test public void testLogicalNot_EQ_FF_Z() throws Exception { - Method method = clazz.getMethod("logicalNot_EQ_FF_Z", float.class, float.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(float.class, method.getParameters()[0].getType()); - assertEquals(float.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertTrue((boolean) method.invoke(object, 1F, 2F)); - assertTrue((boolean) method.invoke(object, 2F, 1F)); - assertFalse((boolean) method.invoke(object, 1F, 1F)); - assertFalse((boolean) method.invoke(object, 1.23F, 1.23F)); + TsClass tsClass = new TsClass( + "return !(a == b);", + boolean.class, + TsMethodArgument.of("a", float.class), + TsMethodArgument.of("b", float.class)); + assertTrue((boolean) tsClass.invoke(1F, 2F)); + assertTrue((boolean) tsClass.invoke(2F, 1F)); + assertFalse((boolean) tsClass.invoke(1F, 1F)); + assertFalse((boolean) tsClass.invoke(1.23F, 1.23F)); } @Test public void testLogicalNot_EQ_II_Z() throws Exception { assertTrue(logicalNot_EQ_II_Z(1, 2)); - Method method = clazz.getMethod("logicalNot_EQ_II_Z", int.class, int.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(int.class, method.getParameters()[0].getType()); - assertEquals(int.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertTrue((boolean) method.invoke(object, 1, 2)); - assertTrue((boolean) method.invoke(object, 2, 1)); - assertFalse((boolean) method.invoke(object, 1, 1)); + TsClass tsClass = new TsClass( + "return !(a == b);", + boolean.class, + TsMethodArgument.of("a", int.class), + TsMethodArgument.of("b", int.class)); + assertTrue((boolean) tsClass.invoke(1, 2)); + assertTrue((boolean) tsClass.invoke(2, 1)); + assertFalse((boolean) tsClass.invoke(1, 1)); } @Test public void testLogicalNot_EQ_IJ_Z() throws Exception { - Method method = clazz.getMethod("logicalNot_EQ_IJ_Z", int.class, long.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(int.class, method.getParameters()[0].getType()); - assertEquals(long.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertTrue((boolean) method.invoke(object, 1, 2L)); - assertTrue((boolean) method.invoke(object, 2, 1L)); - assertFalse((boolean) method.invoke(object, 1, 1L)); + TsClass tsClass = new TsClass( + "return !(a == b);", + boolean.class, + TsMethodArgument.of("a", int.class), + TsMethodArgument.of("b", long.class)); + assertTrue((boolean) tsClass.invoke(1, 2L)); + assertTrue((boolean) tsClass.invoke(2, 1L)); + assertFalse((boolean) tsClass.invoke(1, 1L)); } @Test public void testLogicalNot_GE_DD_Z() throws Exception { - Method method = clazz.getMethod("logicalNot_GE_DD_Z", double.class, double.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(double.class, method.getParameters()[0].getType()); - assertEquals(double.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertTrue((boolean) method.invoke(object, 1D, 2D)); - assertFalse((boolean) method.invoke(object, 2D, 1D)); - assertFalse((boolean) method.invoke(object, 1D, 1D)); - assertFalse((boolean) method.invoke(object, 1.23D, 1.23D)); + TsClass tsClass = new TsClass( + "return !(a >= b);", + boolean.class, + TsMethodArgument.of("a", double.class), + TsMethodArgument.of("b", double.class)); + assertTrue((boolean) tsClass.invoke(1D, 2D)); + assertFalse((boolean) tsClass.invoke(2D, 1D)); + assertFalse((boolean) tsClass.invoke(1D, 1D)); + assertFalse((boolean) tsClass.invoke(1.23D, 1.23D)); } @Test public void testLogicalNot_GE_FF_Z() throws Exception { - Method method = clazz.getMethod("logicalNot_GE_FF_Z", float.class, float.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(float.class, method.getParameters()[0].getType()); - assertEquals(float.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertTrue((boolean) method.invoke(object, 1F, 2F)); - assertFalse((boolean) method.invoke(object, 2F, 1F)); - assertFalse((boolean) method.invoke(object, 1F, 1F)); - assertFalse((boolean) method.invoke(object, 1.23F, 1.23F)); + TsClass tsClass = new TsClass( + "return !(a >= b);", + boolean.class, + TsMethodArgument.of("a", float.class), + TsMethodArgument.of("b", float.class)); + assertTrue((boolean) tsClass.invoke(1F, 2F)); + assertFalse((boolean) tsClass.invoke(2F, 1F)); + assertFalse((boolean) tsClass.invoke(1F, 1F)); + assertFalse((boolean) tsClass.invoke(1.23F, 1.23F)); } @Test public void testLogicalNot_GE_II_Z() throws Exception { - Method method = clazz.getMethod("logicalNot_GE_II_Z", int.class, int.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(int.class, method.getParameters()[0].getType()); - assertEquals(int.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertTrue((boolean) method.invoke(object, 1, 2)); - assertFalse((boolean) method.invoke(object, 2, 1)); - assertFalse((boolean) method.invoke(object, 1, 1)); + TsClass tsClass = new TsClass( + "return !(a >= b);", + boolean.class, + TsMethodArgument.of("a", int.class), + TsMethodArgument.of("b", int.class)); + assertTrue((boolean) tsClass.invoke(1, 2)); + assertFalse((boolean) tsClass.invoke(2, 1)); + assertFalse((boolean) tsClass.invoke(1, 1)); } @Test public void testLogicalNot_GE_IJ_Z() throws Exception { - Method method = clazz.getMethod("logicalNot_GE_IJ_Z", int.class, long.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(int.class, method.getParameters()[0].getType()); - assertEquals(long.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertTrue((boolean) method.invoke(object, 1, 2L)); - assertFalse((boolean) method.invoke(object, 2, 1L)); - assertFalse((boolean) method.invoke(object, 1, 1L)); + TsClass tsClass = new TsClass( + "return !(a >= b);", + boolean.class, + TsMethodArgument.of("a", int.class), + TsMethodArgument.of("b", long.class)); + assertTrue((boolean) tsClass.invoke(1, 2L)); + assertFalse((boolean) tsClass.invoke(2, 1L)); + assertFalse((boolean) tsClass.invoke(1, 1L)); } @Test public void testLogicalNot_GT_DD_Z() throws Exception { - Method method = clazz.getMethod("logicalNot_GT_DD_Z", double.class, double.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(double.class, method.getParameters()[0].getType()); - assertEquals(double.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertTrue((boolean) method.invoke(object, 1D, 2D)); - assertFalse((boolean) method.invoke(object, 2D, 1D)); - assertTrue((boolean) method.invoke(object, 1D, 1D)); - assertTrue((boolean) method.invoke(object, 1.23D, 1.23D)); + TsClass tsClass = new TsClass( + "return !(a > b);", + boolean.class, + TsMethodArgument.of("a", double.class), + TsMethodArgument.of("b", double.class)); + assertTrue((boolean) tsClass.invoke(1D, 2D)); + assertFalse((boolean) tsClass.invoke(2D, 1D)); + assertTrue((boolean) tsClass.invoke(1D, 1D)); + assertTrue((boolean) tsClass.invoke(1.23D, 1.23D)); } @Test public void testLogicalNot_GT_II_Z() throws Exception { - Method method = clazz.getMethod("logicalNot_GT_II_Z", int.class, int.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(int.class, method.getParameters()[0].getType()); - assertEquals(int.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertTrue((boolean) method.invoke(object, 1, 2)); - assertFalse((boolean) method.invoke(object, 2, 1)); - assertTrue((boolean) method.invoke(object, 1, 1)); + TsClass tsClass = new TsClass( + "return !(a > b);", + boolean.class, + TsMethodArgument.of("a", int.class), + TsMethodArgument.of("b", int.class)); + assertTrue((boolean) tsClass.invoke(1, 2)); + assertFalse((boolean) tsClass.invoke(2, 1)); + assertTrue((boolean) tsClass.invoke(1, 1)); } @Test public void testLogicalNot_GT_IJ_Z() throws Exception { - Method method = clazz.getMethod("logicalNot_GT_IJ_Z", int.class, long.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(int.class, method.getParameters()[0].getType()); - assertEquals(long.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertTrue((boolean) method.invoke(object, 1, 2L)); - assertFalse((boolean) method.invoke(object, 2, 1L)); - assertTrue((boolean) method.invoke(object, 1, 1L)); - } - - @Test - public void testLogicalNot_JE_DD_Z() throws Exception { - Method method = clazz.getMethod("logicalNot_JE_DD_Z", double.class, double.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(double.class, method.getParameters()[0].getType()); - assertEquals(double.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertFalse((boolean) method.invoke(object, 1D, 2D)); - assertTrue((boolean) method.invoke(object, 2D, 1D)); - assertFalse((boolean) method.invoke(object, 1D, 1D)); - assertFalse((boolean) method.invoke(object, 1.23D, 1.23D)); - } - - @Test - public void testLogicalNot_JE_FF_Z() throws Exception { - Method method = clazz.getMethod("logicalNot_JE_FF_Z", float.class, float.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(float.class, method.getParameters()[0].getType()); - assertEquals(float.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertFalse((boolean) method.invoke(object, 1F, 2F)); - assertTrue((boolean) method.invoke(object, 2F, 1F)); - assertFalse((boolean) method.invoke(object, 1F, 1F)); - assertFalse((boolean) method.invoke(object, 1.23F, 1.23F)); - } - - @Test - public void testLogicalNot_JE_II_Z() throws Exception { - Method method = clazz.getMethod("logicalNot_JE_II_Z", int.class, int.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(int.class, method.getParameters()[0].getType()); - assertEquals(int.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertFalse((boolean) method.invoke(object, 1, 2)); - assertTrue((boolean) method.invoke(object, 2, 1)); - assertFalse((boolean) method.invoke(object, 1, 1)); - } - - @Test - public void testLogicalNot_JE_IJ_Z() throws Exception { - Method method = clazz.getMethod("logicalNot_JE_IJ_Z", int.class, long.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(int.class, method.getParameters()[0].getType()); - assertEquals(long.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertFalse((boolean) method.invoke(object, 1, 2L)); - assertTrue((boolean) method.invoke(object, 2, 1L)); - assertFalse((boolean) method.invoke(object, 1, 1L)); - } - - @Test - public void testLogicalNot_JT_DD_Z() throws Exception { - Method method = clazz.getMethod("logicalNot_JT_DD_Z", double.class, double.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(double.class, method.getParameters()[0].getType()); - assertEquals(double.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertFalse((boolean) method.invoke(object, 1D, 2D)); - assertTrue((boolean) method.invoke(object, 2D, 1D)); - assertTrue((boolean) method.invoke(object, 1D, 1D)); - assertTrue((boolean) method.invoke(object, 1.23D, 1.23D)); - } - - @Test - public void testLogicalNot_JT_FF_Z() throws Exception { - Method method = clazz.getMethod("logicalNot_JT_FF_Z", float.class, float.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(float.class, method.getParameters()[0].getType()); - assertEquals(float.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertFalse((boolean) method.invoke(object, 1F, 2F)); - assertTrue((boolean) method.invoke(object, 2F, 1F)); - assertTrue((boolean) method.invoke(object, 1F, 1F)); - assertTrue((boolean) method.invoke(object, 1.23F, 1.23F)); - } - - @Test - public void testLogicalNot_JT_II_Z() throws Exception { - Method method = clazz.getMethod("logicalNot_JT_II_Z", int.class, int.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(int.class, method.getParameters()[0].getType()); - assertEquals(int.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertFalse((boolean) method.invoke(object, 1, 2)); - assertTrue((boolean) method.invoke(object, 2, 1)); - assertTrue((boolean) method.invoke(object, 1, 1)); - } - - @Test - public void testLogicalNot_JT_IJ_Z() throws Exception { - Method method = clazz.getMethod("logicalNot_JT_IJ_Z", int.class, long.class); - assertNotNull(method); - assertEquals(boolean.class, method.getReturnType()); - assertEquals(2, method.getParameterCount()); - assertEquals(int.class, method.getParameters()[0].getType()); - assertEquals(long.class, method.getParameters()[1].getType()); - Object object = clazz.getConstructor().newInstance(); - assertFalse((boolean) method.invoke(object, 1, 2L)); - assertTrue((boolean) method.invoke(object, 2, 1L)); - assertTrue((boolean) method.invoke(object, 1, 1L)); + TsClass tsClass = new TsClass( + "return !(a > b);", + boolean.class, + TsMethodArgument.of("a", int.class), + TsMethodArgument.of("b", long.class)); + assertTrue((boolean) tsClass.invoke(1, 2L)); + assertFalse((boolean) tsClass.invoke(2, 1L)); + assertTrue((boolean) tsClass.invoke(1, 1L)); + } + + @Test + public void testLogicalNot_LE_DD_Z() throws Exception { + TsClass tsClass = new TsClass( + "return !(a <= b);", + boolean.class, + TsMethodArgument.of("a", double.class), + TsMethodArgument.of("b", double.class)); + assertFalse((boolean) tsClass.invoke(1D, 2D)); + assertTrue((boolean) tsClass.invoke(2D, 1D)); + assertFalse((boolean) tsClass.invoke(1D, 1D)); + assertFalse((boolean) tsClass.invoke(1.23D, 1.23D)); + } + + @Test + public void testLogicalNot_LE_FF_Z() throws Exception { + TsClass tsClass = new TsClass( + "return !(a <= b);", + boolean.class, + TsMethodArgument.of("a", float.class), + TsMethodArgument.of("b", float.class)); + assertFalse((boolean) tsClass.invoke(1F, 2F)); + assertTrue((boolean) tsClass.invoke(2F, 1F)); + assertFalse((boolean) tsClass.invoke(1F, 1F)); + assertFalse((boolean) tsClass.invoke(1.23F, 1.23F)); + } + + @Test + public void testLogicalNot_LE_II_Z() throws Exception { + TsClass tsClass = new TsClass( + "return !(a <= b);", + boolean.class, + TsMethodArgument.of("a", int.class), + TsMethodArgument.of("b", int.class)); + assertFalse((boolean) tsClass.invoke(1, 2)); + assertTrue((boolean) tsClass.invoke(2, 1)); + assertFalse((boolean) tsClass.invoke(1, 1)); + } + + @Test + public void testLogicalNot_LE_IJ_Z() throws Exception { + TsClass tsClass = new TsClass( + "return !(a <= b);", + boolean.class, + TsMethodArgument.of("a", int.class), + TsMethodArgument.of("b", long.class)); + assertFalse((boolean) tsClass.invoke(1, 2L)); + assertTrue((boolean) tsClass.invoke(2, 1L)); + assertFalse((boolean) tsClass.invoke(1, 1L)); + } + + @Test + public void testLogicalNot_LT_DD_Z() throws Exception { + TsClass tsClass = new TsClass( + "return !(a < b);", + boolean.class, + TsMethodArgument.of("a", double.class), + TsMethodArgument.of("b", double.class)); + assertFalse((boolean) tsClass.invoke(1D, 2D)); + assertTrue((boolean) tsClass.invoke(2D, 1D)); + assertTrue((boolean) tsClass.invoke(1D, 1D)); + assertTrue((boolean) tsClass.invoke(1.23D, 1.23D)); + } + + @Test + public void testLogicalNot_LT_FF_Z() throws Exception { + TsClass tsClass = new TsClass( + "return !(a < b);", + boolean.class, + TsMethodArgument.of("a", float.class), + TsMethodArgument.of("b", float.class)); + assertFalse((boolean) tsClass.invoke(1F, 2F)); + assertTrue((boolean) tsClass.invoke(2F, 1F)); + assertTrue((boolean) tsClass.invoke(1F, 1F)); + assertTrue((boolean) tsClass.invoke(1.23F, 1.23F)); + } + + @Test + public void testLogicalNot_LT_II_Z() throws Exception { + TsClass tsClass = new TsClass( + "return !(a < b);", + boolean.class, + TsMethodArgument.of("a", int.class), + TsMethodArgument.of("b", int.class)); + assertFalse((boolean) tsClass.invoke(1, 2)); + assertTrue((boolean) tsClass.invoke(2, 1)); + assertTrue((boolean) tsClass.invoke(1, 1)); + } + + @Test + public void testLogicalNot_LT_IJ_Z() throws Exception { + TsClass tsClass = new TsClass( + "return !(a < b);", + boolean.class, + TsMethodArgument.of("a", int.class), + TsMethodArgument.of("b", long.class)); + assertFalse((boolean) tsClass.invoke(1, 2L)); + assertTrue((boolean) tsClass.invoke(2, 1L)); + assertTrue((boolean) tsClass.invoke(1, 1L)); } }