tck/src/main/java/org/apache/jdo/tck/query/jdoql/methods/SupportedOptionalMethods.java - db-jdo - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You 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
 <<<<<<< Updated upstream
  *
  *     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
 =======
  *
  *     https://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
 >>>>>>> Stashed changes
  * limitations under the License.
  */

 package org.apache.jdo.tck.query.jdoql.methods;

 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Optional;
 import javax.jdo.PersistenceManager;
 import javax.jdo.Query;
 import javax.jdo.Transaction;
 import org.apache.jdo.tck.pc.query.OptionalSample;
 import org.apache.jdo.tck.query.QueryElementHolder;
 import org.apache.jdo.tck.query.QueryTest;
 import org.apache.jdo.tck.util.BatchTestRunner;

 /**
  * <B>Title:</B> Optional Fields. <br>
  * <B>Keywords:</B> query <br>
  * <B>Assertion ID:</B> A14.6.2-9 <br>
  * <B>Assertion Description: </B> Queries on fields of type java.util.Optional .
  */
 public class SupportedOptionalMethods extends QueryTest {

   /** */
   private static final String ASSERTION_FAILED = "Assertion A14.6.2-9 (OptionalFields) failed: ";

   private static final int PC_ID = 1;
   private static final int PC_EMPTY_ID = 3;
   private static final int PC_NULL_ID = 4;
   private static final int REFERENCED_PC1_ID = 88;
   private static final int REFERENCED_PC2_ID = 99;
   private static final String STRING = "Hello JDO";
   private static final Integer INTEGER = 2016;
   private static final Date DATE = new Date(1000000000);
   private Object oidReferencedPC1;
   private Object oidReferencedPC2;
   private Object oidPC;
   private Object oidEmpty;
   private Object oidNull;

   /**
    * The <code>main</code> is called when the class is directly executed from the command line.
    *
    * @param args The arguments passed to the program.
    */
   public static void main(String[] args) {
     BatchTestRunner.run(SupportedOptionalMethods.class);
   }

   /** */
   public void testQueriesWithPresence() {
     // Matches 'optionalPC.isPresent() == true'
     checkQuery("optionalPC != null", oidPC, oidReferencedPC1);

     // matches !isPresent() but does NOT match Java 'optionalPC==null'
     checkQuery("optionalPC == null", oidEmpty, oidNull, oidReferencedPC2);

     // matches isPresent()
     checkQuery("!(optionalPC == null)", oidReferencedPC1, oidPC);

     // matches !isPresent()
     checkQuery("!(optionalPC != null)", oidReferencedPC2, oidEmpty, oidNull);

     checkQuery("optionalPC.get() != null", oidPC, oidReferencedPC1);
     checkQuery("optionalPC.get() == null", oidEmpty, oidNull, oidReferencedPC2);
     checkQuery("optionalPC.isPresent()", oidPC, oidReferencedPC1);
     checkQuery("!optionalPC.isPresent()", oidReferencedPC2, oidEmpty, oidNull);

     // querying non-PC 'Optional' fields
     checkOptionalForPresence("optionalString");
     checkOptionalForPresence("optionalDate");
     checkOptionalForPresence("optionalInteger");
   }

   private void checkOptionalForPresence(String fieldName) {
     checkQuery(fieldName + " != null", oidPC);
     checkQuery(fieldName + " == null", oidEmpty, oidNull, oidReferencedPC1, oidReferencedPC2);
     checkQuery("!(" + fieldName + " == null)", oidPC);
     checkQuery(
         "!(" + fieldName + " != null)", oidEmpty, oidNull, oidReferencedPC1, oidReferencedPC2);

     checkQuery(fieldName + ".get() != null", oidPC);
     checkQuery(fieldName + ".get() == null", oidEmpty, oidNull, oidReferencedPC1, oidReferencedPC2);
     checkQuery(fieldName + ".isPresent()", oidPC);
     checkQuery(
         "!" + fieldName + ".isPresent()", oidEmpty, oidNull, oidReferencedPC1, oidReferencedPC2);
   }

   public void testQueriesWithNavigation() {
     checkQuery("optionalPC.id == " + REFERENCED_PC1_ID, oidPC);
     checkQuery("optionalPC.id != " + REFERENCED_PC1_ID, oidReferencedPC1);
     checkQuery("!(optionalPC.id == " + REFERENCED_PC1_ID + ")", oidReferencedPC1);
     checkQuery("optionalPC.get().id == " + REFERENCED_PC1_ID, oidPC);
     checkQuery("optionalPC.get().id != " + REFERENCED_PC1_ID, oidReferencedPC1);
     checkQuery("!(optionalPC.get().id == " + REFERENCED_PC1_ID + ")", oidReferencedPC1);
     checkQuery("optionalPC.optionalPC.isPresent()", oidPC);

     // The following reflects the changed behavior in JDO 3.2 in  the sense that
     // all instances are returned where either 'optionalPC.optionalPC==null' (not present)
     // or 'optionalPC==null' (the 'null' evaluates to 'null', which is followed until it is
     // evaluated in the 'isPresent()'). In other words, the query also returns all
     // objects that match '!(optionalPC.isPresent())'.
     checkQuery(
         "!(optionalPC.optionalPC.isPresent())",
         oidReferencedPC1,
         oidReferencedPC2,
         oidEmpty,
         oidNull);

     // A query where 'optionalPC!=null' and 'optionalPC.optionalPC==null;
     // can be done as follows:
     checkQuery("optionalPC.isPresent() && !(optionalPC.optionalPC.isPresent())", oidReferencedPC1);

     checkQuery("optionalPC.optionalPC.id == " + REFERENCED_PC2_ID, oidPC);
     checkQuery("optionalPC.get().optionalPC.get().id == " + REFERENCED_PC2_ID, oidPC);

     // test with && operator
     checkQuery(
         "!(optionalPC.isPresent() && optionalPC.id == " + REFERENCED_PC1_ID + ")",
         oidReferencedPC1,
         oidReferencedPC2,
         oidEmpty,
         oidNull);
   }

   private void checkQuery(String filter, Object... resultOids) {
     QueryElementHolder<OptionalSample> qeh =
         new QueryElementHolder<>(
             /*UNIQUE*/ null,
             /*RESULT*/ null,
             /*INTO*/ null,
             /*FROM*/ OptionalSample.class,
             /*EXCLUDE*/ null,
             /*WHERE*/ filter,
             /*VARIABLES*/ null,
             /*PARAMETERS*/ null,
             /*IMPORTS*/ null,
             /*GROUP BY*/ null,
             /*ORDER BY*/ null,
             /*FROM*/ null,
             /*TO*/ null,
             /*JDOQLTyped*/ null,
             /*paramValues*/ null);

     ArrayList<Object> expectedResults = new ArrayList<>();
     Transaction tx = pm.currentTransaction();
     try {
       tx.begin();
       for (Object resultOid : resultOids) {
         expectedResults.add(pm.getObjectById(resultOid));
       }
     } finally {
       if (tx.isActive()) {
         tx.rollback();
       }
     }

     executeAPIQuery(ASSERTION_FAILED, qeh, expectedResults);
     executeSingleStringQuery(ASSERTION_FAILED, qeh, expectedResults);
   }

   /** This methods tests Optional fields and parameters. */
   public void testParameterOptional() {
     OptionalSample osReferencedPC1 = getOptionalSampleById(oidReferencedPC1);
     String paramDecl = "java.util.Optional op";
     Map<String, Object> paramValues = new HashMap<>();

     paramValues.put("op", Optional.of(osReferencedPC1));
     checkQuery("this.optionalPC == op", paramDecl, paramValues, new Object[] {oidPC});

     paramValues.put("op", Optional.of(DATE));
     checkQuery("this.optionalDate == op", paramDecl, paramValues, new Object[] {oidPC});

     paramValues.put("op", Optional.of(INTEGER));
     checkQuery("this.optionalInteger == op", paramDecl, paramValues, new Object[] {oidPC});

     paramValues.put("op", Optional.of(STRING));
     checkQuery("this.optionalString == op", paramDecl, paramValues, new Object[] {oidPC});
   }

   /** This methods tests Optional fields and parameters with auto de-referencing. */
   public void testParameterOptionalAutoDeref() {
     OptionalSample osReferencedPC1 = getOptionalSampleById(oidReferencedPC1);
     Map<String, Object> paramValues = new HashMap<>();

     paramValues.put("op", osReferencedPC1);
     checkQuery(
         "this.optionalPC == op",
         OptionalSample.class.getName() + " op",
         paramValues,
         new Object[] {oidPC});

     paramValues.put("op", DATE);
     checkQuery("this.optionalDate == op", "java.util.Date op", paramValues, new Object[] {oidPC});

     paramValues.put("op", INTEGER);
     checkQuery("this.optionalInteger == op", "Integer op", paramValues, new Object[] {oidPC});

     paramValues.put("op", STRING);
     checkQuery("this.optionalString == op", "String op", paramValues, new Object[] {oidPC});
   }

   private OptionalSample getOptionalSampleById(Object id) {
     Transaction tx = pm.currentTransaction();
     try {
       tx.begin();
       return (OptionalSample) pm.getObjectById(id);
     } finally {
       if (tx.isActive()) {
         tx.rollback();
       }
     }
   }

   /** This methods tests that empty Optional fields and parameters matches with Optional.empty(). */
   public void testParameterOptionalWithEmptyFields() {
     String paramDecl = "java.util.Optional op";
     Map<String, Object> paramValues = new HashMap<>();
     paramValues.put("op", Optional.empty());
     checkQuery(
         "this.optionalPC == op",
         paramDecl,
         paramValues,
         new Object[] {oidEmpty, oidNull, oidReferencedPC2});
     checkQuery(
         "this.optionalDate == op",
         paramDecl,
         paramValues,
         new Object[] {oidEmpty, oidNull, oidReferencedPC1, oidReferencedPC2});
     checkQuery(
         "this.optionalInteger == op",
         paramDecl,
         paramValues,
         new Object[] {oidEmpty, oidNull, oidReferencedPC1, oidReferencedPC2});
     checkQuery(
         "this.optionalString == op",
         paramDecl,
         paramValues,
         new Object[] {oidEmpty, oidNull, oidReferencedPC1, oidReferencedPC2});
   }

   /** This methods tests that Optional fields and parameters matches with (Optional)null. */
   public void testParameterOptionalWithNull() {
     String paramDecl = "java.util.Optional op";
     Map<String, Object> paramValues = new HashMap<>();
     paramValues.put("op", null);
     checkQuery(
         "this.optionalPC == op",
         paramDecl,
         paramValues,
         new Object[] {oidEmpty, oidNull, oidReferencedPC2});
     checkQuery(
         "this.optionalDate == op",
         paramDecl,
         paramValues,
         new Object[] {oidEmpty, oidNull, oidReferencedPC1, oidReferencedPC2});
     checkQuery(
         "this.optionalInteger == op",
         paramDecl,
         paramValues,
         new Object[] {oidEmpty, oidNull, oidReferencedPC1, oidReferencedPC2});
     checkQuery(
         "this.optionalString == op",
         paramDecl,
         paramValues,
         new Object[] {oidEmpty, oidNull, oidReferencedPC1, oidReferencedPC2});
   }

   /** This methods tests that Optional fields and parameters matches with (Object)null. */
   public void testParameterOptionalNull() {
     Map<String, Object> paramValues = new HashMap<>();
     paramValues.put("op", null);
     checkQuery(
         "this.optionalPC == op",
         OptionalSample.class.getName() + " op",
         paramValues,
         new Object[] {oidEmpty, oidNull, oidReferencedPC2});
     checkQuery(
         "this.optionalDate == op",
         "java.util.Date op",
         paramValues,
         new Object[] {oidEmpty, oidNull, oidReferencedPC1, oidReferencedPC2});
     checkQuery(
         "this.optionalInteger == op",
         "java.lang.Integer op",
         paramValues,
         new Object[] {oidEmpty, oidNull, oidReferencedPC1, oidReferencedPC2});
     checkQuery(
         "this.optionalString == op",
         "java.lang.String op",
         paramValues,
         new Object[] {oidEmpty, oidNull, oidReferencedPC1, oidReferencedPC2});
   }

   /** This methods tests that Optional fields can be accessed in subqueries. */
   public void testSubqueries() {
     String queryStr1 =
         "SELECT FROM "
             + OptionalSample.class.getName()
             + " WHERE "
             + "(select max(a.id) from "
             + OptionalSample.class.getName()
             + " a "
             + "where a.optionalPC.isPresent() ) == id";
     Object[] expectedResult1 = new Object[] {oidReferencedPC1};
     checkSingleStringQuery(queryStr1, expectedResult1);

     String queryStr2 =
         "SELECT FROM "
             + OptionalSample.class.getName()
             + " WHERE "
             + "(select max(a.id) from "
             + OptionalSample.class.getName()
             + " a "
             + "where a.optionalPC.get() != null) == id";
     Object[] expectedResult2 = new Object[] {oidReferencedPC1};
     checkSingleStringQuery(queryStr2, expectedResult2);
   }

   /** This methods tests that Optional fields can be accessed in subqueries. */
   public void testOptionalAggregation() {
     String clsName = OptionalSample.class.getName();

     String queryStr1 = "SELECT AVG(optionalInteger) FROM " + clsName;
     Query<?> q1 = pm.newQuery(queryStr1);
     executeJDOQuery(ASSERTION_FAILED, q1, queryStr1, false, null, (double) INTEGER, true);

     String queryStr2 = "SELECT AVG(optionalInteger.get()) FROM " + clsName;
     Query<?> q2 = pm.newQuery(queryStr2);
     executeJDOQuery(ASSERTION_FAILED, q2, queryStr2, false, null, (double) INTEGER, true);

     // return the object whose Integer is the same as the AVG of all
     // objects that have the Integer present.
     String queryStrSub1 =
         "SELECT FROM "
             + clsName
             + " WHERE "
             + "(select avg(a.optionalInteger) from "
             + clsName
             + " a "
             + "where a.optionalInteger.isPresent() ) == optionalInteger";
     Object[] expectedResult1 = new Object[] {oidPC};
     checkSingleStringQuery(queryStrSub1, expectedResult1);

     String queryStrSub2 =
         "SELECT FROM "
             + clsName
             + " WHERE "
             + "(select avg(a.optionalInteger.get()) from "
             + clsName
             + " a "
             + "where a.optionalInteger.isPresent() ) == optionalInteger";
     Object[] expectedResult2 = new Object[] {oidPC};
     checkSingleStringQuery(queryStrSub2, expectedResult2);

     // Find all where the average is the same as the integer value itself.
     // This returns ALL objects!!!
     String queryStrSub3 =
         "SELECT FROM "
             + clsName
             + " WHERE "
             + "(select avg(a.optionalInteger) from "
             + clsName
             + " a "
             + " ) == optionalInteger";
     Object[] expectedResult3 = new Object[] {oidPC};
     checkSingleStringQuery(queryStrSub3, expectedResult3);
   }

   private void checkSingleStringQuery(String singleStringJDOQL, Object... resultOids) {
     ArrayList<Object> expectedResults = new ArrayList<>();
     Transaction tx = pm.currentTransaction();
     try {
       tx.begin();
       for (Object resultOid : resultOids) {
         expectedResults.add(pm.getObjectById(resultOid));
       }
     } finally {
       if (tx.isActive()) tx.rollback();
     }

     Query<?> singleStringQuery = pm.newQuery(singleStringJDOQL);
     executeJDOQuery(
         ASSERTION_FAILED, singleStringQuery, singleStringJDOQL, false, null, expectedResults, true);
   }

   private void checkQuery(
       String filter, String paramDecl, Map<String, Object> paramValues, Object[] result) {
     QueryElementHolder<OptionalSample> qeh =
         new QueryElementHolder<>(
             /*UNIQUE*/ null,
             /*RESULT*/ null,
             /*INTO*/ null,
             /*FROM*/ OptionalSample.class,
             /*EXCLUDE*/ null,
             /*WHERE*/ filter,
             /*VARIABLES*/ null,
             /*PARAMETERS*/ paramDecl,
             /*IMPORTS*/ null,
             /*GROUP BY*/ null,
             /*ORDER BY*/ null,
             /*FROM*/ null,
             /*TO*/ null,
             /*JDOQLTyped*/ null,
             /*paramValues*/ paramValues);

     ArrayList<Object> expectedResults = new ArrayList<>();
     PersistenceManager pm = getPM();
     Transaction tx = pm.currentTransaction();
     try {
       tx.begin();
       for (Object o : result) {
         if (o instanceof String || o instanceof Date || o instanceof Integer) {
           expectedResults.add(o);
         } else {
           expectedResults.add(pm.getObjectById(o));
         }
       }
     } finally {
       if (tx.isActive()) {
         tx.rollback();
       }
     }

     executeAPIQuery(ASSERTION_FAILED, qeh, expectedResults);
     executeSingleStringQuery(ASSERTION_FAILED, qeh, expectedResults);
   }

   /** Result class for queries on OptionalSample. */
   public static class ResultInfo {
     public long id;
     public String optionalString;

     public ResultInfo() {}

     public ResultInfo(long id, String optionalString) {
       this.id = id;
       this.optionalString = optionalString;
     }
   }

   /** Test Optional.orElse() in the SELECT clause of JDOQL queries. */
   @SuppressWarnings("unchecked")
   public void testOrElseInSELECT() {
     Transaction tx = pm.currentTransaction();
     try {
       tx.begin();
       Query<?> q =
           pm.newQuery(
               "SELECT id, optionalString.orElse('NotPresent') FROM "
                   + OptionalSample.class.getName());
       q.setResultClass(ResultInfo.class);
       Collection<ResultInfo> c = (Collection<ResultInfo>) q.execute();
       if (c.size() != 5) {
         fail(ASSERTION_FAILED, "Wrong result count: " + c.size());
       }
       for (ResultInfo i : c) {
         switch ((int) i.id) {
           case PC_ID:
             if (!STRING.equals(i.optionalString)) {
               fail(ASSERTION_FAILED, "Wrong string value: " + i.optionalString);
             }
             break;
           case PC_EMPTY_ID:
           case PC_NULL_ID:
           case REFERENCED_PC1_ID:
           case REFERENCED_PC2_ID:
             assertEquals("NotPresent", i.optionalString);
             break;
           default:
             fail(ASSERTION_FAILED, "Wrong object id: " + i.id);
         }
       }
     } finally {
       if (tx.isActive()) {
         tx.rollback();
       }
     }
   }

   /**
    * This test assert that null-references are converted to Optional.empty() when loaded from the
    * database.
    */
   public void testPersistenceNotNull() {
     OptionalSample osNotNull = getOptionalSampleById(oidNull);

     Transaction tx = pm.currentTransaction();
     try {
       tx.begin();

       if (osNotNull.getOptionalDate() == null) {
         fail(ASSERTION_FAILED, "Date field was 'null'");
       }
       if (osNotNull.getOptionalInteger() == null) {
         fail(ASSERTION_FAILED, "Integer field was 'null'");
       }
       if (osNotNull.getOptionalPC() == null) {
         fail(ASSERTION_FAILED, "optionalPC field was 'null'");
       }
       if (osNotNull.getOptionalString() == null) {
         fail(ASSERTION_FAILED, "String field was 'null'");
       }

       if (osNotNull.getOptionalDate().isPresent()) {
         fail(ASSERTION_FAILED, "Date field was present");
       }
       if (osNotNull.getOptionalInteger().isPresent()) {
         fail(ASSERTION_FAILED, "Integer field was present");
       }
       if (osNotNull.getOptionalPC().isPresent()) {
         fail(ASSERTION_FAILED, "optionalPC field was present");
       }
       if (osNotNull.getOptionalString().isPresent()) {
         fail(ASSERTION_FAILED, "String field was present");
       }
     } finally {
       if (tx.isActive()) {
         tx.rollback();
       }
     }
   }

   /**
    * @see org.apache.jdo.tck.JDO_Test#localSetUp()
    */
   @Override
   protected void localSetUp() {
     addTearDownClass(OptionalSample.class);
     insertOptionalSample(getPM());
   }

   private void insertOptionalSample(PersistenceManager pm) {
     Transaction tx = pm.currentTransaction();
     try {
       tx.begin();

       // Create two objects that are referenced by other objects, this allows
       // testing of navigation in queries.
       // The referencedPC1 will be referenced by 'osPC',
       // The referencedPC2 will be referenced by referencedPC1.
       OptionalSample referencedPC1 = new OptionalSample();
       referencedPC1.setId(REFERENCED_PC1_ID);
       pm.makePersistent(referencedPC1);
       oidReferencedPC1 = pm.getObjectId(referencedPC1);

       OptionalSample referencedPC2 = new OptionalSample();
       referencedPC2.setId(REFERENCED_PC2_ID);
       pm.makePersistent(referencedPC2);
       oidReferencedPC2 = pm.getObjectId(referencedPC2);

       referencedPC1.setOptionalPC(Optional.of(referencedPC2));

       OptionalSample osPC = new OptionalSample();
       osPC.setId(PC_ID);
       osPC.setOptionalPC(Optional.of(referencedPC1));
       osPC.setOptionalDate(Optional.of(DATE));
       osPC.setOptionalInteger(Optional.of(INTEGER));
       osPC.setOptionalString(Optional.of(STRING));
       pm.makePersistent(osPC);
       oidPC = pm.getObjectId(osPC);

       // use empty optionals
       OptionalSample osEmpty = new OptionalSample();
       osEmpty.setId(PC_EMPTY_ID);
       osEmpty.setOptionalPC(Optional.empty());
       osEmpty.setOptionalDate(Optional.empty());
       osEmpty.setOptionalInteger(Optional.empty());
       osEmpty.setOptionalString(Optional.empty());
       pm.makePersistent(osEmpty);
       oidEmpty = pm.getObjectId(osEmpty);

       // use null for optional fields
       OptionalSample osNull = new OptionalSample();
       osNull.setId(PC_NULL_ID);
       osNull.setOptionalPC(null);
       osNull.setOptionalDate(null);
       osNull.setOptionalInteger(null);
       osNull.setOptionalString(null);
       pm.makePersistent(osNull);
       oidNull = pm.getObjectId(osNull);

       tx.commit();
     } finally {
       if (tx.isActive()) {
         tx.rollback();
       }
     }
   }

   @Override
   protected void localTearDown() {
     // set all references to null to allow deletion of (otherwise) referenced objects
     Transaction tx = getPM().currentTransaction();
     tx.begin();
     Query<OptionalSample> q = pm.newQuery(OptionalSample.class);
     for (OptionalSample os : q.executeList()) {
       os.setOptionalPC(Optional.empty());
     }
     tx.commit();

     super.localTearDown();
   }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You 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
	<<<<<<< Updated upstream
	*
	* 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
	=======
	*
	* https://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
	>>>>>>> Stashed changes
	* limitations under the License.
	*/

	package org.apache.jdo.tck.query.jdoql.methods;

	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.Date;
	import java.util.HashMap;
	import java.util.Map;
	import java.util.Optional;
	import javax.jdo.PersistenceManager;
	import javax.jdo.Query;
	import javax.jdo.Transaction;
	import org.apache.jdo.tck.pc.query.OptionalSample;
	import org.apache.jdo.tck.query.QueryElementHolder;
	import org.apache.jdo.tck.query.QueryTest;
	import org.apache.jdo.tck.util.BatchTestRunner;

	/**
	* <B>Title:</B> Optional Fields. <br>
	* <B>Keywords:</B> query <br>
	* <B>Assertion ID:</B> A14.6.2-9 <br>
	* <B>Assertion Description: </B> Queries on fields of type java.util.Optional .
	*/
	public class SupportedOptionalMethods extends QueryTest {

	/** */
	private static final String ASSERTION_FAILED = "Assertion A14.6.2-9 (OptionalFields) failed: ";

	private static final int PC_ID = 1;
	private static final int PC_EMPTY_ID = 3;
	private static final int PC_NULL_ID = 4;
	private static final int REFERENCED_PC1_ID = 88;
	private static final int REFERENCED_PC2_ID = 99;
	private static final String STRING = "Hello JDO";
	private static final Integer INTEGER = 2016;
	private static final Date DATE = new Date(1000000000);
	private Object oidReferencedPC1;
	private Object oidReferencedPC2;
	private Object oidPC;
	private Object oidEmpty;
	private Object oidNull;

	/**
	* The <code>main</code> is called when the class is directly executed from the command line.
	*
	* @param args The arguments passed to the program.
	*/
	public static void main(String[] args) {
	BatchTestRunner.run(SupportedOptionalMethods.class);
	}

	/** */
	public void testQueriesWithPresence() {
	// Matches 'optionalPC.isPresent() == true'
	checkQuery("optionalPC != null", oidPC, oidReferencedPC1);

	// matches !isPresent() but does NOT match Java 'optionalPC==null'
	checkQuery("optionalPC == null", oidEmpty, oidNull, oidReferencedPC2);

	// matches isPresent()
	checkQuery("!(optionalPC == null)", oidReferencedPC1, oidPC);

	// matches !isPresent()
	checkQuery("!(optionalPC != null)", oidReferencedPC2, oidEmpty, oidNull);

	checkQuery("optionalPC.get() != null", oidPC, oidReferencedPC1);
	checkQuery("optionalPC.get() == null", oidEmpty, oidNull, oidReferencedPC2);
	checkQuery("optionalPC.isPresent()", oidPC, oidReferencedPC1);
	checkQuery("!optionalPC.isPresent()", oidReferencedPC2, oidEmpty, oidNull);

	// querying non-PC 'Optional' fields
	checkOptionalForPresence("optionalString");
	checkOptionalForPresence("optionalDate");
	checkOptionalForPresence("optionalInteger");
	}

	private void checkOptionalForPresence(String fieldName) {
	checkQuery(fieldName + " != null", oidPC);
	checkQuery(fieldName + " == null", oidEmpty, oidNull, oidReferencedPC1, oidReferencedPC2);
	checkQuery("!(" + fieldName + " == null)", oidPC);
	checkQuery(
	"!(" + fieldName + " != null)", oidEmpty, oidNull, oidReferencedPC1, oidReferencedPC2);

	checkQuery(fieldName + ".get() != null", oidPC);
	checkQuery(fieldName + ".get() == null", oidEmpty, oidNull, oidReferencedPC1, oidReferencedPC2);
	checkQuery(fieldName + ".isPresent()", oidPC);
	checkQuery(
	"!" + fieldName + ".isPresent()", oidEmpty, oidNull, oidReferencedPC1, oidReferencedPC2);
	}

	public void testQueriesWithNavigation() {
	checkQuery("optionalPC.id == " + REFERENCED_PC1_ID, oidPC);
	checkQuery("optionalPC.id != " + REFERENCED_PC1_ID, oidReferencedPC1);
	checkQuery("!(optionalPC.id == " + REFERENCED_PC1_ID + ")", oidReferencedPC1);
	checkQuery("optionalPC.get().id == " + REFERENCED_PC1_ID, oidPC);
	checkQuery("optionalPC.get().id != " + REFERENCED_PC1_ID, oidReferencedPC1);
	checkQuery("!(optionalPC.get().id == " + REFERENCED_PC1_ID + ")", oidReferencedPC1);
	checkQuery("optionalPC.optionalPC.isPresent()", oidPC);

	// The following reflects the changed behavior in JDO 3.2 in the sense that
	// all instances are returned where either 'optionalPC.optionalPC==null' (not present)
	// or 'optionalPC==null' (the 'null' evaluates to 'null', which is followed until it is
	// evaluated in the 'isPresent()'). In other words, the query also returns all
	// objects that match '!(optionalPC.isPresent())'.
	checkQuery(
	"!(optionalPC.optionalPC.isPresent())",
	oidReferencedPC1,
	oidReferencedPC2,
	oidEmpty,
	oidNull);

	// A query where 'optionalPC!=null' and 'optionalPC.optionalPC==null;
	// can be done as follows:
	checkQuery("optionalPC.isPresent() && !(optionalPC.optionalPC.isPresent())", oidReferencedPC1);

	checkQuery("optionalPC.optionalPC.id == " + REFERENCED_PC2_ID, oidPC);
	checkQuery("optionalPC.get().optionalPC.get().id == " + REFERENCED_PC2_ID, oidPC);

	// test with && operator
	checkQuery(
	"!(optionalPC.isPresent() && optionalPC.id == " + REFERENCED_PC1_ID + ")",
	oidReferencedPC1,
	oidReferencedPC2,
	oidEmpty,
	oidNull);
	}

	private void checkQuery(String filter, Object... resultOids) {
	QueryElementHolder<OptionalSample> qeh =
	new QueryElementHolder<>(
	/UNIQUE/ null,
	/RESULT/ null,
	/INTO/ null,
	/FROM/ OptionalSample.class,
	/EXCLUDE/ null,
	/WHERE/ filter,
	/VARIABLES/ null,
	/PARAMETERS/ null,
	/IMPORTS/ null,
	/GROUP BY/ null,
	/ORDER BY/ null,
	/FROM/ null,
	/TO/ null,
	/JDOQLTyped/ null,
	/paramValues/ null);

	ArrayList<Object> expectedResults = new ArrayList<>();
	Transaction tx = pm.currentTransaction();
	try {
	tx.begin();
	for (Object resultOid : resultOids) {
	expectedResults.add(pm.getObjectById(resultOid));
	}
	} finally {
	if (tx.isActive()) {
	tx.rollback();
	}
	}

	executeAPIQuery(ASSERTION_FAILED, qeh, expectedResults);
	executeSingleStringQuery(ASSERTION_FAILED, qeh, expectedResults);
	}

	/** This methods tests Optional fields and parameters. */
	public void testParameterOptional() {
	OptionalSample osReferencedPC1 = getOptionalSampleById(oidReferencedPC1);
	String paramDecl = "java.util.Optional op";
	Map<String, Object> paramValues = new HashMap<>();

	paramValues.put("op", Optional.of(osReferencedPC1));
	checkQuery("this.optionalPC == op", paramDecl, paramValues, new Object[] {oidPC});

	paramValues.put("op", Optional.of(DATE));
	checkQuery("this.optionalDate == op", paramDecl, paramValues, new Object[] {oidPC});

	paramValues.put("op", Optional.of(INTEGER));
	checkQuery("this.optionalInteger == op", paramDecl, paramValues, new Object[] {oidPC});

	paramValues.put("op", Optional.of(STRING));
	checkQuery("this.optionalString == op", paramDecl, paramValues, new Object[] {oidPC});
	}

	/** This methods tests Optional fields and parameters with auto de-referencing. */
	public void testParameterOptionalAutoDeref() {
	OptionalSample osReferencedPC1 = getOptionalSampleById(oidReferencedPC1);
	Map<String, Object> paramValues = new HashMap<>();

	paramValues.put("op", osReferencedPC1);
	checkQuery(
	"this.optionalPC == op",
	OptionalSample.class.getName() + " op",
	paramValues,
	new Object[] {oidPC});

	paramValues.put("op", DATE);
	checkQuery("this.optionalDate == op", "java.util.Date op", paramValues, new Object[] {oidPC});

	paramValues.put("op", INTEGER);
	checkQuery("this.optionalInteger == op", "Integer op", paramValues, new Object[] {oidPC});

	paramValues.put("op", STRING);
	checkQuery("this.optionalString == op", "String op", paramValues, new Object[] {oidPC});
	}

	private OptionalSample getOptionalSampleById(Object id) {
	Transaction tx = pm.currentTransaction();
	try {
	tx.begin();
	return (OptionalSample) pm.getObjectById(id);
	} finally {
	if (tx.isActive()) {
	tx.rollback();
	}
	}
	}

	/** This methods tests that empty Optional fields and parameters matches with Optional.empty(). */
	public void testParameterOptionalWithEmptyFields() {
	String paramDecl = "java.util.Optional op";
	Map<String, Object> paramValues = new HashMap<>();
	paramValues.put("op", Optional.empty());
	checkQuery(
	"this.optionalPC == op",
	paramDecl,
	paramValues,
	new Object[] {oidEmpty, oidNull, oidReferencedPC2});
	checkQuery(
	"this.optionalDate == op",
	paramDecl,
	paramValues,
	new Object[] {oidEmpty, oidNull, oidReferencedPC1, oidReferencedPC2});
	checkQuery(
	"this.optionalInteger == op",
	paramDecl,
	paramValues,
	new Object[] {oidEmpty, oidNull, oidReferencedPC1, oidReferencedPC2});
	checkQuery(
	"this.optionalString == op",
	paramDecl,
	paramValues,
	new Object[] {oidEmpty, oidNull, oidReferencedPC1, oidReferencedPC2});
	}

	/** This methods tests that Optional fields and parameters matches with (Optional)null. */
	public void testParameterOptionalWithNull() {
	String paramDecl = "java.util.Optional op";
	Map<String, Object> paramValues = new HashMap<>();
	paramValues.put("op", null);
	checkQuery(
	"this.optionalPC == op",
	paramDecl,
	paramValues,
	new Object[] {oidEmpty, oidNull, oidReferencedPC2});
	checkQuery(
	"this.optionalDate == op",
	paramDecl,
	paramValues,
	new Object[] {oidEmpty, oidNull, oidReferencedPC1, oidReferencedPC2});
	checkQuery(
	"this.optionalInteger == op",
	paramDecl,
	paramValues,
	new Object[] {oidEmpty, oidNull, oidReferencedPC1, oidReferencedPC2});
	checkQuery(
	"this.optionalString == op",
	paramDecl,
	paramValues,
	new Object[] {oidEmpty, oidNull, oidReferencedPC1, oidReferencedPC2});
	}

	/** This methods tests that Optional fields and parameters matches with (Object)null. */
	public void testParameterOptionalNull() {
	Map<String, Object> paramValues = new HashMap<>();
	paramValues.put("op", null);
	checkQuery(
	"this.optionalPC == op",
	OptionalSample.class.getName() + " op",
	paramValues,
	new Object[] {oidEmpty, oidNull, oidReferencedPC2});
	checkQuery(
	"this.optionalDate == op",
	"java.util.Date op",
	paramValues,
	new Object[] {oidEmpty, oidNull, oidReferencedPC1, oidReferencedPC2});
	checkQuery(
	"this.optionalInteger == op",
	"java.lang.Integer op",
	paramValues,
	new Object[] {oidEmpty, oidNull, oidReferencedPC1, oidReferencedPC2});
	checkQuery(
	"this.optionalString == op",
	"java.lang.String op",
	paramValues,
	new Object[] {oidEmpty, oidNull, oidReferencedPC1, oidReferencedPC2});
	}

	/** This methods tests that Optional fields can be accessed in subqueries. */
	public void testSubqueries() {
	String queryStr1 =
	"SELECT FROM "
	+ OptionalSample.class.getName()
	+ " WHERE "
	+ "(select max(a.id) from "
	+ OptionalSample.class.getName()
	+ " a "
	+ "where a.optionalPC.isPresent() ) == id";
	Object[] expectedResult1 = new Object[] {oidReferencedPC1};
	checkSingleStringQuery(queryStr1, expectedResult1);

	String queryStr2 =
	"SELECT FROM "
	+ OptionalSample.class.getName()
	+ " WHERE "
	+ "(select max(a.id) from "
	+ OptionalSample.class.getName()
	+ " a "
	+ "where a.optionalPC.get() != null) == id";
	Object[] expectedResult2 = new Object[] {oidReferencedPC1};
	checkSingleStringQuery(queryStr2, expectedResult2);
	}

	/** This methods tests that Optional fields can be accessed in subqueries. */
	public void testOptionalAggregation() {
	String clsName = OptionalSample.class.getName();

	String queryStr1 = "SELECT AVG(optionalInteger) FROM " + clsName;
	Query<?> q1 = pm.newQuery(queryStr1);
	executeJDOQuery(ASSERTION_FAILED, q1, queryStr1, false, null, (double) INTEGER, true);

	String queryStr2 = "SELECT AVG(optionalInteger.get()) FROM " + clsName;
	Query<?> q2 = pm.newQuery(queryStr2);
	executeJDOQuery(ASSERTION_FAILED, q2, queryStr2, false, null, (double) INTEGER, true);

	// return the object whose Integer is the same as the AVG of all
	// objects that have the Integer present.
	String queryStrSub1 =
	"SELECT FROM "
	+ clsName
	+ " WHERE "
	+ "(select avg(a.optionalInteger) from "
	+ clsName
	+ " a "
	+ "where a.optionalInteger.isPresent() ) == optionalInteger";
	Object[] expectedResult1 = new Object[] {oidPC};
	checkSingleStringQuery(queryStrSub1, expectedResult1);

	String queryStrSub2 =
	"SELECT FROM "
	+ clsName
	+ " WHERE "
	+ "(select avg(a.optionalInteger.get()) from "
	+ clsName
	+ " a "
	+ "where a.optionalInteger.isPresent() ) == optionalInteger";
	Object[] expectedResult2 = new Object[] {oidPC};
	checkSingleStringQuery(queryStrSub2, expectedResult2);

	// Find all where the average is the same as the integer value itself.
	// This returns ALL objects!!!
	String queryStrSub3 =
	"SELECT FROM "
	+ clsName
	+ " WHERE "
	+ "(select avg(a.optionalInteger) from "
	+ clsName
	+ " a "
	+ " ) == optionalInteger";
	Object[] expectedResult3 = new Object[] {oidPC};
	checkSingleStringQuery(queryStrSub3, expectedResult3);
	}

	private void checkSingleStringQuery(String singleStringJDOQL, Object... resultOids) {
	ArrayList<Object> expectedResults = new ArrayList<>();
	Transaction tx = pm.currentTransaction();
	try {
	tx.begin();
	for (Object resultOid : resultOids) {
	expectedResults.add(pm.getObjectById(resultOid));
	}
	} finally {
	if (tx.isActive()) tx.rollback();
	}

	Query<?> singleStringQuery = pm.newQuery(singleStringJDOQL);
	executeJDOQuery(
	ASSERTION_FAILED, singleStringQuery, singleStringJDOQL, false, null, expectedResults, true);
	}

	private void checkQuery(
	String filter, String paramDecl, Map<String, Object> paramValues, Object[] result) {
	QueryElementHolder<OptionalSample> qeh =
	new QueryElementHolder<>(
	/UNIQUE/ null,
	/RESULT/ null,
	/INTO/ null,
	/FROM/ OptionalSample.class,
	/EXCLUDE/ null,
	/WHERE/ filter,
	/VARIABLES/ null,
	/PARAMETERS/ paramDecl,
	/IMPORTS/ null,
	/GROUP BY/ null,
	/ORDER BY/ null,
	/FROM/ null,
	/TO/ null,
	/JDOQLTyped/ null,
	/paramValues/ paramValues);

	ArrayList<Object> expectedResults = new ArrayList<>();
	PersistenceManager pm = getPM();
	Transaction tx = pm.currentTransaction();
	try {
	tx.begin();
	for (Object o : result) {
	if (o instanceof String \|\| o instanceof Date \|\| o instanceof Integer) {
	expectedResults.add(o);
	} else {
	expectedResults.add(pm.getObjectById(o));
	}
	}
	} finally {
	if (tx.isActive()) {
	tx.rollback();
	}
	}

	executeAPIQuery(ASSERTION_FAILED, qeh, expectedResults);
	executeSingleStringQuery(ASSERTION_FAILED, qeh, expectedResults);
	}

	/** Result class for queries on OptionalSample. */
	public static class ResultInfo {
	public long id;
	public String optionalString;

	public ResultInfo() {}

	public ResultInfo(long id, String optionalString) {
	this.id = id;
	this.optionalString = optionalString;
	}
	}

	/** Test Optional.orElse() in the SELECT clause of JDOQL queries. */
	@SuppressWarnings("unchecked")
	public void testOrElseInSELECT() {
	Transaction tx = pm.currentTransaction();
	try {
	tx.begin();
	Query<?> q =
	pm.newQuery(
	"SELECT id, optionalString.orElse('NotPresent') FROM "
	+ OptionalSample.class.getName());
	q.setResultClass(ResultInfo.class);
	Collection<ResultInfo> c = (Collection<ResultInfo>) q.execute();
	if (c.size() != 5) {
	fail(ASSERTION_FAILED, "Wrong result count: " + c.size());
	}
	for (ResultInfo i : c) {
	switch ((int) i.id) {
	case PC_ID:
	if (!STRING.equals(i.optionalString)) {
	fail(ASSERTION_FAILED, "Wrong string value: " + i.optionalString);
	}
	break;
	case PC_EMPTY_ID:
	case PC_NULL_ID:
	case REFERENCED_PC1_ID:
	case REFERENCED_PC2_ID:
	assertEquals("NotPresent", i.optionalString);
	break;
	default:
	fail(ASSERTION_FAILED, "Wrong object id: " + i.id);
	}
	}
	} finally {
	if (tx.isActive()) {
	tx.rollback();
	}
	}
	}

	/**
	* This test assert that null-references are converted to Optional.empty() when loaded from the
	* database.
	*/
	public void testPersistenceNotNull() {
	OptionalSample osNotNull = getOptionalSampleById(oidNull);

	Transaction tx = pm.currentTransaction();
	try {
	tx.begin();

	if (osNotNull.getOptionalDate() == null) {
	fail(ASSERTION_FAILED, "Date field was 'null'");
	}
	if (osNotNull.getOptionalInteger() == null) {
	fail(ASSERTION_FAILED, "Integer field was 'null'");
	}
	if (osNotNull.getOptionalPC() == null) {
	fail(ASSERTION_FAILED, "optionalPC field was 'null'");
	}
	if (osNotNull.getOptionalString() == null) {
	fail(ASSERTION_FAILED, "String field was 'null'");
	}

	if (osNotNull.getOptionalDate().isPresent()) {
	fail(ASSERTION_FAILED, "Date field was present");
	}
	if (osNotNull.getOptionalInteger().isPresent()) {
	fail(ASSERTION_FAILED, "Integer field was present");
	}
	if (osNotNull.getOptionalPC().isPresent()) {
	fail(ASSERTION_FAILED, "optionalPC field was present");
	}
	if (osNotNull.getOptionalString().isPresent()) {
	fail(ASSERTION_FAILED, "String field was present");
	}
	} finally {
	if (tx.isActive()) {
	tx.rollback();
	}
	}
	}

	/**
	* @see org.apache.jdo.tck.JDO_Test#localSetUp()
	*/
	@Override
	protected void localSetUp() {
	addTearDownClass(OptionalSample.class);
	insertOptionalSample(getPM());
	}

	private void insertOptionalSample(PersistenceManager pm) {
	Transaction tx = pm.currentTransaction();
	try {
	tx.begin();

	// Create two objects that are referenced by other objects, this allows
	// testing of navigation in queries.
	// The referencedPC1 will be referenced by 'osPC',
	// The referencedPC2 will be referenced by referencedPC1.
	OptionalSample referencedPC1 = new OptionalSample();
	referencedPC1.setId(REFERENCED_PC1_ID);
	pm.makePersistent(referencedPC1);
	oidReferencedPC1 = pm.getObjectId(referencedPC1);

	OptionalSample referencedPC2 = new OptionalSample();
	referencedPC2.setId(REFERENCED_PC2_ID);
	pm.makePersistent(referencedPC2);
	oidReferencedPC2 = pm.getObjectId(referencedPC2);

	referencedPC1.setOptionalPC(Optional.of(referencedPC2));

	OptionalSample osPC = new OptionalSample();
	osPC.setId(PC_ID);
	osPC.setOptionalPC(Optional.of(referencedPC1));
	osPC.setOptionalDate(Optional.of(DATE));
	osPC.setOptionalInteger(Optional.of(INTEGER));
	osPC.setOptionalString(Optional.of(STRING));
	pm.makePersistent(osPC);
	oidPC = pm.getObjectId(osPC);

	// use empty optionals
	OptionalSample osEmpty = new OptionalSample();
	osEmpty.setId(PC_EMPTY_ID);
	osEmpty.setOptionalPC(Optional.empty());
	osEmpty.setOptionalDate(Optional.empty());
	osEmpty.setOptionalInteger(Optional.empty());
	osEmpty.setOptionalString(Optional.empty());
	pm.makePersistent(osEmpty);
	oidEmpty = pm.getObjectId(osEmpty);

	// use null for optional fields
	OptionalSample osNull = new OptionalSample();
	osNull.setId(PC_NULL_ID);
	osNull.setOptionalPC(null);
	osNull.setOptionalDate(null);
	osNull.setOptionalInteger(null);
	osNull.setOptionalString(null);
	pm.makePersistent(osNull);
	oidNull = pm.getObjectId(osNull);

	tx.commit();
	} finally {
	if (tx.isActive()) {
	tx.rollback();
	}
	}
	}

	@Override
	protected void localTearDown() {
	// set all references to null to allow deletion of (otherwise) referenced objects
	Transaction tx = getPM().currentTransaction();
	tx.begin();
	Query<OptionalSample> q = pm.newQuery(OptionalSample.class);
	for (OptionalSample os : q.executeList()) {
	os.setOptionalPC(Optional.empty());
	}
	tx.commit();

	super.localTearDown();
	}
	}