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 void reset() {
   // Remove the transport added for this test
   DatabaseSession session = (DatabaseSession) getSession();
   UnitOfWork uow = session.acquireUnitOfWork();
   ExpressionBuilder transport = new ExpressionBuilder();
   Expression expression = transport.get("id").equal(transportId);
   uow.deleteAllObjects(uow.readAllObjects(Transport.class, expression));
   uow.commit();
 }
 public ReadQuery getQueryForTest() {
   ReportQuery testQuery = new ReportQuery();
   testQuery.setReferenceClass(Employee.class);
   ExpressionBuilder employees = new ExpressionBuilder();
   Expression exp = employees.get("firstName").like("B%");
   testQuery.setSelectionCriteria(exp);
   testQuery.cacheQueryResults();
   testQuery.addAttribute("firstName");
   return testQuery;
 }
 public void test() {
   ExpressionBuilder eb = new ExpressionBuilder();
   ReportQuery rq = new ReportQuery(Employee.class, eb);
   rq.addAttribute("firstName");
   rq.addAttribute("lastName");
   Expression exp = eb.getFunction("dbms_random.value");
   exp.setSelectIfOrderedBy(false);
   rq.addOrdering(exp.ascending());
   rq.setSelectionCriteria(eb.anyOf("projects").get("teamLeader").isNull());
   results = (Vector) getSession().executeQuery(rq);
 }
  private void addOuterJoinJoiningTest() {
    ExpressionBuilder emp = new ExpressionBuilder();

    ReadAllExpressionTest test = new ReadAllOuterJoinExpressionTest(Employee.class, 12);
    test.setName("OuterJoinJoiningTest");
    test.setDescription("Test joining with outer joins");
    ReadAllQuery query = new ReadAllQuery(Employee.class);
    query.addJoinedAttribute(emp.getAllowingNull("address"));
    test.setQuery(query);

    addTest(test);
  }
  private void addOuterJoinOrderByTest() {
    ExpressionBuilder emp = new ExpressionBuilder();

    ReadAllExpressionTest test = new ReadAllOuterJoinExpressionTest(Employee.class, 12);
    test.setName("OuterJoinOrderByTest");
    test.setDescription("Test order by with outer joins");
    ReadAllQuery query = new ReadAllQuery(Employee.class);
    query.addOrdering(emp.getAllowingNull("address").get("city"));
    test.setQuery(query);

    addTest(test);
  }
  private void addOuterJoinSimpleTest() {
    // This one does not really make sense, however its simple and tests that the syntax works.
    ExpressionBuilder emp = new ExpressionBuilder();
    Expression expression = emp.getAllowingNull("address").get("city").equal("Ottawa");

    ReadAllExpressionTest test = new ReadAllOuterJoinExpressionTest(Employee.class, 1);
    test.setName("OuterJoinSimpleTest");
    test.setDescription("Test expression with outer joins");
    test.setExpression(expression);

    addTest(test);
  }
  private void addOuterJoinJoiningComplexTest() {
    ExpressionBuilder emp = new ExpressionBuilder();

    ReadAllExpressionTest test = new ReadAllOuterJoinExpressionTest(Project.class, 15);
    test.setName("OuterJoinJoiningComplexTest");
    test.setDescription("Test joining with outer joins");
    ReadAllQuery query = new ReadAllQuery(Project.class);
    query.addJoinedAttribute(emp.getAllowingNull("teamLeader"));
    test.setQuery(query);

    addTest(test);
  }
  public void test() {
    transport = Transport.example6();
    UnitOfWork uow = getSession().acquireUnitOfWork();
    uow.registerObject(transport);
    uow.commit();

    transportId = transport.getId();

    DatabaseSession session = (DatabaseSession) getSession();
    ExpressionBuilder exp = new ExpressionBuilder();
    Expression expression = exp.get("id").equal(transportId);
    transport = (Transport) session.readObject(Transport.class, expression);
  }
  private void addOuterJoinManyToManyTest() {
    ExpressionBuilder emp = new ExpressionBuilder();
    Expression expression =
        emp.get("firstName")
            .like("%")
            .or(emp.anyOfAllowingNone("projects").get("description").like("%"));

    ReadAllExpressionTest test = new ReadAllOuterJoinExpressionTest(Employee.class, 12);
    test.setName("OuterJoinManytoManyTest");
    test.setDescription("Tests manytomany relationships with outer joins");
    test.setExpression(expression);

    addTest(test);
  }
  private void addOuterJoinOrAnyWhereClauseTest() {
    ExpressionBuilder emp = new ExpressionBuilder();
    Expression expression =
        emp.get("firstName")
            .like("Sarah%")
            .or(emp.anyOfAllowingNone("phoneNumbers").get("areaCode").equal("613"));

    ReadAllExpressionTest test = new ReadAllOuterJoinExpressionTest(Employee.class, 10);
    test.setName("OuterJoinOrAnyWhereClauseTest");
    test.setDescription("Test expression anyof with outer joins");
    test.setExpression(expression);

    addTest(test);
  }
  private void addOuterJoinOrWhereClauseTest2() {
    ExpressionBuilder emp = new ExpressionBuilder();
    Expression expression =
        emp.get("firstName")
            .like("Sarah%")
            .or(emp.getAllowingNull("manager").get("firstName").like("Sarah%"));

    ReadAllExpressionTest test = new ReadAllOuterJoinExpressionTest(Employee.class, 3);
    test.setName("OuterJoinOrWhereClauseTest2");
    test.setDescription("Test expression with outer joins");
    test.setExpression(expression);

    addTest(test);
  }
  private void addOuterJoinDirectCollectionTest() {
    ExpressionBuilder emp = new ExpressionBuilder();
    Expression expression =
        emp.get("firstName")
            .equal("Nancy")
            .or(emp.anyOfAllowingNone("responsibilitiesList").equal("Write lots of Java code."));

    ReadAllExpressionTest test = new ReadAllOuterJoinExpressionTest(Employee.class, 2);
    test.setName("OuterJoinDirectCollectionTest");
    test.setDescription("Tests direct collection relationships with outer joins");
    test.setExpression(expression);

    addTest(test);
  }
  private void addOuterJoinIsNullTest() {
    ExpressionBuilder emp = new ExpressionBuilder();
    Expression expression =
        emp.get("firstName")
            .equal("Bob")
            .or(emp.getAllowingNull("address").isNull())
            .or(emp.getAllowingNull("address").get("city").equal("Ottawa"));

    ReadAllExpressionTest test = new ReadAllOuterJoinExpressionTest(Employee.class, 2);
    test.setName("OuterJoinIsNullTest");
    test.setDescription("Test using isNull with outer joins");
    test.setExpression(expression);

    addTest(test);
  }
  public void setup() {
    if (this.getSession().getLogin().getPlatform().isOracle()
        || getSession().getLogin().getPlatform().isMySQL()) {

      ExpressionBuilder emp = new ExpressionBuilder();

      expression =
          emp.get("firstName").getFunction("CONCAT", " is cool!").equal("Sarah" + " is cool!");
      getQuery(true).setSelectionCriteria(expression);

      super.setup();
    } else {
      throw new TestWarningException("This test can only be done on Oracle");
    }
  }
  private void addOuterJoinJoiningTest2() {
    ExpressionBuilder emp = new ExpressionBuilder();

    ReadAllExpressionTest test =
        new ReadAllOuterJoinExpressionTest2(
            org.eclipse.persistence.testing.models.insurance.PolicyHolder.class, 4);
    test.setName("OuterJoinJoiningTest2");
    test.setDescription("Test joining with outer joins");
    ReadAllQuery query =
        new ReadAllQuery(org.eclipse.persistence.testing.models.insurance.PolicyHolder.class);
    query.addJoinedAttribute(emp.getAllowingNull("address"));
    test.setQuery(query);

    addTest(test);
  }
  public static ReadObjectTest getReadInterfaceObjectTest() {
    TestSuite suite = new TestSuite();
    PopulationManager manager = PopulationManager.getDefaultManager();
    Contact contact = ((Employee) manager.getObject(Employee.class, "example1")).getContact();

    ExpressionBuilder builder = new ExpressionBuilder();
    Expression expression = builder.get("id").equal(contact.getEmp().getId());

    ReadObjectQuery query = new ReadObjectQuery();
    query.setReferenceClass(ContactHolder.class);
    query.setSelectionCriteria(expression);

    ReadObjectTest test = new ReadObjectTest(contact.getEmp());
    test.setQuery(query);

    return test;
  }
  private void addOuterJoinOrWhereClauseTest4() {
    ExpressionBuilder emp = new ExpressionBuilder();
    Expression expression =
        emp.get("firstName")
            .like("Bob%")
            .or(
                emp.getAllowingNull("address")
                    .get("city")
                    .like("Ot%")
                    .and(emp.getAllowingNull("address").get("city").like("%wa")));

    ReadAllExpressionTest test = new ReadAllOuterJoinExpressionTest(Employee.class, 2);
    test.setName("OuterJoinOrWhereClauseTest4");
    test.setDescription("Test expression with outer joins");
    test.setExpression(expression);

    addTest(test);
  }
  private void addOuterJoinAcrossInheritanceTest() {
    ExpressionBuilder emp = new ExpressionBuilder();

    ReadAllExpressionTest test =
        new ReadAllOuterJoinExpressionTest(
            org.eclipse.persistence.testing.models.inheritance.Person.class, 1);
    test.setName("OuterJoinAcrossInheritanceTest");
    test.setDescription("Test joining with outer joins across inheritance");
    ReadAllQuery query =
        new ReadAllQuery(org.eclipse.persistence.testing.models.inheritance.Person.class);

    // This test used to make no sense...
    // query.setSelectionCriteria(emp.getAllowingNull("representitive").get("name").equalOuterJoin("Richard"));
    query.addOrdering(emp.getAllowingNull("representitive").get("name"));
    test.setQuery(query);

    addTest(test);
  }
  protected void test() {
    for (int i = 0; i <= 1; i++) {
      getSession().getPlatform().setShouldBindAllParameters(i != 0);
      for (int j = 0; j <= 2; j++) {
        query = new ReadAllQuery(Employee.class);
        ExpressionBuilder builder = new ExpressionBuilder();
        Vector vExp = new Vector(2);
        vExp.add(builder.getParameter("p1"));
        query.addArgument("p1");
        vExp.add(builder.getParameter("p2"));
        query.addArgument("p2");
        Expression exp = builder.get("id").in(vExp);
        query.setSelectionCriteria(exp);

        switch (j) {
          case 0:
            // nothing to do - just test the default:
            // query.bindAllParameters == Undefined
            break;
          case 1:
            // query.bindAllParameters == False
            query.setShouldBindAllParameters(false);
            break;
          case 2:
            // query.bindAllParameters == True
            query.setShouldBindAllParameters(true);
            break;
        }

        // clear the writer's buffer
        ((StringWriter) getSession().getLog()).getBuffer().setLength(0);
        try {
          getSession().executeQuery(query, v);
        } catch (DatabaseException e) {
          throw new TestProblemException("executeQuery threw DatabaseException");
        }
        if (shouldBind() != wasBound()) {
          return;
        }
      }
    }
  }
  private void createEmployeeAndSearchExpression() {
    // Create the example employee
    employee =
        (org.eclipse.persistence.testing.models.employee.domain.Employee)
            new org.eclipse.persistence.testing.models.employee.domain.EmployeePopulator()
                .basicEmployeeExample1();
    employee.setFirstName("Timugen");
    employee.setLastName("Singaera");
    employee.addResponsibility("Answer the phones.");

    // Create an expression to retreive the employee from the database
    ExpressionBuilder expressionBuilder = new ExpressionBuilder();
    Expression exp1;
    Expression exp2;
    Expression expression;

    exp1 = expressionBuilder.get("firstName").equal(employee.getFirstName());
    exp2 = expressionBuilder.get("lastName").equal(employee.getLastName());

    searchExpression = exp1.or(exp2);
  }
 public void run() {
   try {
     ExpressionBuilder builder = new ExpressionBuilder();
     Expression exp = builder.anyOf("policies").get("policyNumber").equal(200);
     for (int i = 0; i < 1; i++) {
       PolicyHolder holder =
           (PolicyHolder)
               this.clientSession.readObject(
                   org.eclipse.persistence.testing.models.insurance.PolicyHolder.class, exp);
       if ((holder == null)
           || (holder.getFirstName() == "")
           || (holder.getPolicies() == null)
           || (holder.getAddress() == null)
           || (holder.getAddress().getCity() == null)) {
         throw new TestWarningException("Client/Server dead lock test fails as null is returned.");
       }
     }
   } catch (Exception exception) {
     this.server.errorOccured = true;
     exception.printStackTrace(System.out);
   }
 }
  public static BinaryOperatorWithParameterTest getNumericParameterLessThanEqualTest() {
    BinaryOperatorWithParameterTest theTest = new BinaryOperatorWithParameterTest();
    theTest.setName("Less than equal to with parameter test");

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

    ExpressionBuilder builder = new ExpressionBuilder();
    Expression whereClause = builder.get("id").lessThanEqual(builder.getParameter(parameterName));
    theTest.setOriginalObjectExpression(whereClause);

    String ejbqlString = "SELECT OBJECT(emp) FROM Employee emp WHERE ";
    ejbqlString = ejbqlString + "emp.id <= ?1 ";

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

    return theTest;
  }
  public static BinaryOperatorWithParameterTest getNumericTwoParameterMultipleOperators() {
    BinaryOperatorWithParameterTest theTest = new BinaryOperatorWithParameterTest();
    theTest.setName("Multiple operators with two parameters");

    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.subtract(
                ExpressionMath.add(builder.get("salary"), 10000),
                ExpressionMath.multiply(
                    ExpressionMath.divide(
                        ExpressionBuilder.fromConstant(new Integer(10000), builder),
                        builder.getParameter(parameterNameForDivide)),
                    builder.getParameter(parameterNameForMultiply)))
            .greaterThanEqual(50000);
    theTest.setOriginalObjectExpression(whereClause);

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

    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;
  }
 /** Read all employees with salary > 0. */
 public void test() throws Exception {
   ReadAllQuery query = new ReadAllQuery(Employee.class);
   ExpressionBuilder builder = new ExpressionBuilder();
   query.setSelectionCriteria(builder.get("salary").greaterThan(0));
   List results = (List) getSession().executeQuery(query);
 }
  public void test() {

    ReadAllQuery query = new ReadAllQuery();
    ScrollableCursor cursor = null;

    try {
      query.setReferenceClass(Employee.class);
      if (TYPE_SCROLL_INSENSITIVE_isSupported && CONCUR_UPDATABLE_isSupported) {
        query.useScrollableCursor(2);
      } else {
        ScrollableCursorPolicy policy = new ScrollableCursorPolicy();
        if (!TYPE_SCROLL_INSENSITIVE_isSupported) {
          policy.setResultSetType(ScrollableCursorPolicy.TYPE_SCROLL_SENSITIVE);
        }
        if (!CONCUR_UPDATABLE_isSupported) {
          policy.setResultSetConcurrency(ScrollableCursorPolicy.CONCUR_READ_ONLY);
        }
        policy.setPageSize(2);
        query.useScrollableCursor(policy);
      }
      //
      if (configuration != null) {
        ExpressionBuilder builder = new ExpressionBuilder();
        Expression exp = builder.get("salary").greaterThan(50000);
        query.setSelectionCriteria(exp);
        query.conformResultsInUnitOfWork();
      }
      cursor = (ScrollableCursor) getSession().executeQuery(query);

      try {
        // test to see if we can iterate through a list and then iterate
        // in reverse through the same list.
        int totalItems = 0;
        while (cursor.hasNext()) {
          readWithNext.addElement(cursor.next());
          totalItems++;
        }
        while (cursor.hasPrevious()) {
          readWithPrevious.addElement(cursor.previous());
          totalItems--;
        }

        cursorSuccess = (totalItems == 0);

        int size = readWithPrevious.size();
        for (int i = 0; i < readWithNext.size(); i++) {
          cursorSuccess =
              (cursorSuccess
                  && (readWithNext.elementAt(i) == readWithPrevious.elementAt((size - 1) - i)));
        }

      } catch (org.eclipse.persistence.exceptions.QueryException ex) {
        caughtException = ex;
      }

    } finally {
      if (cursor != null) {
        cursor.close();
      }
    }
  }
  public void test() {

    ReadAllQuery query = new ReadAllQuery();

    if (configuration != null) {
      ExpressionBuilder emp = new ExpressionBuilder();
      Expression exp = emp.get("salary").greaterThan(50000);
      query.setSelectionCriteria(exp);
      query.conformResultsInUnitOfWork();
    }
    ScrollableCursor cursor = null;

    try {
      query.setReferenceClass(Employee.class);
      if (TYPE_SCROLL_INSENSITIVE_isSupported && CONCUR_UPDATABLE_isSupported) {
        query.useScrollableCursor(2);
      } else {
        ScrollableCursorPolicy policy = new ScrollableCursorPolicy();
        if (!TYPE_SCROLL_INSENSITIVE_isSupported) {
          policy.setResultSetType(ScrollableCursorPolicy.TYPE_SCROLL_SENSITIVE);
        }
        if (!CONCUR_UPDATABLE_isSupported) {
          policy.setResultSetConcurrency(ScrollableCursorPolicy.CONCUR_READ_ONLY);
        }
        policy.setPageSize(2);
        query.useScrollableCursor(policy);
      }
      cursor = (ScrollableCursor) getSession().executeQuery(query);

      try {
        boolean isFirst = cursor.first();
        if (!cursor.isFirst() || !isFirst) {
          navigationError = "cursor.first() does not result in cursor.isFirst() returning true.";
        }
        Object second = cursor.next();
        Object first = cursor.previous();
        if (first.equals(second)) {
          navigationError = "cursor.next() and cursor.previous() are not complementary.";
        }
        if (!second.equals(cursor.next())) {
          navigationError = "cursor.next() does not move the cursor forward.";
        }
        boolean isRelative = cursor.relative(1);
        if (!isRelative || !second.equals(cursor.previous())) {
          navigationError =
              "cursor.relative() does not move the cursor the proper number of spaces.";
        }
        boolean isAbsolute = cursor.absolute(1);
        if (!second.equals(cursor.next())) {
          navigationError = "cursor.absolute(0) move a cursor to the beginning of the cursor.";
        }
        cursor.beforeFirst();
        if (!cursor.isBeforeFirst()) {
          navigationError =
              "cursor.beforeFirst() does not result in cursor.isBeforeFirst() returning true.";
        }
        if (!first.equals(cursor.next())) {
          navigationError = "cursor.beforeFirst() does not set the cursor position properly.";
        }

        boolean isLast = cursor.last();
        if (!isLast || !cursor.isLast()) {
          navigationError = "cursor.last() does not result in cursor.isLast() returning true.";
        }
        cursor.afterLast();

        if (!cursor.isAfterLast()) {
          navigationError =
              "cursor.afterLast() does not result in cursor.isAfterLast() returning true.";
        }
        Object last = cursor.previous();
        int size = cursor.size();
        cursor.relative(size);
        Object lastBySize = cursor.previous();
        if (!last.equals(lastBySize)) {
          navigationError = "The last item in the list is not correct.";
        }

      } catch (org.eclipse.persistence.exceptions.QueryException ex) {
        caughtException = ex;
      }

    } finally {
      if (cursor != null) {
        cursor.close();
      }
    }
  }