// Test setting attributes with values that don't conform to their domain
@Test(expected = ClassCastException.class)
public void testAccessAttributesFailure3() throws GraphIOException {
Schema s =
GraphIO.loadSchemaFromFile(GenericGraphImplTest.SCHEMAFOLDER + "DefaultValueTestSchema.tg");
Graph g = s.createGraph(ImplementationType.GENERIC);
Vertex v = g.createVertex(g.getGraphClass().getVertexClass("TestVertex"));
v.setAttribute("stringVertex", 42);
}
// Test type specific getFirstIncidence Method
@Test
public void testGetFirstIncidence() throws GraphIOException {
Schema s =
GraphIO.loadSchemaFromFile(GenericGraphImplTest.SCHEMAFOLDER + "VertexTestSchema.tg");
Graph g = s.createGraph(ImplementationType.GENERIC);
Vertex[] vertices = new Vertex[6];
vertices[0] = g.createVertex(g.getGraphClass().getVertexClass("A"));
vertices[1] = g.createVertex(g.getGraphClass().getVertexClass("B"));
vertices[2] = g.createVertex(g.getGraphClass().getVertexClass("C"));
vertices[3] = g.createVertex(g.getGraphClass().getVertexClass("D"));
vertices[4] = g.createVertex(g.getGraphClass().getVertexClass("C2"));
vertices[5] = g.createVertex(g.getGraphClass().getVertexClass("D2"));
EdgeClass[] edgeClasses = new EdgeClass[7];
edgeClasses[0] = g.getGraphClass().getEdgeClass("E");
edgeClasses[1] = g.getGraphClass().getEdgeClass("F");
edgeClasses[2] = g.getGraphClass().getEdgeClass("G");
edgeClasses[3] = g.getGraphClass().getEdgeClass("H");
edgeClasses[4] = g.getGraphClass().getEdgeClass("I");
edgeClasses[5] = g.getGraphClass().getEdgeClass("J");
edgeClasses[6] = g.getGraphClass().getEdgeClass("K");
for (Vertex v : vertices) {
for (EdgeClass ec : edgeClasses) {
assertNull(v.getFirstIncidence(ec));
assertNull(v.getFirstIncidence(ec, EdgeDirection.IN));
assertNull(v.getFirstIncidence(ec, EdgeDirection.OUT));
}
}
Edge[] edges = new Edge[7];
edges[0] = g.createEdge(edgeClasses[0], vertices[0], vertices[1]);
edges[1] = g.createEdge(edgeClasses[1], vertices[2], vertices[3]);
edges[2] = g.createEdge(edgeClasses[2], vertices[2], vertices[3]);
edges[3] = g.createEdge(edgeClasses[3], vertices[0], vertices[1]);
edges[4] = g.createEdge(edgeClasses[4], vertices[0], vertices[0]);
edges[5] = g.createEdge(edgeClasses[5], vertices[4], vertices[5]);
edges[6] = g.createEdge(edgeClasses[6], vertices[0], vertices[1]);
assertEquals(vertices[0].getFirstIncidence(edgeClasses[0]), edges[0]);
assertEquals(vertices[0].getFirstIncidence(edgeClasses[6]), edges[6]);
assertEquals(vertices[1].getFirstIncidence(edgeClasses[0]), edges[0].getReversedEdge());
assertEquals(vertices[1].getFirstIncidence(edgeClasses[6]), edges[6].getReversedEdge());
assertEquals(vertices[2].getFirstIncidence(edgeClasses[1]), edges[1]);
assertEquals(vertices[3].getFirstIncidence(edgeClasses[1]), edges[1].getReversedEdge());
assertEquals(vertices[4].getFirstIncidence(edgeClasses[5]), edges[5]);
assertEquals(vertices[5].getFirstIncidence(edgeClasses[5]), edges[5].getReversedEdge());
assertEquals(
vertices[0].getFirstIncidence(edgeClasses[4], EdgeDirection.IN),
edges[4].getReversedEdge());
assertEquals(vertices[2].getFirstIncidence(edgeClasses[0], EdgeDirection.OUT), edges[1]);
}
@Override
public Iterable<Edge> getThoseEdges(Graph traversalContext) {
Vertex vertex;
try {
vertex =
localGraphDatabase.getVertexObject(storingGraphDatabase.getVertexIdAtIncidenceId(id));
} catch (RemoteException e) {
throw new RuntimeException(e);
}
assert getGraph().getTraversalContext() == null
|| getGraph().getTraversalContext().containsVertex(vertex);
return vertex.getIncidentEdges(traversalContext, getDirection().getOppositeDirection());
}
@Test
public void testAccessAttributesAfterSaveAndLoad() throws GraphIOException, IOException {
Schema schema =
GraphIO.loadSchemaFromFile(GenericGraphImplTest.SCHEMAFOLDER + "DefaultValueTestSchema.tg");
Graph g = schema.createGraph(ImplementationType.GENERIC);
Vertex v = g.createVertex(g.getGraphClass().getVertexClass("TestVertex"));
File tmp = File.createTempFile("graph", "tg");
g.save(tmp.getPath());
g = GraphIO.loadGraphFromFile(tmp.getPath(), ImplementationType.GENERIC, null);
v = g.getFirstVertex();
for (Attribute a : v.getAttributedElementClass().getAttributeList()) {
GraphIO io = GraphIO.createStringWriter(g.getSchema());
a.getDomain().serializeGenericAttribute(io, v.getAttribute(a.getName()));
assertEquals(a.getDefaultValueAsString(), io.getStringWriterResult());
}
}
@Test
public void testAccessAttributes() throws GraphIOException {
Schema s =
GraphIO.loadSchemaFromFile(GenericGraphImplTest.SCHEMAFOLDER + "DefaultValueTestSchema.tg");
Graph g = s.createGraph(ImplementationType.GENERIC);
Vertex v = g.createVertex(g.getGraphClass().getVertexClass("TestVertex"));
// accessing default values
assertEquals(true, v.getAttribute("boolVertex"));
assertEquals(
JGraLab.vector()
.plus(JGraLab.vector().plus(true))
.plus(JGraLab.vector().plus(false))
.plus(JGraLab.vector().plus(true)),
v.getAttribute("complexListVertex"));
assertEquals(
JGraLab.map()
.plus(JGraLab.vector().plus(true), JGraLab.set().plus(true))
.plus(JGraLab.vector().plus(false), JGraLab.set().plus(false)),
v.getAttribute("complexMapVertex"));
assertEquals(
JGraLab.set().plus(JGraLab.set().plus(true)).plus(JGraLab.set().plus(false)),
v.getAttribute("complexSetVertex"));
assertEquals(1.1, v.getAttribute("doubleVertex"), 0.001);
assertEquals("FIRST", v.getAttribute("enumVertex"));
assertEquals(1, (int) v.getAttribute("intVertex"));
assertEquals(JGraLab.vector().plus(true).plus(false).plus(true), v.getAttribute("listVertex"));
assertEquals(1l, (long) v.getAttribute("longVertex"));
assertEquals(
JGraLab.map().plus(1, true).plus(2, false).plus(3, true), v.getAttribute("mapVertex"));
assertEquals(
RecordImpl.empty()
.plus("boolRecord", true)
.plus("doubleRecord", 1.1d)
.plus("enumRecord", "FIRST")
.plus("intRecord", 1)
.plus("listRecord", JGraLab.vector().plus(true).plus(false).plus(true))
.plus("longRecord", 1l)
.plus("mapRecord", JGraLab.map().plus(1, true).plus(2, false).plus(3, true))
.plus("setRecord", JGraLab.set().plus(true).plus(false))
.plus("stringRecord", "test"),
v.getAttribute("recordVertex"));
assertEquals(JGraLab.set().plus(true).plus(false), v.getAttribute("setVertex"));
assertEquals("test", v.getAttribute("stringVertex"));
// changing values
v.setAttribute("boolVertex", false);
assertEquals(false, v.getAttribute("boolVertex"));
v.setAttribute(
"complexListVertex",
JGraLab.vector().plus(JGraLab.vector().plus(false)).plus(JGraLab.vector().plus(false)));
assertEquals(
JGraLab.vector().plus(JGraLab.vector().plus(false)).plus(JGraLab.vector().plus(false)),
v.getAttribute("complexListVertex"));
v.setAttribute(
"complexMapVertex",
JGraLab.map()
.plus(JGraLab.vector().plus(true).plus(false), JGraLab.set().plus(false))
.plus(JGraLab.vector().plus(false).plus(true), JGraLab.set().plus(true)));
assertEquals(
JGraLab.map()
.plus(JGraLab.vector().plus(true).plus(false), JGraLab.set().plus(false))
.plus(JGraLab.vector().plus(false).plus(true), JGraLab.set().plus(true)),
v.getAttribute("complexMapVertex"));
v.setAttribute("complexSetVertex", JGraLab.set().plus(JGraLab.set().plus(false)));
assertEquals(JGraLab.set().plus(JGraLab.set().plus(false)), v.getAttribute("complexSetVertex"));
v.setAttribute("doubleVertex", 2.2d);
assertEquals(2.2d, v.getAttribute("doubleVertex"), 0.001);
v.setAttribute("enumVertex", "SECOND");
assertEquals("SECOND", v.getAttribute("enumVertex"));
v.setAttribute("intVertex", 42);
assertEquals(42, (int) v.getAttribute("intVertex"));
v.setAttribute("listVertex", JGraLab.vector().plus(false).plus(false).plus(true));
assertEquals(JGraLab.vector().plus(false).plus(false).plus(true), v.getAttribute("listVertex"));
v.setAttribute("longVertex", 987654321l);
assertEquals(987654321l, (long) v.getAttribute("longVertex"));
v.setAttribute("mapVertex", JGraLab.map().plus(42, true).plus(24, false));
assertEquals(JGraLab.map().plus(42, true).plus(24, false), v.getAttribute("mapVertex"));
v.setAttribute(
"recordVertex",
RecordImpl.empty()
.plus("boolRecord", false)
.plus("doubleRecord", 1.3d)
.plus("enumRecord", "THIRD")
.plus("intRecord", 42)
.plus("listRecord", JGraLab.vector().plus(false).plus(true).plus(false))
.plus("longRecord", 987654321l)
.plus("mapRecord", JGraLab.map().plus(42, true).plus(24, false))
.plus("setRecord", JGraLab.set().plus(false))
.plus("stringRecord", "more test"));
assertEquals(
RecordImpl.empty()
.plus("boolRecord", false)
.plus("doubleRecord", 1.3d)
.plus("enumRecord", "THIRD")
.plus("intRecord", 42)
.plus("listRecord", JGraLab.vector().plus(false).plus(true).plus(false))
.plus("longRecord", 987654321l)
.plus("mapRecord", JGraLab.map().plus(42, true).plus(24, false))
.plus("setRecord", JGraLab.set().plus(false))
.plus("stringRecord", "more test"),
v.getAttribute("recordVertex"));
v.setAttribute("setVertex", JGraLab.set().plus(true));
assertEquals(JGraLab.set().plus(true), v.getAttribute("setVertex"));
v.setAttribute("stringVertex", "some String");
assertEquals("some String", v.getAttribute("stringVertex"));
}
// Test type specific incidences() method
@Test
public void testIncidences() throws GraphIOException {
Schema s =
GraphIO.loadSchemaFromFile(GenericGraphImplTest.SCHEMAFOLDER + "VertexTestSchema.tg");
Graph g = s.createGraph(ImplementationType.GENERIC);
Vertex a = g.createVertex(g.getGraphClass().getVertexClass("A"));
Vertex b = g.createVertex(g.getGraphClass().getVertexClass("B"));
Vertex c = g.createVertex(g.getGraphClass().getVertexClass("C"));
Vertex d = g.createVertex(g.getGraphClass().getVertexClass("D"));
Vertex c2 = g.createVertex(g.getGraphClass().getVertexClass("C2"));
Vertex d2 = g.createVertex(g.getGraphClass().getVertexClass("D2"));
HashMap<String, EdgeClass> ecs = new HashMap<>();
ecs.put("E", g.getGraphClass().getEdgeClass("E"));
ecs.put("F", g.getGraphClass().getEdgeClass("F"));
ecs.put("G", g.getGraphClass().getEdgeClass("G"));
ecs.put("H", g.getGraphClass().getEdgeClass("H"));
ecs.put("I", g.getGraphClass().getEdgeClass("I"));
ecs.put("J", g.getGraphClass().getEdgeClass("J"));
ecs.put("K", g.getGraphClass().getEdgeClass("K"));
Iterator<Edge> iterator = a.incidences(ecs.get("E")).iterator();
assertFalse(iterator.hasNext());
iterator = a.incidences(ecs.get("E"), EdgeDirection.OUT).iterator();
assertFalse(iterator.hasNext());
iterator = c.incidences(ecs.get("F"), EdgeDirection.OUT).iterator();
assertFalse(iterator.hasNext());
Edge[] edges = new Edge[7];
edges[0] = g.createEdge(ecs.get("E"), a, b);
edges[1] = g.createEdge(ecs.get("F"), c, d);
edges[2] = g.createEdge(ecs.get("G"), c, d);
edges[3] = g.createEdge(ecs.get("H"), a, b);
edges[4] = g.createEdge(ecs.get("I"), a, a);
edges[5] = g.createEdge(ecs.get("J"), c2, d2);
edges[6] = g.createEdge(ecs.get("K"), a, b);
Edge[] incidentEdges = new Edge[] {edges[0], edges[3], edges[6]};
Iterator<Edge> ii1 = a.incidences(ecs.get("E")).iterator();
Iterator<Edge> ii2 = a.incidences(ecs.get("E"), EdgeDirection.OUT).iterator();
for (int i = 0; i < incidentEdges.length; i++) {
Edge e1 = ii1.next();
Edge e2 = ii2.next();
assertEquals(incidentEdges[i], e1);
assertEquals(incidentEdges[i], e2);
}
assertFalse(ii1.hasNext());
assertFalse(ii2.hasNext());
incidentEdges = new Edge[] {edges[3], edges[6]};
ii1 = a.incidences(ecs.get("H")).iterator();
ii2 = a.incidences(ecs.get("H"), EdgeDirection.OUT).iterator();
for (int i = 0; i < incidentEdges.length; i++) {
Edge e1 = ii1.next();
Edge e2 = ii2.next();
assertEquals(incidentEdges[i], e1);
assertEquals(incidentEdges[i], e2);
}
assertFalse(ii1.hasNext());
assertFalse(ii2.hasNext());
incidentEdges =
new Edge[] {
edges[0].getReversedEdge(), edges[3].getReversedEdge(), edges[6].getReversedEdge()
};
ii1 = b.incidences(ecs.get("E")).iterator();
ii2 = b.incidences(ecs.get("E"), EdgeDirection.IN).iterator();
for (int i = 0; i < incidentEdges.length; i++) {
Edge e1 = ii1.next();
Edge e2 = ii2.next();
assertEquals(incidentEdges[i], e1);
assertEquals(incidentEdges[i], e2);
}
assertFalse(ii1.hasNext());
assertFalse(ii2.hasNext());
incidentEdges = new Edge[] {edges[1]};
ii1 = c.incidences(ecs.get("F")).iterator();
ii2 = c.incidences(ecs.get("F"), EdgeDirection.OUT).iterator();
for (int i = 0; i < incidentEdges.length; i++) {
Edge e1 = ii1.next();
Edge e2 = ii2.next();
assertEquals(incidentEdges[i], e1);
assertEquals(incidentEdges[i], e2);
}
assertFalse(ii1.hasNext());
assertFalse(ii2.hasNext());
incidentEdges = new Edge[] {edges[2]};
ii1 = c.incidences(ecs.get("G")).iterator();
ii2 = c.incidences(ecs.get("G"), EdgeDirection.OUT).iterator();
for (int i = 0; i < incidentEdges.length; i++) {
Edge e1 = ii1.next();
Edge e2 = ii2.next();
assertEquals(incidentEdges[i], e1);
assertEquals(incidentEdges[i], e2);
}
assertFalse(ii1.hasNext());
assertFalse(ii2.hasNext());
incidentEdges = new Edge[] {edges[4], edges[4].getReversedEdge()};
ii1 = a.incidences(ecs.get("I")).iterator();
for (int i = 0; i < incidentEdges.length; i++) {
Edge e1 = ii1.next();
assertEquals(incidentEdges[i], e1);
}
assertFalse(ii1.hasNext());
incidentEdges = new Edge[] {edges[5]};
ii1 = c2.incidences(ecs.get("J")).iterator();
ii2 = c2.incidences(ecs.get("J"), EdgeDirection.OUT).iterator();
for (int i = 0; i < incidentEdges.length; i++) {
Edge e1 = ii1.next();
Edge e2 = ii2.next();
assertEquals(incidentEdges[i], e1);
assertEquals(incidentEdges[i], e2);
}
assertFalse(ii1.hasNext());
assertFalse(ii2.hasNext());
}
