openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/graph/TestPersistentGraph.java - openjpa - 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
  *
  * 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 org.apache.openjpa.persistence.graph;

 import java.sql.Date;
 import java.util.Arrays;
 import java.util.List;

 import javax.persistence.EntityManager;
 import javax.persistence.NoResultException;

 import org.apache.openjpa.jdbc.meta.ClassMapping;
 import org.apache.openjpa.jdbc.meta.FieldMapping;
 import org.apache.openjpa.jdbc.meta.FieldStrategy;
 import org.apache.openjpa.jdbc.meta.MappingRepository;
 import org.apache.openjpa.jdbc.meta.ValueHandler;
 import org.apache.openjpa.jdbc.meta.strats.HandlerFieldStrategy;
 import org.apache.openjpa.jdbc.meta.strats.HandlerHandlerMapTableFieldStrategy;
 import org.apache.openjpa.jdbc.meta.strats.UntypedPCValueHandler;
 import org.apache.openjpa.kernel.QueryHints;
 import org.apache.openjpa.meta.ClassMetaData;
 import org.apache.openjpa.meta.FieldMetaData;
 import org.apache.openjpa.meta.MetaDataRepository;
 import org.apache.openjpa.persistence.test.SingleEMFTestCase;

 /**
  * Tests basic create and query on generic persistent graph. The test creates a
  * graph of People and Cities. Then different queries on the graph are verified.
  *
  * @author Pinaki Poddar
  *
  */
 public class TestPersistentGraph extends SingleEMFTestCase {
     private static enum Emotion {
         LOVES, HATES, KNOWS
     }

     // Identity of People is their SSN
     private static final long[] SSN = { 123456781, 123456782, 123456783, 123456784, 123456785 };
     private static final String[] PERSON_NAMES = { "P1", "P2", "P3", "P4", "P5" };
     private static final String[] CITY_NAMES = { "San Francisco", "Paris", "Rome" };

     private static final String ATTR_SINCE = "since";
     private static final Date SINCE = new Date(90, 1, 27);

     private static final String ATTR_EMOTION = "feels";
     private static final Emotion[][] EMOTIONS = {
                             /*    P1             P2             P3             P4             P5       */
     /* P1 */new Emotion[] {          null, Emotion.LOVES, Emotion.HATES,          null, Emotion.KNOWS },
     /* P2 */new Emotion[] { Emotion.LOVES,          null, Emotion.LOVES,          null, Emotion.LOVES },
     /* P3 */new Emotion[] { Emotion.HATES, Emotion.LOVES,          null,          null, Emotion.KNOWS },
     /* P4 */new Emotion[] { Emotion.LOVES, Emotion.HATES, Emotion.KNOWS, Emotion.LOVES, Emotion.LOVES },
     /* P5 */new Emotion[] {          null, Emotion.LOVES, Emotion.KNOWS, Emotion.KNOWS,          null },
     };

     private static final String ATTR_DISTANCE = "distance";
     private static final int[][] ATTR_DISTANCE_VALUE = {
                        /* C1 C2 C3 */
     /* C1 */new int[] { 0, 200, 400 },
     /* C2 */new int[] { 200, 0, 500 },
     /* C3 */new int[] { 400, 500, 0 }
     };

     private EntityManager em;
     private PersistentGraph<Object> graph;

     @Override
     public void setUp() throws Exception {
         super.setUp(CLEAR_TABLES, PersistentGraph.class, RelationGraph.class,
                 PersistentRelation.class, People.class, City.class);
         em = emf.createEntityManager();
         graph = createData();
         em.clear();
     }

     /**
      * Verifies that fields are mapped with expected strategy or value handlers.
      */
     public void testMapping() {
         assertStrategy(PersistentRelation.class, "source", HandlerFieldStrategy.class, UntypedPCValueHandler.class);
         assertStrategy(PersistentRelation.class, "target", HandlerFieldStrategy.class, UntypedPCValueHandler.class);
         assertStrategy(PersistentRelation.class, "attrs", HandlerHandlerMapTableFieldStrategy.class, null);
     }

     private void printMapping(FieldMapping fm) {
         System.err.println("Field :" + fm.getName());
         System.err.println("Type :" + fm.getTypeCode() + " " + fm.getType());
         System.err.println("Type (declared):" + fm.getDeclaredTypeCode() + " " + fm.getDeclaredType());
         System.err.println("Type Override :" + fm.getTypeOverride());
         System.err.println("Key type  :" + fm.getKey().getType());
         System.err.println("Key declared type  :" + fm.getKey().getDeclaredType());
         System.err.println("Element type  :" + fm.getElement().getType());
         System.err.println("Element declared type  :" + fm.getElement().getDeclaredType());
     }

     FieldMapping getFieldMapping(Class<?> pcClass, String field) {
         MappingRepository repos = (MappingRepository) emf.getConfiguration()
                 .getMetaDataRepositoryInstance();
         ClassMapping cmd = repos.getMapping(pcClass, null, true);
         assertNotNull("No metadata found for " + pcClass, cmd);
         FieldMapping fmd = cmd.getFieldMapping(field);
         assertNotNull("No metadata found for " + pcClass.getName() + "." + field + " Fields are "
                 + Arrays.toString(cmd.getFieldNames()), fmd);
         return fmd;
     }

     /**
      * Asserts that the given field of the given class has been mapped with the
      * given strategy or value handler.
      */
     void assertStrategy(Class<?> pcClass, String field, Class<? extends FieldStrategy> strategy,
             Class<? extends ValueHandler> handler) {

         FieldMapping fmd = getFieldMapping(pcClass, field);
         FieldStrategy actualStrategy = ((FieldMapping) fmd).getStrategy();
         assertEquals(strategy, actualStrategy.getClass());
         ValueHandler actualHandler = fmd.getHandler();
         if (handler == null) {
             if (actualHandler != null) {
                 printMapping(fmd);
                 fail("Expected no value handler for " + pcClass.getName() + "." + field +
                         " but found " + actualHandler);
             }
         } else {
             if (actualHandler == null) {
                 printMapping(fmd);
                 fail("Expected a value handler for " + pcClass.getName() + "." + field + " but found null");
             }
             if (!handler.equals(actualHandler.getClass())) {
                 printMapping(fmd);
                 assertEquals(handler, fmd.getHandler().getClass());
             }
         }
     }

     FieldStrategy getStrategy(Class<?> cls, String field) {
         MetaDataRepository repos = emf.getConfiguration().getMetaDataRepositoryInstance();
         ClassMetaData cmd = repos.getMetaData(cls, null, true);
         assertNotNull("No metadat found for " + cls, cmd);
         FieldMetaData fmd = cmd.getField(field);
         assertNotNull("No metadata found for " + cls.getName() + "." + field + " Fields are "
                 + Arrays.toString(cmd.getFieldNames()), fmd);
         FieldStrategy strategy = ((FieldMapping) fmd).getStrategy();
         System.err.println(cls.getName() + "." + field + ":" + strategy.getClass().getSimpleName());
         return strategy;
     }

     /**
      * Tests that the nodes retrieved from the database meets the same
      * assertions of the created graph.
      */
     public void testCreateGraph() {
         em.getTransaction().begin();
         assertFalse(em.contains(graph));
         graph = em.find(PersistentGraph.class, graph.getId());
         assertNotNull(graph);
         People[] people = new People[SSN.length];
         for (int i = 0; i < SSN.length; i++) {
             People p = em.find(People.class, SSN[i]);
             assertNotNull(p);
             people[i] = p;
         }
         City[] cities = new City[CITY_NAMES.length];
         for (int i = 0; i < CITY_NAMES.length; i++) {
             City c = em.find(City.class, CITY_NAMES[i]);
             assertNotNull(c);
             cities[i] = c;
         }
         assertDataEquals(graph, people, cities);

         em.getTransaction().rollback();
     }

     /**
      * Tests that relation can be queried and their references are set
      * correctly.
      */
     public void testQueryRelation() {
         String jpql = "select r from PersistentRelation r";
         List<PersistentRelation> relations = em.createQuery(jpql, PersistentRelation.class).getResultList();
         for (Relation<?, ?> r : relations) {
             Object source = r.getSource();
             Object target = r.getTarget();
             if (source instanceof People) {
                 int i = indexOf((People) source);
                 if (target instanceof People) {
                     int j = indexOf((People) target);
                     assertNotNull(EMOTIONS[i][j]);
                     assertEquals(EMOTIONS[i][j].toString(), r.getAttribute(ATTR_EMOTION));
                 } else if (target instanceof City) {
                     int j = indexOf((City) target);
                     assertEquals(i % CITY_NAMES.length, j);
                     assertTrue(r.getAttributes().isEmpty());
                 } else if (target != null){
                     fail("Unexpected relation " + r);
                 }
             } else if (source instanceof City) {
                 int i = indexOf((City) source);
                 if (target instanceof City) {
                     int j = indexOf((City) target);
                     assertEquals(""+ATTR_DISTANCE_VALUE[i][j], r.getAttribute(ATTR_DISTANCE));
                 } else if (target != null) {
                     fail("Unexpected relation " + r);
                 }
             }
         }
     }

     /**
      * Tests that a relation can be queried predicated on its source vertex.
      */
     public void testQueryRelationOnSourceParameter() {
         People p1 = em.find(People.class, SSN[0]);
         String jpql = "select r from PersistentRelation r where r.source = :node";
         List<PersistentRelation> result = em.createQuery(jpql, PersistentRelation.class)
                                   .setParameter("node", p1)
                                   .getResultList();
         assertFalse("Result of [" + jpql + "] on source = " + p1 + " should not be empty", result.isEmpty());
     }

     /**
      * Tests that a relation can be queried predicated on its attribute key.
      */
     public void testQueryRelationOnSingleAttributeKey() {
         String jpql = "select r from PersistentRelation r join r.attrs a where key(a) = :key";
         List<PersistentRelation> result = em.createQuery(jpql, PersistentRelation.class)
                                   .setParameter("key", ATTR_EMOTION)
                                   .getResultList();

         assertFalse("Result of [" + jpql + "] on key = " + ATTR_EMOTION + " should not be empty", result.isEmpty());
     }

     /**
      * Tests that a relation can be queried predicated on a single attribute
      * key-value pair.
      */
     public void testQueryRelationOnSingleAttributeKeyValue() {
         String jpql = "select r from PersistentRelation r join r.attrs a where key(a) = :key and value(a) = :value";
         String value = EMOTIONS[0][2].toString();
         List<PersistentRelation> result = em.createQuery(jpql, PersistentRelation.class)
                                   .setParameter("key", ATTR_EMOTION)
                                   .setParameter("value", value)
                                   .getResultList();

         assertFalse("Result of [" + jpql + "] on key-value (" + ATTR_EMOTION + "," + value + ") should not be empty",
                 result.isEmpty());
     }

     /**
      * Tests that a relation can be queried predicated on a multiple attribute
      * key-value pair. This requires multiple joins. Single join will produce
      * wrong result.
      */
     public void testQueryRelationOnMultipleAttributeKeyValuePairs() {
         String jpql = "select r from PersistentRelation r join r.attrs a1 join r.attrs a2 "
                     + "where key(a1) = :key1 and value(a1) = :value1 "
                     + "and key(a2) = :key2 and value(a2) = :value2";
         String value = EMOTIONS[0][2].toString();
         List<PersistentRelation> result = em.createQuery(jpql, PersistentRelation.class)
                                   .setParameter("key1", ATTR_EMOTION)
                                   .setParameter("value1", value)
                                   .setParameter("key2", ATTR_SINCE)
                                   .setParameter("value2", SINCE.toString())
                                   .getResultList();

         assertFalse("Result of [" + jpql + "] on key-value = (" + ATTR_EMOTION + "," + value
                 + ") and key-value=("  + ATTR_SINCE + "," + SINCE + ") should not be empty",
                 result.isEmpty());

         String wrongJPQL = "select r from PersistentRelation r join r.attrs a "
                          + "where key(a) = :key1 and value(a) = :value1 "
                          + "and key(a) = :key2 and value(a) = :value2";
         List<PersistentRelation> result2 = em.createQuery(wrongJPQL, PersistentRelation.class)
                                    .setParameter("key1", ATTR_EMOTION)
                                    .setParameter("value1", value)
                                    .setParameter("key2", ATTR_SINCE)
                                    .setParameter("value2", SINCE.toString())
                                    .getResultList();

         assertTrue("Result of [" + jpql + "] on key-value = (" + ATTR_EMOTION + "," + value
                 + ") and key-value=("+ ATTR_SINCE + "," + SINCE + ") should be empty",
                 result2.isEmpty());
     }

     public void testAddRemoveAttribute() {
         em.getTransaction().begin();
         People p1 = em.find(People.class, SSN[0]);
         String jpql = "select r from PersistentRelation r where r.source = :node";
         List<PersistentRelation> r = em.createQuery(jpql, PersistentRelation.class)
                             .setHint(QueryHints.HINT_IGNORE_PREPARED_QUERY, true)
                             .setParameter("node", p1)
                             .getResultList();
         assertFalse(r.isEmpty());
         r.get(0).addAttribute("new-key", "new-value");
         em.getTransaction().commit();
         em.clear();

         em.getTransaction().begin();
         jpql = "select r from PersistentRelation r join r.attrs a where key(a) = :key";
         Relation newR = em.createQuery(jpql, PersistentRelation.class)
                           .setParameter("key", "new-key")
                           .getSingleResult();
         assertNotNull(newR);
         assertEquals("new-value", newR.getAttribute("new-key"));
         newR.removeAttribute("new-key");
         em.getTransaction().commit();

         em.getTransaction().begin();
         jpql = "select r from PersistentRelation r join r.attrs a where key(a) = :key";
         try {
             newR = em.createQuery(jpql, PersistentRelation.class)
                           .setParameter("key", "new-key")
                           .getSingleResult();
             fail(jpql + " with new-key expected no result");
         } catch (NoResultException nre) {
             // this is what is expected
         } finally {
             em.getTransaction().rollback();
         }
     }

     boolean isPopulated() {
         return em.createQuery("select count(p) from People p", Long.class).getSingleResult() > 0;
     }

     /**
      * Creates a typical graph of People and Cities. The tests are sensitive to
      * the actual values and relations set in in this method.
      */
     PersistentGraph<Object> createData() {
         PersistentGraph<Object> graph = new RelationGraph<>();

         em.getTransaction().begin();

         People[] people = new People[SSN.length];
         for (int i = 0; i < SSN.length; i++) {
             People p = new People();
             graph.add(p);
             p.setSsn(SSN[i]);
             p.setName(PERSON_NAMES[i]);
             people[i] = p;
         }
         City[] cities = new City[CITY_NAMES.length];
         for (int i = 0; i < CITY_NAMES.length; i++) {
             City c = new City();
             graph.add(c);
             c.setName(CITY_NAMES[i]);
             cities[i] = c;
         }
         for (int i = 0; i < people.length; i++) {
             for (int j = 0; j < people.length; j++) {
                 if (EMOTIONS[i][j] != null) {
                     Relation<People, People> r = graph.link(people[i], people[j])
                                  .addAttribute(ATTR_EMOTION, EMOTIONS[i][j]);
                     if (i == 0 && j == 2) {
                         r.addAttribute(ATTR_SINCE, SINCE);
                     }
                 }
             }
         }
         for (int i = 0; i < cities.length; i++) {
             for (int j = 0; j < cities.length; j++) {
                 graph.link(cities[i], cities[j]).addAttribute(ATTR_DISTANCE, ATTR_DISTANCE_VALUE[i][j]);
             }
         }

         for (int i = 0; i < people.length; i++) {
             graph.link(people[i], cities[i % CITY_NAMES.length]);
         }
         em.persist(graph);
         em.getTransaction().commit();

         return graph;
     }

     void assertDataEquals(Graph<Object> graph, People[] people, City[] cities) {
         assertEquals(SSN.length, people.length);
         assertEquals(CITY_NAMES.length, cities.length);

         for (int i = 0; i < people.length; i++) {
             People p = people[i];
             assertEquals(SSN[i], p.getSsn());
             assertEquals(PERSON_NAMES[i], p.getName());
         }
         for (int i = 0; i < cities.length; i++) {
             City c = cities[i];
             assertEquals(CITY_NAMES[i], c.getName());
         }
         for (int i = 0; i < people.length; i++) {
             People p1 = people[i];
             for (int j = 0; j < people.length; j++) {
                 People p2 = people[j];
                 Relation<People, People> r = graph.getRelation(p1,p2);
                 if (EMOTIONS[i][j] != null) {
                     assertNotNull(r);
                     assertEquals(EMOTIONS[i][j].toString(), r.getAttribute(ATTR_EMOTION));
                 } else {
                     assertNull(r);
                 }
             }
         }
         for (int i = 0; i < cities.length; i++) {
             City c1 = cities[i];
             for (int j = 0; j < cities.length; j++) {
                 City c2 = cities[j];
                 Relation<City, City> r12 = graph.getRelation(c1,c2);
                 assertNotNull(r12);
                 assertEquals(""+ATTR_DISTANCE_VALUE[i][j], r12.getAttribute(ATTR_DISTANCE));
             }
         }

         for (int i = 0; i < people.length; i++) {
             People p = people[i];
             for (int j = 0; j < cities.length; j++) {
                 City c = cities[j];
                 Relation<People, City> r = graph.getRelation(p,c);
                 if (i % CITY_NAMES.length == j) {
                     assertNotNull(r);
                 } else {
                     assertNull(r);
                 }
             }

         }
     }

     int indexOf(People p) {
         for (int i = 0; i < SSN.length; i++) {
             if (SSN[i] == p.getSsn())
                 return i;
         }
         return -1;
     }

     int indexOf(City c) {
         for (int i = 0; i < CITY_NAMES.length; i++) {
             if (CITY_NAMES[i].equals(c.getName()))
                 return i;
         }
         return -1;
     }
 }
	/*
	* 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
	*
	* 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 org.apache.openjpa.persistence.graph;

	import java.sql.Date;
	import java.util.Arrays;
	import java.util.List;

	import javax.persistence.EntityManager;
	import javax.persistence.NoResultException;

	import org.apache.openjpa.jdbc.meta.ClassMapping;
	import org.apache.openjpa.jdbc.meta.FieldMapping;
	import org.apache.openjpa.jdbc.meta.FieldStrategy;
	import org.apache.openjpa.jdbc.meta.MappingRepository;
	import org.apache.openjpa.jdbc.meta.ValueHandler;
	import org.apache.openjpa.jdbc.meta.strats.HandlerFieldStrategy;
	import org.apache.openjpa.jdbc.meta.strats.HandlerHandlerMapTableFieldStrategy;
	import org.apache.openjpa.jdbc.meta.strats.UntypedPCValueHandler;
	import org.apache.openjpa.kernel.QueryHints;
	import org.apache.openjpa.meta.ClassMetaData;
	import org.apache.openjpa.meta.FieldMetaData;
	import org.apache.openjpa.meta.MetaDataRepository;
	import org.apache.openjpa.persistence.test.SingleEMFTestCase;

	/**
	* Tests basic create and query on generic persistent graph. The test creates a
	* graph of People and Cities. Then different queries on the graph are verified.
	*
	* @author Pinaki Poddar
	*
	*/
	public class TestPersistentGraph extends SingleEMFTestCase {
	private static enum Emotion {
	LOVES, HATES, KNOWS
	}

	// Identity of People is their SSN
	private static final long[] SSN = { 123456781, 123456782, 123456783, 123456784, 123456785 };
	private static final String[] PERSON_NAMES = { "P1", "P2", "P3", "P4", "P5" };
	private static final String[] CITY_NAMES = { "San Francisco", "Paris", "Rome" };

	private static final String ATTR_SINCE = "since";
	private static final Date SINCE = new Date(90, 1, 27);

	private static final String ATTR_EMOTION = "feels";
	private static final Emotion[][] EMOTIONS = {
	/* P1 P2 P3 P4 P5 */
	/* P1 */new Emotion[] { null, Emotion.LOVES, Emotion.HATES, null, Emotion.KNOWS },
	/* P2 */new Emotion[] { Emotion.LOVES, null, Emotion.LOVES, null, Emotion.LOVES },
	/* P3 */new Emotion[] { Emotion.HATES, Emotion.LOVES, null, null, Emotion.KNOWS },
	/* P4 */new Emotion[] { Emotion.LOVES, Emotion.HATES, Emotion.KNOWS, Emotion.LOVES, Emotion.LOVES },
	/* P5 */new Emotion[] { null, Emotion.LOVES, Emotion.KNOWS, Emotion.KNOWS, null },
	};

	private static final String ATTR_DISTANCE = "distance";
	private static final int[][] ATTR_DISTANCE_VALUE = {
	/* C1 C2 C3 */
	/* C1 */new int[] { 0, 200, 400 },
	/* C2 */new int[] { 200, 0, 500 },
	/* C3 */new int[] { 400, 500, 0 }
	};

	private EntityManager em;
	private PersistentGraph<Object> graph;

	@Override
	public void setUp() throws Exception {
	super.setUp(CLEAR_TABLES, PersistentGraph.class, RelationGraph.class,
	PersistentRelation.class, People.class, City.class);
	em = emf.createEntityManager();
	graph = createData();
	em.clear();
	}

	/**
	* Verifies that fields are mapped with expected strategy or value handlers.
	*/
	public void testMapping() {
	assertStrategy(PersistentRelation.class, "source", HandlerFieldStrategy.class, UntypedPCValueHandler.class);
	assertStrategy(PersistentRelation.class, "target", HandlerFieldStrategy.class, UntypedPCValueHandler.class);
	assertStrategy(PersistentRelation.class, "attrs", HandlerHandlerMapTableFieldStrategy.class, null);
	}

	private void printMapping(FieldMapping fm) {
	System.err.println("Field :" + fm.getName());
	System.err.println("Type :" + fm.getTypeCode() + " " + fm.getType());
	System.err.println("Type (declared):" + fm.getDeclaredTypeCode() + " " + fm.getDeclaredType());
	System.err.println("Type Override :" + fm.getTypeOverride());
	System.err.println("Key type :" + fm.getKey().getType());
	System.err.println("Key declared type :" + fm.getKey().getDeclaredType());
	System.err.println("Element type :" + fm.getElement().getType());
	System.err.println("Element declared type :" + fm.getElement().getDeclaredType());
	}

	FieldMapping getFieldMapping(Class<?> pcClass, String field) {
	MappingRepository repos = (MappingRepository) emf.getConfiguration()
	.getMetaDataRepositoryInstance();
	ClassMapping cmd = repos.getMapping(pcClass, null, true);
	assertNotNull("No metadata found for " + pcClass, cmd);
	FieldMapping fmd = cmd.getFieldMapping(field);
	assertNotNull("No metadata found for " + pcClass.getName() + "." + field + " Fields are "
	+ Arrays.toString(cmd.getFieldNames()), fmd);
	return fmd;
	}

	/**
	* Asserts that the given field of the given class has been mapped with the
	* given strategy or value handler.
	*/
	void assertStrategy(Class<?> pcClass, String field, Class<? extends FieldStrategy> strategy,
	Class<? extends ValueHandler> handler) {

	FieldMapping fmd = getFieldMapping(pcClass, field);
	FieldStrategy actualStrategy = ((FieldMapping) fmd).getStrategy();
	assertEquals(strategy, actualStrategy.getClass());
	ValueHandler actualHandler = fmd.getHandler();
	if (handler == null) {
	if (actualHandler != null) {
	printMapping(fmd);
	fail("Expected no value handler for " + pcClass.getName() + "." + field +
	" but found " + actualHandler);
	}
	} else {
	if (actualHandler == null) {
	printMapping(fmd);
	fail("Expected a value handler for " + pcClass.getName() + "." + field + " but found null");
	}
	if (!handler.equals(actualHandler.getClass())) {
	printMapping(fmd);
	assertEquals(handler, fmd.getHandler().getClass());
	}
	}
	}

	FieldStrategy getStrategy(Class<?> cls, String field) {
	MetaDataRepository repos = emf.getConfiguration().getMetaDataRepositoryInstance();
	ClassMetaData cmd = repos.getMetaData(cls, null, true);
	assertNotNull("No metadat found for " + cls, cmd);
	FieldMetaData fmd = cmd.getField(field);
	assertNotNull("No metadata found for " + cls.getName() + "." + field + " Fields are "
	+ Arrays.toString(cmd.getFieldNames()), fmd);
	FieldStrategy strategy = ((FieldMapping) fmd).getStrategy();
	System.err.println(cls.getName() + "." + field + ":" + strategy.getClass().getSimpleName());
	return strategy;
	}

	/**
	* Tests that the nodes retrieved from the database meets the same
	* assertions of the created graph.
	*/
	public void testCreateGraph() {
	em.getTransaction().begin();
	assertFalse(em.contains(graph));
	graph = em.find(PersistentGraph.class, graph.getId());
	assertNotNull(graph);
	People[] people = new People[SSN.length];
	for (int i = 0; i < SSN.length; i++) {
	People p = em.find(People.class, SSN[i]);
	assertNotNull(p);
	people[i] = p;
	}
	City[] cities = new City[CITY_NAMES.length];
	for (int i = 0; i < CITY_NAMES.length; i++) {
	City c = em.find(City.class, CITY_NAMES[i]);
	assertNotNull(c);
	cities[i] = c;
	}
	assertDataEquals(graph, people, cities);

	em.getTransaction().rollback();
	}

	/**
	* Tests that relation can be queried and their references are set
	* correctly.
	*/
	public void testQueryRelation() {
	String jpql = "select r from PersistentRelation r";
	List<PersistentRelation> relations = em.createQuery(jpql, PersistentRelation.class).getResultList();
	for (Relation<?, ?> r : relations) {
	Object source = r.getSource();
	Object target = r.getTarget();
	if (source instanceof People) {
	int i = indexOf((People) source);
	if (target instanceof People) {
	int j = indexOf((People) target);
	assertNotNull(EMOTIONS[i][j]);
	assertEquals(EMOTIONS[i][j].toString(), r.getAttribute(ATTR_EMOTION));
	} else if (target instanceof City) {
	int j = indexOf((City) target);
	assertEquals(i % CITY_NAMES.length, j);
	assertTrue(r.getAttributes().isEmpty());
	} else if (target != null){
	fail("Unexpected relation " + r);
	}
	} else if (source instanceof City) {
	int i = indexOf((City) source);
	if (target instanceof City) {
	int j = indexOf((City) target);
	assertEquals(""+ATTR_DISTANCE_VALUE[i][j], r.getAttribute(ATTR_DISTANCE));
	} else if (target != null) {
	fail("Unexpected relation " + r);
	}
	}
	}
	}

	/**
	* Tests that a relation can be queried predicated on its source vertex.
	*/
	public void testQueryRelationOnSourceParameter() {
	People p1 = em.find(People.class, SSN[0]);
	String jpql = "select r from PersistentRelation r where r.source = :node";
	List<PersistentRelation> result = em.createQuery(jpql, PersistentRelation.class)
	.setParameter("node", p1)
	.getResultList();
	assertFalse("Result of [" + jpql + "] on source = " + p1 + " should not be empty", result.isEmpty());
	}

	/**
	* Tests that a relation can be queried predicated on its attribute key.
	*/
	public void testQueryRelationOnSingleAttributeKey() {
	String jpql = "select r from PersistentRelation r join r.attrs a where key(a) = :key";
	List<PersistentRelation> result = em.createQuery(jpql, PersistentRelation.class)
	.setParameter("key", ATTR_EMOTION)
	.getResultList();

	assertFalse("Result of [" + jpql + "] on key = " + ATTR_EMOTION + " should not be empty", result.isEmpty());
	}

	/**
	* Tests that a relation can be queried predicated on a single attribute
	* key-value pair.
	*/
	public void testQueryRelationOnSingleAttributeKeyValue() {
	String jpql = "select r from PersistentRelation r join r.attrs a where key(a) = :key and value(a) = :value";
	String value = EMOTIONS[0][2].toString();
	List<PersistentRelation> result = em.createQuery(jpql, PersistentRelation.class)
	.setParameter("key", ATTR_EMOTION)
	.setParameter("value", value)
	.getResultList();

	assertFalse("Result of [" + jpql + "] on key-value (" + ATTR_EMOTION + "," + value + ") should not be empty",
	result.isEmpty());
	}

	/**
	* Tests that a relation can be queried predicated on a multiple attribute
	* key-value pair. This requires multiple joins. Single join will produce
	* wrong result.
	*/
	public void testQueryRelationOnMultipleAttributeKeyValuePairs() {
	String jpql = "select r from PersistentRelation r join r.attrs a1 join r.attrs a2 "
	+ "where key(a1) = :key1 and value(a1) = :value1 "
	+ "and key(a2) = :key2 and value(a2) = :value2";
	String value = EMOTIONS[0][2].toString();
	List<PersistentRelation> result = em.createQuery(jpql, PersistentRelation.class)
	.setParameter("key1", ATTR_EMOTION)
	.setParameter("value1", value)
	.setParameter("key2", ATTR_SINCE)
	.setParameter("value2", SINCE.toString())
	.getResultList();

	assertFalse("Result of [" + jpql + "] on key-value = (" + ATTR_EMOTION + "," + value
	+ ") and key-value=(" + ATTR_SINCE + "," + SINCE + ") should not be empty",
	result.isEmpty());

	String wrongJPQL = "select r from PersistentRelation r join r.attrs a "
	+ "where key(a) = :key1 and value(a) = :value1 "
	+ "and key(a) = :key2 and value(a) = :value2";
	List<PersistentRelation> result2 = em.createQuery(wrongJPQL, PersistentRelation.class)
	.setParameter("key1", ATTR_EMOTION)
	.setParameter("value1", value)
	.setParameter("key2", ATTR_SINCE)
	.setParameter("value2", SINCE.toString())
	.getResultList();

	assertTrue("Result of [" + jpql + "] on key-value = (" + ATTR_EMOTION + "," + value
	+ ") and key-value=("+ ATTR_SINCE + "," + SINCE + ") should be empty",
	result2.isEmpty());
	}

	public void testAddRemoveAttribute() {
	em.getTransaction().begin();
	People p1 = em.find(People.class, SSN[0]);
	String jpql = "select r from PersistentRelation r where r.source = :node";
	List<PersistentRelation> r = em.createQuery(jpql, PersistentRelation.class)
	.setHint(QueryHints.HINT_IGNORE_PREPARED_QUERY, true)
	.setParameter("node", p1)
	.getResultList();
	assertFalse(r.isEmpty());
	r.get(0).addAttribute("new-key", "new-value");
	em.getTransaction().commit();
	em.clear();

	em.getTransaction().begin();
	jpql = "select r from PersistentRelation r join r.attrs a where key(a) = :key";
	Relation newR = em.createQuery(jpql, PersistentRelation.class)
	.setParameter("key", "new-key")
	.getSingleResult();
	assertNotNull(newR);
	assertEquals("new-value", newR.getAttribute("new-key"));
	newR.removeAttribute("new-key");
	em.getTransaction().commit();

	em.getTransaction().begin();
	jpql = "select r from PersistentRelation r join r.attrs a where key(a) = :key";
	try {
	newR = em.createQuery(jpql, PersistentRelation.class)
	.setParameter("key", "new-key")
	.getSingleResult();
	fail(jpql + " with new-key expected no result");
	} catch (NoResultException nre) {
	// this is what is expected
	} finally {
	em.getTransaction().rollback();
	}
	}

	boolean isPopulated() {
	return em.createQuery("select count(p) from People p", Long.class).getSingleResult() > 0;
	}

	/**
	* Creates a typical graph of People and Cities. The tests are sensitive to
	* the actual values and relations set in in this method.
	*/
	PersistentGraph<Object> createData() {
	PersistentGraph<Object> graph = new RelationGraph<>();

	em.getTransaction().begin();

	People[] people = new People[SSN.length];
	for (int i = 0; i < SSN.length; i++) {
	People p = new People();
	graph.add(p);
	p.setSsn(SSN[i]);
	p.setName(PERSON_NAMES[i]);
	people[i] = p;
	}
	City[] cities = new City[CITY_NAMES.length];
	for (int i = 0; i < CITY_NAMES.length; i++) {
	City c = new City();
	graph.add(c);
	c.setName(CITY_NAMES[i]);
	cities[i] = c;
	}
	for (int i = 0; i < people.length; i++) {
	for (int j = 0; j < people.length; j++) {
	if (EMOTIONS[i][j] != null) {
	Relation<People, People> r = graph.link(people[i], people[j])
	.addAttribute(ATTR_EMOTION, EMOTIONS[i][j]);
	if (i == 0 && j == 2) {
	r.addAttribute(ATTR_SINCE, SINCE);
	}
	}
	}
	}
	for (int i = 0; i < cities.length; i++) {
	for (int j = 0; j < cities.length; j++) {
	graph.link(cities[i], cities[j]).addAttribute(ATTR_DISTANCE, ATTR_DISTANCE_VALUE[i][j]);
	}
	}

	for (int i = 0; i < people.length; i++) {
	graph.link(people[i], cities[i % CITY_NAMES.length]);
	}
	em.persist(graph);
	em.getTransaction().commit();

	return graph;
	}

	void assertDataEquals(Graph<Object> graph, People[] people, City[] cities) {
	assertEquals(SSN.length, people.length);
	assertEquals(CITY_NAMES.length, cities.length);

	for (int i = 0; i < people.length; i++) {
	People p = people[i];
	assertEquals(SSN[i], p.getSsn());
	assertEquals(PERSON_NAMES[i], p.getName());
	}
	for (int i = 0; i < cities.length; i++) {
	City c = cities[i];
	assertEquals(CITY_NAMES[i], c.getName());
	}
	for (int i = 0; i < people.length; i++) {
	People p1 = people[i];
	for (int j = 0; j < people.length; j++) {
	People p2 = people[j];
	Relation<People, People> r = graph.getRelation(p1,p2);
	if (EMOTIONS[i][j] != null) {
	assertNotNull(r);
	assertEquals(EMOTIONS[i][j].toString(), r.getAttribute(ATTR_EMOTION));
	} else {
	assertNull(r);
	}
	}
	}
	for (int i = 0; i < cities.length; i++) {
	City c1 = cities[i];
	for (int j = 0; j < cities.length; j++) {
	City c2 = cities[j];
	Relation<City, City> r12 = graph.getRelation(c1,c2);
	assertNotNull(r12);
	assertEquals(""+ATTR_DISTANCE_VALUE[i][j], r12.getAttribute(ATTR_DISTANCE));
	}
	}

	for (int i = 0; i < people.length; i++) {
	People p = people[i];
	for (int j = 0; j < cities.length; j++) {
	City c = cities[j];
	Relation<People, City> r = graph.getRelation(p,c);
	if (i % CITY_NAMES.length == j) {
	assertNotNull(r);
	} else {
	assertNull(r);
	}
	}

	}
	}

	int indexOf(People p) {
	for (int i = 0; i < SSN.length; i++) {
	if (SSN[i] == p.getSsn())
	return i;
	}
	return -1;
	}

	int indexOf(City c) {
	for (int i = 0; i < CITY_NAMES.length; i++) {
	if (CITY_NAMES[i].equals(c.getName()))
	return i;
	}
	return -1;
	}
	}