public static BinaryOperatorWithParameterTest
      getNumericParameterDivideTestWithBracketsAfterComparison() {
    BinaryOperatorWithParameterTest theTest = new BinaryOperatorWithParameterTest();
    theTest.setName("Divide with parameter test with brackets after comparison");

    String parameterName = "amountToDivide";
    theTest.setExpressionParameters(new Vector());
    theTest.getExpressionParameters().add(parameterName);

    ExpressionBuilder builder = new ExpressionBuilder();
    Expression whereClause =
        ExpressionBuilder.fromConstant(new Integer(20000), builder)
            .greaterThan(
                ExpressionMath.divide(
                    builder.get("salary"), (builder.getParameter(parameterName))));
    theTest.setOriginalObjectExpression(whereClause);

    String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE 20000 > (emp.salary / ?1)";

    theTest.setEjbqlString(ejbqlString);
    Vector myArgumentNames = new Vector();
    myArgumentNames.add("1");
    theTest.setArgumentNames(myArgumentNames);

    theTest.setArguments(new Vector());
    theTest.getArguments().addElement(new Integer(2));

    return theTest;
  }
  public static BinaryOperatorWithParameterTest getNumericParameterDivideTest() {
    BinaryOperatorWithParameterTest theTest = new BinaryOperatorWithParameterTest();
    theTest.setName("Divide with parameter test");

    String parameterName = "amountToDivide";
    theTest.setExpressionParameters(new Vector());
    theTest.getExpressionParameters().add(parameterName);

    ExpressionBuilder builder = new ExpressionBuilder();
    Expression whereClause =
        ExpressionMath.divide(builder.get("salary"), (builder.getParameter(parameterName)))
            .lessThanEqual(20000);
    theTest.setOriginalObjectExpression(whereClause);

    String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE emp.salary / ?1 <= 20000";

    theTest.setEjbqlString(ejbqlString);
    Vector myArgumentNames = new Vector();
    myArgumentNames.add("1");
    theTest.setArgumentNames(myArgumentNames);

    theTest.setArguments(new Vector());
    theTest.getArguments().addElement(new Integer(2));

    return theTest;
  }
  public static BinaryOperatorWithParameterTest
      getNumericParameterMultiplyTestWithBracketsBeforeComparison() {
    BinaryOperatorWithParameterTest theTest = new BinaryOperatorWithParameterTest();
    theTest.setName("Multiply with parameter test with brackets before comparison");

    String parameterName = "amountToMultiply";
    theTest.setExpressionParameters(new Vector());
    theTest.getExpressionParameters().add(parameterName);

    ExpressionBuilder builder = new ExpressionBuilder();
    Expression whereClause =
        ExpressionMath.multiply(builder.get("salary"), (builder.getParameter(parameterName)))
            .lessThanEqual(100000);
    theTest.setOriginalObjectExpression(whereClause);

    String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE (emp.salary * ?1) <= 100000";

    theTest.setEjbqlString(ejbqlString);
    Vector myArgumentNames = new Vector();
    myArgumentNames.add("1");
    theTest.setArgumentNames(myArgumentNames);

    theTest.setArguments(new Vector());
    theTest.getArguments().addElement(new Integer(2));

    return theTest;
  }
  public static ModTest getSimpleModTest() {
    String ejbql = "SELECT OBJECT(emp) FROM Employee emp WHERE MOD(emp.salary, 2) > 0";
    ModTest test = getNewTestCaseNamed("Mod Test", ejbql, Employee.class);

    ExpressionBuilder employee = new ExpressionBuilder();
    Expression whereClause = ExpressionMath.mod(employee.get("salary"), 2).greaterThan(0);

    test.setOriginalObjectExpression(whereClause);

    return test;
  }
  public static BinaryOperatorWithParameterTest
      getNumericTwoParameterMultipleOperatorsWithBracketsAroundMultiply() {
    BinaryOperatorWithParameterTest theTest = new BinaryOperatorWithParameterTest();
    theTest.setName("Multiple operators with two parameters with brackets around multiply");

    String parameterNameForDivide = "amountToDivide";
    String parameterNameForMultiply = "amountToMultiply";
    theTest.setExpressionParameters(new Vector());
    theTest.getExpressionParameters().add(parameterNameForDivide);
    theTest.getExpressionParameters().add(parameterNameForMultiply);

    ExpressionBuilder builder = new ExpressionBuilder();
    Expression whereClause =
        builder
            .get("salary")
            .greaterThan(
                ExpressionMath.subtract(
                    ExpressionMath.add(
                        ExpressionBuilder.fromConstant(new Integer(50000), builder), 10000),
                    ExpressionMath.divide(
                        ExpressionBuilder.fromConstant(new Integer(10000), builder),
                        ExpressionMath.multiply(
                            builder.getParameter(parameterNameForMultiply),
                            builder.getParameter(parameterNameForDivide)))));
    theTest.setOriginalObjectExpression(whereClause);

    String ejbqlString =
        "SELECT OBJECT(emp) FROM Employee emp WHERE emp.salary > (50000 + 10000 - 10000 / (?1 * ?2))";

    theTest.setEjbqlString(ejbqlString);
    Vector myArgumentNames = new Vector();
    myArgumentNames.add("1");
    myArgumentNames.add("2");
    theTest.setArgumentNames(myArgumentNames);

    theTest.setArguments(new Vector());
    theTest.getArguments().addElement(new Integer(2));
    theTest.getArguments().addElement(new Integer(5));

    return theTest;
  }
  public static BinaryOperatorWithParameterTest
      getNumericTwoParameterMultipleOperatorsWithBracketsAroundPlusMinus() {
    BinaryOperatorWithParameterTest theTest = new BinaryOperatorWithParameterTest();
    theTest.setName("Multiple operators with two parameters with brackets around plus/minus");

    String parameterNameForDivide = "amountToDivide";
    String parameterNameForMultiply = "amountToMultiply";
    theTest.setExpressionParameters(new Vector());
    theTest.getExpressionParameters().add(parameterNameForDivide);
    theTest.getExpressionParameters().add(parameterNameForMultiply);

    ExpressionBuilder builder = new ExpressionBuilder();
    Expression whereClause =
        ExpressionMath.multiply(
                ExpressionMath.divide(
                    ExpressionMath.subtract(ExpressionMath.add(builder.get("salary"), 10), 20),
                    builder.getParameter(parameterNameForDivide)),
                builder.getParameter(parameterNameForMultiply))
            .greaterThanEqual(70000);
    theTest.setOriginalObjectExpression(whereClause);

    String ejbqlString =
        "SELECT OBJECT(emp) FROM Employee emp WHERE (emp.salary + 10 - 20) / ?1 * ?2 >= 70000";

    theTest.setEjbqlString(ejbqlString);
    Vector myArgumentNames = new Vector();
    myArgumentNames.add("1");
    myArgumentNames.add("2");
    theTest.setArgumentNames(myArgumentNames);

    theTest.setArguments(new Vector());
    theTest.getArguments().addElement(new Integer(2));
    theTest.getArguments().addElement(new Integer(3));

    return theTest;
  }