public static StatementBuilder declareVariable(final String name, final MetaClass type, final Object initialization) { return StatementBuilder.create().declareVariable(name, type, initialization); }
@Override public StatementBuilder declareFinalVariable(final String name, final Class<?> type) { return declareVariable(Variable.createFinal(name, type)); }
public static StatementBegin create() { return new StatementBuilder(null); }
@Override public VariableReferenceContextualStatementBuilder loadVariable(final String name, final Object... indexes) { final Matcher m = THIS_PATTERN.matcher(name); if (m.matches()) { return loadClassMember(name.replaceFirst("(this\\.)", ""), indexes); } appendCallElement(new LoadVariable(name, indexes)); return new ContextualStatementBuilderImpl(context, callElementBuilder); }
@Test public void testInvokeWithParameterizedListAndVariableReturnType() { String s = StatementBuilder.create(Context.create().autoImport()) .declareVariable("list", new TypeLiteral<List<String>>() { }) .declareVariable("str", String.class, StatementBuilder.create().invokeStatic(Foo.class, "bar", Variable.get("list"))) .toJavaString(); assertEquals("Failed to generate method invocation with variable return type inferred from List<T>", "String str = Foo.bar(list);", s); }
@Test public void testInvokeWithLiteralParameters() { String result = StatementBuilder.create().declareVariable("s", String.class) .loadVariable("s").invoke("replaceAll", "foo", "foo\t\n").toJavaString(); assertEquals("Failed to generate invocation using literal parameters", "s.replaceAll(\"foo\", \"foo\\t\\n\")", result); }
@Test public void testAssignArrayValueWithVariableIndexes() { final String s = StatementBuilder.create() .declareVariable("twoDimArray", String[][].class) .declareVariable("i", int.class) .declareVariable("j", int.class) .loadVariable("twoDimArray", Variable.get("i"), Variable.get("j")) .assignValue("test") .toJavaString(); assertEquals("Failed to generate array assignment", "twoDimArray[i][j] = \"test\";", s); }
@Test public void testDeclareVariableWithObjectInitializationWithExactTypeProvided() { final Context ctx = Context.create(); final String s = StatementBuilder.create().declareVariable("str", String.class, ObjectBuilder.newInstanceOf(String.class)).generate(ctx); assertEquals("failed to generate variable declaration with object initialization and type provided", "String str = new String();", s); final VariableReference str = ctx.getVariable("str"); assertEquals("Wrong variable name", "str", str.getName()); Assert.assertEquals("Wrong variable type", MetaClassFactory.get(String.class), str.getType()); }
@Test public void testDeclareVariableWithImplicitTypeConversion() { final Context ctx = Context.create(); final String s = StatementBuilder.create().declareVariable("n", Integer.class, "10").generate(ctx); assertEquals("failed to generate variable declaration with implicit type conversion", "Integer n = 10;", s); final VariableReference n = ctx.getVariable("n"); assertEquals("Wrong variable name", "n", n.getName()); Assert.assertEquals("Wrong variable type", MetaClassFactory.get(Integer.class), n.getType()); Assert.assertEquals("Wrong variable value", LiteralFactory.getLiteral(10), n.getValue()); try { StatementBuilder.create().declareVariable("n", Integer.class, "abc").toJavaString(); fail("Expected InvalidTypeException"); } catch (InvalidTypeException ive) { // expected assertTrue(ive.getCause() instanceof NumberFormatException); } }
@Test public void testForLoopUnchainedWithInitializerAndCountingExpression() { String s = StatementBuilder.create() .declareVariable("i", Integer.class) .for_(StatementBuilder.create().loadVariable("i").assignValue(0), Bool.expr(Variable.get("i"), BooleanOperator.LessThan, 100), StatementBuilder.create().loadVariable("i").assignValue(AssignmentOperator.PreIncrementAssign, 1)) .finish().toJavaString(); assertEquals("Failed to generate for loop with initializer and counting expression", FOR_INITIALIZER_COUNTING_EXP_EMPTY, s); }
@Test public void testDoWhileLoopUnchainedWithoutRhs() { String s = StatementBuilder.create() .declareVariable("b", Boolean.class) .do_() .append(StatementBuilder.create().loadVariable("b").assignValue(false)) .finish() .while_(Bool.expr(Variable.get("b"))) .toJavaString(); assertEquals("Failed to generate do while loop with simple expression (no operator and rhs)", DOWHILE_SIMPLE_EXPRESSION_NO_OP, s); }
@Override public StatementEnd throw_(final String exceptionVarName) { appendCallElement(new ThrowException(exceptionVarName)); return this; }
@Override public ContextualStatementBuilder invokeStatic(final Class<?> clazz, final String methodName, final Object... parameters) { return invokeStatic(MetaClassFactory.get(clazz), methodName, parameters); }
@Test public void testDeclareVariableWithStatementInitialization() { final Context ctx = Context.create(); final String s = Stmt.declareVariable("str", String.class, Stmt.nestedCall(Stmt.newObject(Integer.class).withParameters(2)).invoke("toString")) .generate(ctx); assertEquals("failed to generate variable declaration with statement initialization", "String str = new Integer(2).toString();", s); final VariableReference str = ctx.getVariable("str"); assertEquals("Wrong variable name", "str", str.getName()); Assert.assertEquals("Wrong variable type", MetaClassFactory.get(String.class), str.getType()); }
@Test public void testInvokeWithParameterizedMapAndVariableReturnType() { String s = StatementBuilder.create(Context.create().autoImport()) .declareVariable("map", new TypeLiteral<Map<String, Integer>>() { }) .declareVariable("val", Integer.class, StatementBuilder.create().invokeStatic(Foo.class, "bar", Variable.get("map"))) .toJavaString(); assertEquals("Failed to generate method invocation with variable return type inferred from Map<K, V>", "Integer val = Foo.bar(map);", s); }
@Test public void testInvokeBestMatchingMethod() { String s = StatementBuilder.create() .declareVariable("n", Integer.class) .loadVariable("n") // 1 will be inferred to LiteralValue<Integer>, equals(Integer.class) // should be matched equals(Object.class) .invoke("equals", 1) .toJavaString(); assertEquals("Failed to generate invocation on matched method", "n.equals(1)", s); }
@Test public void testChainedInvocations() { String s = StatementBuilder.create() .declareVariable("i", Integer.class) .declareVariable("regex", String.class) .declareVariable("replacement", String.class) .loadVariable("i") .invoke("toString") .invoke("replaceAll", Variable.get("regex"), Variable.get("replacement")) .toJavaString(); assertEquals("Failed to generate chained invocations on variable", "i.toString().replaceAll(regex, replacement)", s); }
@Test public void testDeclareVariableWithExactTypeProvided() { final Context ctx = Context.create(); final String s = StatementBuilder.create().declareVariable("n", Integer.class, 10).generate(ctx); assertEquals("failed to generate variable declaration with type provided", "Integer n = 10;", s); final VariableReference n = ctx.getVariable("n"); assertEquals("Wrong variable name", "n", n.getName()); Assert.assertEquals("Wrong variable type", MetaClassFactory.get(Integer.class), n.getType()); Assert.assertEquals("Wrong variable value", LiteralFactory.getLiteral(10), n.getValue()); }
@Test public void testForLoopUnchainedWithInitializer() { String s = StatementBuilder.create() .declareVariable("i", Integer.class) .for_(StatementBuilder.create().loadVariable("i").assignValue(0), Bool.expr(Variable.get("i"), BooleanOperator.LessThan, 100)) .finish().toJavaString(); assertEquals("Failed to generate for loop with initializer", FOR_INITIALIZER_NO_COUNTING_EXP_EMPTY, s); }
@Test public void testDoWhileLoopUnchainedWithNestedExpressions() { String s = StatementBuilder.create() .declareVariable("str", String.class) .do_() .append(StatementBuilder.create().loadStatic(System.class, "out").invoke("println", Variable.get("str"))) .finish() .while_(Bool.expr( Bool.expr(Variable.get("str"), BooleanOperator.NotEquals, null), BooleanOperator.And, Bool.expr(Stmt.loadVariable("str").invoke("length"), BooleanOperator.GreaterThan, 0))) .toJavaString(); assertEquals("Failed to generate do while loop with nested expression", DOWHILE_NESTED_EXPRESSION, s); }