From 5da5bf112aa32fda4dfe97444718136d1821976c Mon Sep 17 00:00:00 2001 From: Michael Hackstein Date: Thu, 16 Oct 2014 09:21:11 +0200 Subject: [PATCH 1/9] Improved Graph AQL query tests. Some tests are missing. --- js/server/tests/ahuacatl-general-graph.js | 2309 +++++++++++---------- 1 file changed, 1220 insertions(+), 1089 deletions(-) diff --git a/js/server/tests/ahuacatl-general-graph.js b/js/server/tests/ahuacatl-general-graph.js index 66c26b0918..51f4d1721a 100644 --- a/js/server/tests/ahuacatl-general-graph.js +++ b/js/server/tests/ahuacatl-general-graph.js @@ -41,6 +41,7 @@ var assertQueryError = helper.assertQueryError; function ahuacatlQueryGeneralEdgesTestSuite() { + var gN = "bla3"; var v1 = "UnitTestsAhuacatlVertex1"; var v2 = "UnitTestsAhuacatlVertex2"; var v3 = "UnitTestsAhuacatlVertex3"; @@ -49,11 +50,14 @@ function ahuacatlQueryGeneralEdgesTestSuite() { var e2 = "UnitTestsAhuacatlEdge2"; var or = "UnitTestsAhuacatlOrphan"; + var AQL_VERTICES = "FOR e IN GRAPH_VERTICES(@name, @example, @options) SORT e._id RETURN e"; + var AQL_EDGES = "FOR e IN GRAPH_EDGES(@name, @example, @options) SORT e.what RETURN e.what"; + return { -//////////////////////////////////////////////////////////////////////////////// -/// @brief set up -//////////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////////////////////////////////////////////// + /// @brief set up + //////////////////////////////////////////////////////////////////////////////// setUp: function () { db._drop(v1); @@ -112,9 +116,9 @@ function ahuacatlQueryGeneralEdgesTestSuite() { ); }, -//////////////////////////////////////////////////////////////////////////////// -/// @brief tear down -//////////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////////////////////////////////////////////// + /// @brief tear down + //////////////////////////////////////////////////////////////////////////////// tearDown: function () { db._drop(v1); @@ -127,26 +131,160 @@ function ahuacatlQueryGeneralEdgesTestSuite() { db._collection("_graphs").remove("_graphs/bla3"); }, -//////////////////////////////////////////////////////////////////////////////// -/// @brief checks GRAPH_EDGES() and GRAPH_NEIGHBOURS() and GRAPH_VERTICES() -//////////////////////////////////////////////////////////////////////////////// - - testEdgesAny: function () { - - var actual; - actual = getRawQueryResults("FOR e IN GRAPH_VERTICES('bla3', '" + v1 + "/v1', {direction : 'any'}) RETURN e"); + //////////////////////////////////////////////////////////////////////////////// + /// @brief checks GRAPH_VERTICES() + //////////////////////////////////////////////////////////////////////////////// + testVertices: function () { + var bindVars = { + name: gN, + example: v1 + "/v1", + options: {direction : 'any'} + }; + var actual = getRawQueryResults(AQL_VERTICES, bindVars); assertEqual(actual[0]._id, v1 + '/v1'); + }, - actual = getRawQueryResults("FOR e IN GRAPH_VERTICES('bla3', {}, {direction : 'any', vertexCollectionRestriction : 'UnitTestsAhuacatlOrphan'}) RETURN e"); + testVerticesRestricted: function() { + var bindVars = { + name: gN, + example: {}, + options: { + direction : 'any', + vertexCollectionRestriction: or + } + }; + var actual = getRawQueryResults(AQL_VERTICES, bindVars); assertEqual(actual[0]._id, 'UnitTestsAhuacatlOrphan/orphan'); + assertEqual(actual.length, 1); + }, + testVerticesExample: function () { + var bindVars = { + name: gN, + example: [{hugo : true}, {heinz : 1}], + options: {direction : 'any'} + }; + var actual = getRawQueryResults(AQL_VERTICES, bindVars); + assertEqual(actual[0]._id, 'UnitTestsAhuacatlVertex1/v1'); + assertEqual(actual[1]._id, 'UnitTestsAhuacatlVertex1/v2'); + assertEqual(actual[2]._id, 'UnitTestsAhuacatlVertex2/v3'); + assertEqual(actual[3]._id, 'UnitTestsAhuacatlVertex4/v8'); + assertEqual(actual.length, 4); + }, + + testVerticesWithInboundEdges: function () { + var bindVars = { + name: gN, + example: v3 + "/v5", + options: {direction : 'inbound'} + }; + var actual = getRawQueryResults(AQL_VERTICES, bindVars); + assertEqual(actual[0]._id, 'UnitTestsAhuacatlVertex3/v5'); + assertEqual(actual.length, 1); + }, + + testVerticesWithInboundEdgesHasNoInboundEdges: function () { + var bindVars = { + name: gN, + example: v2 + "/v3", + options: {direction : 'inbound'} + }; + var actual = getRawQueryResults(AQL_VERTICES, bindVars); + assertEqual(actual.length, 0); + }, + + testVerticesWithInboundEdgesAndExample: function () { + var bindVars = { + name: gN, + example: [{hugo : true}, {heinz : 1}], + options: {direction : 'inbound'} + }; + var actual = getRawQueryResults(AQL_VERTICES, bindVars); + assertEqual(actual[0]._id, 'UnitTestsAhuacatlVertex1/v1'); + assertEqual(actual[1]._id, 'UnitTestsAhuacatlVertex1/v2'); + assertEqual(actual[2]._id, 'UnitTestsAhuacatlVertex4/v8'); + assertEqual(actual.length, 3); + }, + + testVerticesWithInboundEdgesRestrictedHasNoInbound: function() { + var bindVars = { + name: gN, + example: {}, + options: { + direction : 'inbound', + vertexCollectionRestriction: v2 + } + }; + var actual = getRawQueryResults(AQL_VERTICES, bindVars); + assertEqual(actual.length, 0); + }, + + testVerticesWithInboundEdgesRestrictedHasInbound: function() { + var bindVars = { + name: gN, + example: {}, + options: { + direction : 'inbound', + vertexCollectionRestriction: v3 + } + }; + var actual = getRawQueryResults(AQL_VERTICES, bindVars); + assertEqual(actual[0]._id, v3 + '/v5'); + assertEqual(actual[1]._id, v3 + '/v6'); + assertEqual(actual.length, 2); + }, + + testVerticesWithOutboundEdgesRestrictedHasOutbound: function() { + var bindVars = { + name: gN, + example: {}, + options: { + direction : 'outbound', + vertexCollectionRestriction: v2 + } + }; + var actual = getRawQueryResults(AQL_VERTICES, bindVars); + assertEqual(actual[0]._id, v2 + '/v3'); + assertEqual(actual[1]._id, v2 + '/v4'); + assertEqual(actual.length, 2); + }, + + testVerticesWithOutboundEdgesRestrictedHasNoOutbound: function() { + var bindVars = { + name: gN, + example: {}, + options: { + direction : 'outbound', + vertexCollectionRestriction: v3 + } + }; + var actual = getRawQueryResults(AQL_VERTICES, bindVars); + assertEqual(actual.length, 0); + }, + + //////////////////////////////////////////////////////////////////////////////// + /// @brief checks GRAPH_EDGES() + //////////////////////////////////////////////////////////////////////////////// + + //////////////////////////////////////////////////////////////////////////////// + /// Section any direction + //////////////////////////////////////////////////////////////////////////////// + + testEdgesAny: function () { + var actual; actual = getQueryResults("FOR e IN GRAPH_EDGES('bla3', 'UnitTestsAhuacatlVertex1/v1', {direction : 'any'}) SORT e.what RETURN e.what"); assertEqual(actual, [ "v1->v2", "v1->v5", "v2->v1" ]); + }, + testEdgesAnyRestricted: function () { + var actual; actual = getQueryResults("FOR e IN GRAPH_EDGES('bla3', 'UnitTestsAhuacatlVertex1/v1', {direction : 'any' , edgeCollectionRestriction: ['UnitTestsAhuacatlEdge1']}) " + "SORT e.what RETURN e.what"); assertEqual(actual, [ "v1->v2", "v2->v1" ]); + }, + testEdgesAnyStartExample: function () { + var actual; actual = getQueryResults("FOR e IN GRAPH_EDGES('bla3', [{hugo : true}, {heinz : 1}], {direction : 'any'}) " + "SORT e.what RETURN e.what"); assertEqual(actual, [ "v1->v2", @@ -156,24 +294,27 @@ function ahuacatlQueryGeneralEdgesTestSuite() { "v3->v5", "v3->v6", "v3->v8" ]); + }, - actual = getRawQueryResults("FOR e IN GRAPH_VERTICES('bla3', [{hugo : true}, {heinz : 1}], {direction : 'any'}) SORT e._id RETURN e"); - assertEqual(actual[0]._id, 'UnitTestsAhuacatlVertex1/v1'); - assertEqual(actual[1]._id, 'UnitTestsAhuacatlVertex1/v2'); - assertEqual(actual[2]._id, 'UnitTestsAhuacatlVertex2/v3'); - assertEqual(actual[3]._id, 'UnitTestsAhuacatlVertex4/v8'); - - + testEdgesAnyStartExampleEdgeExample: function () { + var actual; actual = getQueryResults("FOR e IN GRAPH_EDGES('bla3', 'UnitTestsAhuacatlVertex1/v1', {direction : 'any' , edgeExamples : [{'what' : 'v2->v1'}]}) SORT e.what RETURN e.what"); assertEqual(actual, [ "v2->v1" ]); + }, + //////////////////////////////////////////////////////////////////////////////// + /// @brief checks GRAPH_NEIGHBORS() + //////////////////////////////////////////////////////////////////////////////// + testNeighborsAnyStartExampleEdgeExample: function () { + var actual; actual = getQueryResults("FOR e IN GRAPH_NEIGHBORS('bla3', 'UnitTestsAhuacatlVertex1/v1', {direction : 'any' , edgeExamples : [{'what' : 'v2->v1'}]}) SORT e.what RETURN e"); assertEqual(actual[0].path.edges[0].what, "v2->v1"); assertEqual(actual[0].vertex._key, "v2"); }, -//////////////////////////////////////////////////////////////////////////////// -/// @brief checks EDGES() -//////////////////////////////////////////////////////////////////////////////// + + //////////////////////////////////////////////////////////////////////////////// + /// @brief checks EDGES() + //////////////////////////////////////////////////////////////////////////////// testEdgesIn: function () { var actual; @@ -181,17 +322,7 @@ function ahuacatlQueryGeneralEdgesTestSuite() { actual = getQueryResults("FOR e IN GRAPH_EDGES('bla3', 'UnitTestsAhuacatlVertex3/v5', {direction : 'inbound'}) SORT e.what RETURN e.what"); assertEqual(actual, [ "v1->v5", "v2->v5", "v3->v5"]); - actual = getRawQueryResults("FOR e IN GRAPH_VERTICES('bla3', 'UnitTestsAhuacatlVertex3/v5', {direction : 'inbound'}) SORT e._id RETURN e"); - assertEqual(actual[0]._id, 'UnitTestsAhuacatlVertex3/v5'); - - actual = getRawQueryResults("FOR e IN GRAPH_VERTICES('bla3', [{hugo : true}, {heinz : 1}], {direction : 'inbound'}) SORT e._id RETURN e"); - assertEqual(actual[0]._id, 'UnitTestsAhuacatlVertex1/v1'); - assertEqual(actual[1]._id, 'UnitTestsAhuacatlVertex1/v2'); - assertEqual(actual[2]._id, 'UnitTestsAhuacatlVertex4/v8'); - assertTrue(actual.length === 3); - - - actual = getQueryResults("FOR e IN GRAPH_EDGES('bla3', 'UnitTestsAhuacatlVertex3/v5', {direction : 'inbound' ,edgeCollectionRestriction: 'UnitTestsAhuacatlEdge2'}) SORT e.what RETURN e.what"); + actual = getQueryResults("FOR e IN GRAPH_EDGES('bla3', 'UnitTestsAhuacatlVertex3/v5', {direction : 'inbound' ,edgeCollectionRestriction: ['UnitTestsAhuacatlEdge2']}) SORT e.what RETURN e.what"); assertEqual(actual, [ "v1->v5", "v2->v5", "v3->v5"]); actual = getQueryResults("FOR e IN GRAPH_EDGES('bla3', 'UnitTestsAhuacatlVertex3/v5', {direction : 'inbound' , edgeExamples : [{'what' : 'v2->v5'}]}) SORT e.what RETURN e.what"); @@ -203,9 +334,9 @@ function ahuacatlQueryGeneralEdgesTestSuite() { }, -//////////////////////////////////////////////////////////////////////////////// -/// @brief checks EDGES() -//////////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////////////////////////////////////////////// + /// @brief checks EDGES() + //////////////////////////////////////////////////////////////////////////////// testEdgesOut: function () { var actual; @@ -256,9 +387,9 @@ function ahuacatlQueryGeneralEdgesTestSuite() { assertEqual(actual[2].vertex._key, "v5"); assertEqual(actual[3].vertex._key, "v5"); }, -//////////////////////////////////////////////////////////////////////////////// -/// @brief checks EDGES() exceptions -//////////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////////////////////////////////////////////// + /// @brief checks EDGES() exceptions + //////////////////////////////////////////////////////////////////////////////// testEdgesExceptions: function () { return undefined; @@ -274,9 +405,9 @@ function ahuacatlQueryGeneralEdgesTestSuite() { function ahuacatlQueryGeneralCommonTestSuite() { return { -//////////////////////////////////////////////////////////////////////////////// -/// @brief set up -//////////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////////////////////////////////////////////// + /// @brief set up + //////////////////////////////////////////////////////////////////////////////// setUp: function () { db._drop("UnitTestsAhuacatlVertex1"); @@ -326,9 +457,9 @@ function ahuacatlQueryGeneralCommonTestSuite() { ); }, -//////////////////////////////////////////////////////////////////////////////// -/// @brief tear down -//////////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////////////////////////////////////////////// + /// @brief tear down + //////////////////////////////////////////////////////////////////////////////// tearDown: function () { db._drop("UnitTestsAhuacatlVertex1"); @@ -340,20 +471,20 @@ function ahuacatlQueryGeneralCommonTestSuite() { } }, -//////////////////////////////////////////////////////////////////////////////// -/// @brief checks GRAPH_COMMON_NEIGHBORS() and GRAPH_COMMON_PROPERTIES() -//////////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////////////////////////////////////////////// + /// @brief checks GRAPH_COMMON_NEIGHBORS() and GRAPH_COMMON_PROPERTIES() + //////////////////////////////////////////////////////////////////////////////// - testEdgesAny: function () { + testCommonNeighbors: function () { var actual = getQueryResults("FOR e IN GRAPH_COMMON_NEIGHBORS('bla3', 'UnitTestsAhuacatlVertex1/v3' , 'UnitTestsAhuacatlVertex2/v6', {direction : 'any'}) SORT ATTRIBUTES(e)[0] RETURN e"); assertEqual(actual[0]["UnitTestsAhuacatlVertex1/v3"]["UnitTestsAhuacatlVertex2/v6"][0]._id, "UnitTestsAhuacatlVertex1/v2"); assertEqual(actual[0]["UnitTestsAhuacatlVertex1/v3"]["UnitTestsAhuacatlVertex2/v6"][1]._id, "UnitTestsAhuacatlVertex2/v7"); }, -//////////////////////////////////////////////////////////////////////////////// -/// @brief checks GRAPH_COMMON_NEIGHBORS() -//////////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////////////////////////////////////////////// + /// @brief checks GRAPH_COMMON_NEIGHBORS() + //////////////////////////////////////////////////////////////////////////////// testCommonNeighborsIn: function () { var actual = getQueryResults("FOR e IN GRAPH_COMMON_NEIGHBORS('bla3', {} , {}, {direction : 'inbound'}, {direction : 'inbound'}) SORT TO_STRING(ATTRIBUTES(e)) RETURN e"); @@ -371,9 +502,9 @@ function ahuacatlQueryGeneralCommonTestSuite() { assertEqual(actual[4]["UnitTestsAhuacatlVertex2/v8"]["UnitTestsAhuacatlVertex2/v7"][0]._id, "UnitTestsAhuacatlVertex1/v3"); }, -//////////////////////////////////////////////////////////////////////////////// -/// @brief checks GRAPH_COMMON_NEIGHBORS() -//////////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////////////////////////////////////////////// + /// @brief checks GRAPH_COMMON_NEIGHBORS() + //////////////////////////////////////////////////////////////////////////////// testCommonNeighborsOut: function () { var actual = getQueryResults("FOR e IN GRAPH_COMMON_NEIGHBORS('bla3', { hugo : true } , {heinz : 1}, " + @@ -392,9 +523,9 @@ function ahuacatlQueryGeneralCommonTestSuite() { }, -//////////////////////////////////////////////////////////////////////////////// -/// @brief checks GRAPH_COMMON_NEIGHBORS() -//////////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////////////////////////////////////////////// + /// @brief checks GRAPH_COMMON_NEIGHBORS() + //////////////////////////////////////////////////////////////////////////////// testCommonNeighborsMixedOptions: function () { var actual = getQueryResults("FOR e IN GRAPH_COMMON_NEIGHBORS('bla3', {} , {}, " + @@ -417,9 +548,9 @@ function ahuacatlQueryGeneralCommonTestSuite() { }, -//////////////////////////////////////////////////////////////////////////////// -/// @brief checks GRAPH_COMMON_PROPERTIES() -//////////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////////////////////////////////////////////// + /// @brief checks GRAPH_COMMON_PROPERTIES() + //////////////////////////////////////////////////////////////////////////////// testCommonProperties: function () { var actual = getQueryResults("FOR e IN GRAPH_COMMON_PROPERTIES('bla3', { } , {}, {}) SORT ATTRIBUTES(e)[0] RETURN e"); @@ -468,9 +599,9 @@ function ahuacatlQueryGeneralCommonTestSuite() { function ahuacatlQueryGeneralPathsTestSuite() { return { -//////////////////////////////////////////////////////////////////////////////// -/// @brief set up -//////////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////////////////////////////////////////////// + /// @brief set up + //////////////////////////////////////////////////////////////////////////////// setUp: function () { db._drop("UnitTestsAhuacatlVertex1"); @@ -525,9 +656,9 @@ function ahuacatlQueryGeneralPathsTestSuite() { makeEdge(v3._id, v5._id, g[e2]); }, -//////////////////////////////////////////////////////////////////////////////// -/// @brief tear down -//////////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////////////////////////////////////////////// + /// @brief tear down + //////////////////////////////////////////////////////////////////////////////// tearDown: function () { db._drop("UnitTestsAhuacatlVertex1"); @@ -539,15 +670,15 @@ function ahuacatlQueryGeneralPathsTestSuite() { db._collection("_graphs").remove("_graphs/bla3"); }, -//////////////////////////////////////////////////////////////////////////////// -/// @brief checks GRAPH_PATHS() -//////////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////////////////////////////////////////////// + /// @brief checks GRAPH_PATHS() + //////////////////////////////////////////////////////////////////////////////// testPaths: function () { var actual; actual = getQueryResults( - "FOR e IN GRAPH_PATHS('bla3') " + "FOR e IN GRAPH_PATHS('bla3') " + "LET length = LENGTH(e.edges) " + "SORT e.source._key, e.destination._key, length " + "RETURN {src: e.source._key, dest: e.destination._key, edges: e.edges, length: length}" @@ -556,80 +687,80 @@ function ahuacatlQueryGeneralPathsTestSuite() { actual.forEach(function (p) { switch (p.src) { case "v1": - switch (p.dest) { - case "v1": - assertEqual(p.length, 0); - break; - case "v2": - assertEqual(p.length, 1); - assertEqual(p.edges[0].what, "v1->v2"); - break; - case "v5": - if (p.length === 1) { - assertEqual(p.edges[0].what, "v1->v5"); + switch (p.dest) { + case "v1": + assertEqual(p.length, 0); + break; + case "v2": + assertEqual(p.length, 1); + assertEqual(p.edges[0].what, "v1->v2"); + break; + case "v5": + if (p.length === 1) { + assertEqual(p.edges[0].what, "v1->v5"); - } else { - assertEqual(p.length, 2); - assertEqual(p.edges[0].what, "v1->v2"); - assertEqual(p.edges[1].what, "v2->v5"); - } - break; - default: - fail("Found unknown path"); + } else { + assertEqual(p.length, 2); + assertEqual(p.edges[0].what, "v1->v2"); + assertEqual(p.edges[1].what, "v2->v5"); } break; - case "v2": - switch (p.dest) { - case "v2": - assertEqual(p.length, 0); - break; - case "v1": - assertEqual(p.length, 1); - assertEqual(p.edges[0].what, "v2->v1"); - break; - case "v5": - if (p.length === 1) { - assertEqual(p.edges[0].what, "v2->v5"); - - } else { - assertEqual(p.length, 2); - assertEqual(p.edges[0].what, "v2->v1"); - assertEqual(p.edges[1].what, "v1->v5"); - } - break; - default: - fail("Found unknown path"); - } - break; - case "v3": - switch (p.dest) { - case "v3": - assertEqual(p.length, 0); - break; - case "v5": - assertEqual(p.length, 1); - assertEqual(p.edges[0].what, "v3->v5"); - break; - default: - fail("Found unknown path"); - } - break; - case "v4": - switch (p.dest) { - case "v4": - assertEqual(p.length, 0); - break; - case "v7": - assertEqual(p.length, 1); - assertEqual(p.edges[0].what, "v4->v7"); - break; - default: - fail("Found unknown path"); - } - break; - - default: + default: fail("Found unknown path"); + } + break; + case "v2": + switch (p.dest) { + case "v2": + assertEqual(p.length, 0); + break; + case "v1": + assertEqual(p.length, 1); + assertEqual(p.edges[0].what, "v2->v1"); + break; + case "v5": + if (p.length === 1) { + assertEqual(p.edges[0].what, "v2->v5"); + + } else { + assertEqual(p.length, 2); + assertEqual(p.edges[0].what, "v2->v1"); + assertEqual(p.edges[1].what, "v1->v5"); + } + break; + default: + fail("Found unknown path"); + } + break; + case "v3": + switch (p.dest) { + case "v3": + assertEqual(p.length, 0); + break; + case "v5": + assertEqual(p.length, 1); + assertEqual(p.edges[0].what, "v3->v5"); + break; + default: + fail("Found unknown path"); + } + break; + case "v4": + switch (p.dest) { + case "v4": + assertEqual(p.length, 0); + break; + case "v7": + assertEqual(p.length, 1); + assertEqual(p.edges[0].what, "v4->v7"); + break; + default: + fail("Found unknown path"); + } + break; + + default: + fail("Found unknown path"); } }); }, @@ -698,9 +829,9 @@ function ahuacatlQueryGeneralPathsTestSuite() { function ahuacatlQueryGeneralTraversalTestSuite() { return { -//////////////////////////////////////////////////////////////////////////////// -/// @brief set up -//////////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////////////////////////////////////////////// + /// @brief set up + //////////////////////////////////////////////////////////////////////////////// setUp: function () { db._drop("UnitTests_Berliner"); @@ -756,9 +887,9 @@ function ahuacatlQueryGeneralTraversalTestSuite() { makeEdge(Emil._id, Fritz._id, g[KenntAnderen], 0.2); }, -//////////////////////////////////////////////////////////////////////////////// -/// @brief tear down -//////////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////////////////////////////////////////////// + /// @brief tear down + //////////////////////////////////////////////////////////////////////////////// tearDown: function () { db._drop("UnitTests_Berliner"); @@ -770,9 +901,9 @@ function ahuacatlQueryGeneralTraversalTestSuite() { db._collection("_graphs").remove("_graphs/werKenntWen"); }, -//////////////////////////////////////////////////////////////////////////////// -/// @brief checks GRAPH_TRAVERSAL() -//////////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////////////////////////////////////////////// + /// @brief checks GRAPH_TRAVERSAL() + //////////////////////////////////////////////////////////////////////////////// testGRAPH_TRAVERSALs: function () { var actual, result = []; @@ -977,682 +1108,682 @@ function ahuacatlQueryGeneralTraversalTestSuite() { 0 ] ] - ); + ); - actual = getQueryResults("FOR e IN GRAPH_SHORTEST_PATH('werKenntWen', {}, " + - "{}, {direction : 'inbound', algorithm : 'djikstra'}) SORT e.startVertex, e.vertex._id RETURN [e.startVertex, e.vertex._id, e.distance]"); - assertEqual(actual, [ - [ - "UnitTests_Berliner/Anton", - "UnitTests_Berliner/Anton", - 0 - ], - [ - "UnitTests_Berliner/Anton", - "UnitTests_Berliner/Berta", - 1 - ], - [ - "UnitTests_Berliner/Anton", - "UnitTests_Hamburger/Caesar", - 1 - ], - [ - "UnitTests_Berliner/Berta", - "UnitTests_Berliner/Berta", - 0 - ], - [ - "UnitTests_Berliner/Berta", - "UnitTests_Hamburger/Caesar", - 1 - ], - [ - "UnitTests_Frankfurter/Emil", - "UnitTests_Berliner/Berta", - 3 - ], - [ - "UnitTests_Frankfurter/Emil", - "UnitTests_Frankfurter/Emil", - 0 - ], - [ - "UnitTests_Frankfurter/Emil", - "UnitTests_Hamburger/Caesar", - 4 - ], - [ - "UnitTests_Frankfurter/Emil", - "UnitTests_Hamburger/Dieter", - 1 - ], - [ - "UnitTests_Frankfurter/Emil", - "UnitTests_Leipziger/Gerda", - 2 - ], - [ - "UnitTests_Frankfurter/Fritz", - "UnitTests_Berliner/Berta", - 4 - ], - [ - "UnitTests_Frankfurter/Fritz", - "UnitTests_Frankfurter/Emil", - 1 - ], - [ - "UnitTests_Frankfurter/Fritz", - "UnitTests_Frankfurter/Fritz", - 0 - ], - [ - "UnitTests_Frankfurter/Fritz", - "UnitTests_Hamburger/Caesar", - 5 - ], - [ - "UnitTests_Frankfurter/Fritz", - "UnitTests_Hamburger/Dieter", - 2 - ], - [ - "UnitTests_Frankfurter/Fritz", - "UnitTests_Leipziger/Gerda", - 3 - ], - [ - "UnitTests_Hamburger/Caesar", - "UnitTests_Hamburger/Caesar", - 0 - ], - [ - "UnitTests_Hamburger/Dieter", - "UnitTests_Berliner/Berta", - 2 - ], - [ - "UnitTests_Hamburger/Dieter", - "UnitTests_Hamburger/Caesar", - 3 - ], - [ - "UnitTests_Hamburger/Dieter", - "UnitTests_Hamburger/Dieter", - 0 - ], - [ - "UnitTests_Hamburger/Dieter", - "UnitTests_Leipziger/Gerda", - 1 - ], - [ - "UnitTests_Leipziger/Gerda", - "UnitTests_Berliner/Berta", - 1 - ], - [ - "UnitTests_Leipziger/Gerda", - "UnitTests_Hamburger/Caesar", - 2 - ], - [ - "UnitTests_Leipziger/Gerda", - "UnitTests_Leipziger/Gerda", - 0 - ] - ] - ); - - actual = getQueryResults("FOR e IN GRAPH_SHORTEST_PATH('werKenntWen', {}, " + - "{_id : 'UnitTests_Berliner/Berta'}, {direction : 'inbound', algorithm : 'djikstra'}) SORT e.startVertex, e.vertex._id RETURN [e.startVertex, e.vertex._id, e.distance]"); - assertEqual(actual,[ - [ - "UnitTests_Berliner/Anton", - "UnitTests_Berliner/Berta", - 1 - ], - [ - "UnitTests_Berliner/Berta", - "UnitTests_Berliner/Berta", - 0 - ], - [ - "UnitTests_Frankfurter/Emil", - "UnitTests_Berliner/Berta", - 3 - ], - [ - "UnitTests_Frankfurter/Fritz", - "UnitTests_Berliner/Berta", - 4 - ], - [ - "UnitTests_Hamburger/Dieter", - "UnitTests_Berliner/Berta", - 2 - ], - [ - "UnitTests_Leipziger/Gerda", - "UnitTests_Berliner/Berta", - 1 - ] + actual = getQueryResults("FOR e IN GRAPH_SHORTEST_PATH('werKenntWen', {}, " + + "{}, {direction : 'inbound', algorithm : 'djikstra'}) SORT e.startVertex, e.vertex._id RETURN [e.startVertex, e.vertex._id, e.distance]"); + assertEqual(actual, [ + [ + "UnitTests_Berliner/Anton", + "UnitTests_Berliner/Anton", + 0 + ], + [ + "UnitTests_Berliner/Anton", + "UnitTests_Berliner/Berta", + 1 + ], + [ + "UnitTests_Berliner/Anton", + "UnitTests_Hamburger/Caesar", + 1 + ], + [ + "UnitTests_Berliner/Berta", + "UnitTests_Berliner/Berta", + 0 + ], + [ + "UnitTests_Berliner/Berta", + "UnitTests_Hamburger/Caesar", + 1 + ], + [ + "UnitTests_Frankfurter/Emil", + "UnitTests_Berliner/Berta", + 3 + ], + [ + "UnitTests_Frankfurter/Emil", + "UnitTests_Frankfurter/Emil", + 0 + ], + [ + "UnitTests_Frankfurter/Emil", + "UnitTests_Hamburger/Caesar", + 4 + ], + [ + "UnitTests_Frankfurter/Emil", + "UnitTests_Hamburger/Dieter", + 1 + ], + [ + "UnitTests_Frankfurter/Emil", + "UnitTests_Leipziger/Gerda", + 2 + ], + [ + "UnitTests_Frankfurter/Fritz", + "UnitTests_Berliner/Berta", + 4 + ], + [ + "UnitTests_Frankfurter/Fritz", + "UnitTests_Frankfurter/Emil", + 1 + ], + [ + "UnitTests_Frankfurter/Fritz", + "UnitTests_Frankfurter/Fritz", + 0 + ], + [ + "UnitTests_Frankfurter/Fritz", + "UnitTests_Hamburger/Caesar", + 5 + ], + [ + "UnitTests_Frankfurter/Fritz", + "UnitTests_Hamburger/Dieter", + 2 + ], + [ + "UnitTests_Frankfurter/Fritz", + "UnitTests_Leipziger/Gerda", + 3 + ], + [ + "UnitTests_Hamburger/Caesar", + "UnitTests_Hamburger/Caesar", + 0 + ], + [ + "UnitTests_Hamburger/Dieter", + "UnitTests_Berliner/Berta", + 2 + ], + [ + "UnitTests_Hamburger/Dieter", + "UnitTests_Hamburger/Caesar", + 3 + ], + [ + "UnitTests_Hamburger/Dieter", + "UnitTests_Hamburger/Dieter", + 0 + ], + [ + "UnitTests_Hamburger/Dieter", + "UnitTests_Leipziger/Gerda", + 1 + ], + [ + "UnitTests_Leipziger/Gerda", + "UnitTests_Berliner/Berta", + 1 + ], + [ + "UnitTests_Leipziger/Gerda", + "UnitTests_Hamburger/Caesar", + 2 + ], + [ + "UnitTests_Leipziger/Gerda", + "UnitTests_Leipziger/Gerda", + 0 ] - ); - - - actual = getQueryResults("FOR e IN GRAPH_SHORTEST_PATH('werKenntWen', 'UnitTests_Hamburger/Caesar', " + - " 'UnitTests_Berliner/Anton', {direction : 'outbound', weight: 'entfernung', algorithm : 'Floyd-Warshall'}) SORT e.startVertex, e.vertex._id RETURN e.paths[0].vertices"); - assertEqual(actual[0].length, 3); - - actual = getQueryResults("FOR e IN GRAPH_SHORTEST_PATH('werKenntWen', 'UnitTests_Hamburger/Caesar', " + - " 'UnitTests_Berliner/Anton', {direction : 'outbound', algorithm : 'Floyd-Warshall'}) SORT e.startVertex, e.vertex._id RETURN e.paths[0].vertices"); - assertEqual(actual[0].length, 2); - - actual = getQueryResults("FOR e IN GRAPH_DISTANCE_TO('werKenntWen', 'UnitTests_Hamburger/Caesar', 'UnitTests_Frankfurter/Emil', " + - "{direction : 'outbound', weight: 'entfernung', defaultWeight : 80, algorithm : 'Floyd-Warshall'}) RETURN [e.startVertex, e.vertex._id, e.distance]"); - assertEqual(actual, - [ - [ - "UnitTests_Hamburger/Caesar", - "UnitTests_Frankfurter/Emil", - 830.1 - ] - ] - ); - - - }, - - testGRAPH_SHORTEST_PATH_WITH_DIJSKTRA: function () { - var actual; - - actual = getQueryResults("FOR e IN GRAPH_SHORTEST_PATH('werKenntWen', 'UnitTests_Hamburger/Caesar', " + - " 'UnitTests_Frankfurter/Emil', {direction : 'outbound', algorithm : 'dijkstra'}) SORT e.startVertex, e.vertex._id RETURN [e.startVertex, e.vertex._id]"); - assertEqual(actual, - [ - [ - "UnitTests_Hamburger/Caesar", - "UnitTests_Frankfurter/Emil" - ] - ] - ); - - actual = getQueryResults("FOR e IN GRAPH_SHORTEST_PATH('werKenntWen', 'UnitTests_Hamburger/Caesar', " + - " 'UnitTests_Berliner/Anton', {direction : 'outbound', weight: 'entfernung', algorithm : 'dijkstra'}) SORT e.startVertex, e.vertex._id RETURN e.paths[0].vertices"); - assertEqual(actual[0].length, 3); - - actual = getQueryResults("FOR e IN GRAPH_SHORTEST_PATH('werKenntWen', 'UnitTests_Hamburger/Caesar', " + - " 'UnitTests_Berliner/Anton', {direction : 'outbound', algorithm : 'dijkstra'}) SORT e.startVertex, e.vertex._id RETURN e.path.vertices"); - assertEqual(actual[0].length, 2); - - actual = getQueryResults("FOR e IN GRAPH_DISTANCE_TO('werKenntWen', 'UnitTests_Hamburger/Caesar', 'UnitTests_Frankfurter/Emil', " + - "{direction : 'outbound', weight: 'entfernung', defaultWeight : 80, algorithm : 'dijkstra'}) RETURN [e.startVertex, e.vertex._id, e.distance]"); - assertEqual(actual, - [ - [ - "UnitTests_Hamburger/Caesar", - "UnitTests_Frankfurter/Emil", - 830.1 - ] - ] - ); - - - }, - - testGRAPH_CLOSENESS: function () { - var actual; - actual = getQueryResults("RETURN GRAPH_CLOSENESS('werKenntWen', {algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0]["UnitTests_Berliner/Anton"].toFixed(2), 0.69); - assertEqual(actual[0]["UnitTests_Berliner/Berta"].toFixed(2), 0.92); - assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(2), 0.73); - assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"].toFixed(2), 0.55); - assertEqual(actual[0]["UnitTests_Hamburger/Caesar"].toFixed(2), 0.69); - assertEqual(actual[0]["UnitTests_Hamburger/Dieter"].toFixed(2), 0.92); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 1); - - - actual = getQueryResults("RETURN GRAPH_CLOSENESS('werKenntWen', {weight : 'entfernung', defaultWeight : 80, algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0]["UnitTests_Berliner/Anton"].toFixed(2), 0.89); - assertEqual(actual[0]["UnitTests_Berliner/Berta"].toFixed(2), 0.89); - assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(2), 0.63); - assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"].toFixed(2), 0.63); - assertEqual(actual[0]["UnitTests_Hamburger/Caesar"].toFixed(2), 0.54); - assertEqual(actual[0]["UnitTests_Hamburger/Dieter"].toFixed(2), 0.95); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 1); - - - actual = getQueryResults("RETURN GRAPH_ABSOLUTE_CLOSENESS('werKenntWen', {gender: 'male'}, {weight : 'entfernung', defaultWeight : 80})"); - assertEqual(actual[0]["UnitTests_Berliner/Anton"].toFixed(1), 1890.9); - assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(1), 2670.4); - assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"].toFixed(1), 2671.4); - assertEqual(actual[0]["UnitTests_Hamburger/Caesar"].toFixed(1), 3140.9); - assertEqual(actual[0]["UnitTests_Hamburger/Dieter"].toFixed(1), 1770.4); - }, - - - testGRAPH_CLOSENESS_OUTBOUND: function () { - var actual; - actual = getQueryResults("RETURN GRAPH_CLOSENESS('werKenntWen', {direction : 'outbound', algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0]["UnitTests_Berliner/Anton"], 0); - assertEqual(actual[0]["UnitTests_Berliner/Berta"].toFixed(2), 0.94); - assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(1), 0.3); - assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 0); - assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 1); - assertEqual(actual[0]["UnitTests_Hamburger/Dieter"].toFixed(2), 0.46); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"].toFixed(2), 0.56); - - - actual = getQueryResults("RETURN GRAPH_CLOSENESS('werKenntWen', {weight : 'entfernung', defaultWeight : 80, direction : 'outbound', algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0]["UnitTests_Berliner/Anton"], 0); - assertEqual(actual[0]["UnitTests_Berliner/Berta"], 1); - assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(1), 0.5); - assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 0); - assertEqual(actual[0]["UnitTests_Hamburger/Caesar"].toFixed(3), 0.001); - assertEqual(actual[0]["UnitTests_Hamburger/Dieter"].toFixed(3), 0.001); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"].toFixed(3), 0.002); - }, - - testGRAPH_CLOSENESS_INBOUND: function () { - var actual; - actual = getQueryResults("RETURN GRAPH_CLOSENESS('werKenntWen', {direction : 'inbound', algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0]["UnitTests_Berliner/Anton"].toFixed(2), 0.88); - assertEqual(actual[0]["UnitTests_Berliner/Berta"].toFixed(2), 0.44); - assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(2), 0.91); - assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 1); - assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 0); - assertEqual(actual[0]["UnitTests_Hamburger/Dieter"].toFixed(1), 0.8); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"].toFixed(2), 0.66); - - - actual = getQueryResults("RETURN GRAPH_CLOSENESS('werKenntWen', {weight : 'entfernung', defaultWeight : 80, direction : 'inbound', algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0]["UnitTests_Berliner/Anton"], 1); - assertEqual(actual[0]["UnitTests_Berliner/Berta"].toFixed(4), 0.0004); - assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(4), 0.0009); - assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"].toFixed(1), 0.5); - assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 0); - assertEqual(actual[0]["UnitTests_Hamburger/Dieter"].toFixed(3), 0.002); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"].toFixed(4), 0.0007); - }, - - - testGRAPH_ECCENTRICITY: function () { - var actual; - actual = getQueryResults("RETURN GRAPH_ECCENTRICITY('werKenntWen', {algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0]["UnitTests_Berliner/Anton"].toFixed(1), 0.6); - assertEqual(actual[0]["UnitTests_Berliner/Berta"].toFixed(2), 0.75); - assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(2), 0.75); - assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"].toFixed(1), 0.6); - assertEqual(actual[0]["UnitTests_Hamburger/Caesar"].toFixed(1), 0.6); - assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 1); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 1); - - actual = getQueryResults("RETURN GRAPH_ECCENTRICITY('werKenntWen', {algorithm : 'Floyd-Warshall', direction : 'inbound'})"); - assertEqual(actual[0]["UnitTests_Berliner/Anton"], 1); - assertEqual(actual[0]["UnitTests_Berliner/Berta"], 1); - assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(2), 0.25); - assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"].toFixed(1), 0.2); - assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 0); - assertEqual(actual[0]["UnitTests_Hamburger/Dieter"].toFixed(2), 0.33); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"].toFixed(1), 0.5); - - - actual = getQueryResults("RETURN GRAPH_ABSOLUTE_ECCENTRICITY('werKenntWen', {gender : 'female'}, {algorithm : 'Floyd-Warshall', direction : 'inbound'})"); - assertEqual(actual[0]["UnitTests_Berliner/Berta"], 1); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 2); - - - actual = getQueryResults("RETURN GRAPH_ECCENTRICITY('werKenntWen', {weight : 'entfernung', defaultWeight : 80, algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0]["UnitTests_Berliner/Anton"].toFixed(2), 0.78); - assertEqual(actual[0]["UnitTests_Berliner/Berta"].toFixed(2), 0.78); - assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(2), 0.54); - assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"].toFixed(2), 0.54); - assertEqual(actual[0]["UnitTests_Hamburger/Caesar"].toFixed(2), 0.54); - assertEqual(actual[0]["UnitTests_Hamburger/Dieter"].toFixed(2), 0.85); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 1); - - - }, - - testGRAPH_BETWEENNESS: function () { - var actual; - - actual = getQueryResults("RETURN GRAPH_ABSOLUTE_BETWEENNESS('werKenntWen', {algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0]["UnitTests_Berliner/Anton"], 0); - assertEqual(actual[0]["UnitTests_Berliner/Berta"], 16); - assertEqual(actual[0]["UnitTests_Frankfurter/Emil"], 10); - assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 0); - assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 0); - assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 16); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 18); - - - actual = getQueryResults("RETURN GRAPH_BETWEENNESS('werKenntWen', {algorithm : 'Floyd-Warshall'})"); - - assertEqual(actual[0]["UnitTests_Berliner/Anton"], 0); - assertEqual(actual[0]["UnitTests_Berliner/Berta"].toFixed(2), 0.89); - assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(2), 0.56); - assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 0); - assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 0); - assertEqual(actual[0]["UnitTests_Hamburger/Dieter"].toFixed(2), 0.89); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 1); - - - actual = getQueryResults("RETURN GRAPH_ABSOLUTE_BETWEENNESS('werKenntWen', {algorithm : 'Floyd-Warshall', direction : 'inbound'})"); - assertEqual(actual[0]["UnitTests_Berliner/Anton"], 0); - assertEqual(actual[0]["UnitTests_Berliner/Berta"], 4); - assertEqual(actual[0]["UnitTests_Frankfurter/Emil"], 4); - assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 0); - assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 0); - assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 6); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 6); - - actual = getQueryResults("RETURN GRAPH_BETWEENNESS('werKenntWen', {algorithm : 'Floyd-Warshall', direction : 'inbound'})"); - assertEqual(actual[0]["UnitTests_Berliner/Anton"], 0); - assertEqual(actual[0]["UnitTests_Berliner/Berta"].toFixed(2), 0.67); - assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(2), 0.67); - assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 0); - assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 0); - assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 1); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 1); - - - - actual = getQueryResults("RETURN GRAPH_BETWEENNESS('werKenntWen', {weight : 'entfernung', defaultWeight : 80, algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0]["UnitTests_Berliner/Anton"], 0); - assertEqual(actual[0]["UnitTests_Berliner/Berta"], 1); - assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(2), 0.56); - assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 0); - assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 0); - assertEqual(actual[0]["UnitTests_Hamburger/Dieter"].toFixed(2), 0.89); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 1); - - - }, - - testGRAPH_DIAMETER_AND_RADIUS: function () { - var actual; - actual = getQueryResults("RETURN GRAPH_RADIUS('werKenntWen', {algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0], 3); - - actual = getQueryResults("RETURN GRAPH_RADIUS('werKenntWen', {weight : 'entfernung', defaultWeight : 80, algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0].toFixed(1), 450.1); - - actual = getQueryResults("RETURN GRAPH_DIAMETER('werKenntWen', {algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0], 5); - - actual = getQueryResults("RETURN GRAPH_DIAMETER('werKenntWen', {weight : 'entfernung', defaultWeight : 80, algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0].toFixed(1), 830.3); - - - - actual = getQueryResults("RETURN GRAPH_RADIUS('werKenntWen', {direction : 'inbound', algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0], 1); - - actual = getQueryResults("RETURN GRAPH_RADIUS('werKenntWen', {direction : 'inbound', weight : 'entfernung', defaultWeight : 80, algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0].toFixed(1), 250.1); - - actual = getQueryResults("RETURN GRAPH_DIAMETER('werKenntWen', {direction : 'inbound', algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0], 5); - - actual = getQueryResults("RETURN GRAPH_DIAMETER('werKenntWen', {direction : 'inbound', weight : 'entfernung', defaultWeight : 80, algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0].toFixed(1), 830.3); - - actual = getQueryResults("RETURN GRAPH_RADIUS('werKenntWen', {direction : 'outbound', algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0], 1); - - actual = getQueryResults("RETURN GRAPH_RADIUS('werKenntWen', {direction : 'outbound', weight : 'entfernung', defaultWeight : 80, algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0].toFixed(1), 0.2); - - actual = getQueryResults("RETURN GRAPH_DIAMETER('werKenntWen', {direction : 'outbound', algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0], 5); - - actual = getQueryResults("RETURN GRAPH_DIAMETER('werKenntWen', {direction : 'outbound', weight : 'entfernung', defaultWeight : 80, algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0].toFixed(1), 830.3); - - - - }, - - testGRAPH_SHORTEST_PATHWithExamples: function () { - var actual; - - actual = getQueryResults("FOR e IN GRAPH_SHORTEST_PATH('werKenntWen', {gender : 'female'}, {gender : 'male', age : 30}, " + - "{direction : 'any', algorithm : 'Floyd-Warshall'}) SORT e.startVertex, e.vertex._id RETURN [e.startVertex, e.vertex._id]"); - assertEqual(actual, [ - [ - "UnitTests_Berliner/Berta", - "UnitTests_Frankfurter/Fritz" - ], - [ - "UnitTests_Berliner/Berta", - "UnitTests_Hamburger/Caesar" - ], - [ - "UnitTests_Leipziger/Gerda", - "UnitTests_Frankfurter/Fritz" - ], - [ - "UnitTests_Leipziger/Gerda", - "UnitTests_Hamburger/Caesar" - ] + ] + ); + + actual = getQueryResults("FOR e IN GRAPH_SHORTEST_PATH('werKenntWen', {}, " + + "{_id : 'UnitTests_Berliner/Berta'}, {direction : 'inbound', algorithm : 'djikstra'}) SORT e.startVertex, e.vertex._id RETURN [e.startVertex, e.vertex._id, e.distance]"); + assertEqual(actual,[ + [ + "UnitTests_Berliner/Anton", + "UnitTests_Berliner/Berta", + 1 + ], + [ + "UnitTests_Berliner/Berta", + "UnitTests_Berliner/Berta", + 0 + ], + [ + "UnitTests_Frankfurter/Emil", + "UnitTests_Berliner/Berta", + 3 + ], + [ + "UnitTests_Frankfurter/Fritz", + "UnitTests_Berliner/Berta", + 4 + ], + [ + "UnitTests_Hamburger/Dieter", + "UnitTests_Berliner/Berta", + 2 + ], + [ + "UnitTests_Leipziger/Gerda", + "UnitTests_Berliner/Berta", + 1 + ] + ] +); + + +actual = getQueryResults("FOR e IN GRAPH_SHORTEST_PATH('werKenntWen', 'UnitTests_Hamburger/Caesar', " + + " 'UnitTests_Berliner/Anton', {direction : 'outbound', weight: 'entfernung', algorithm : 'Floyd-Warshall'}) SORT e.startVertex, e.vertex._id RETURN e.paths[0].vertices"); +assertEqual(actual[0].length, 3); + +actual = getQueryResults("FOR e IN GRAPH_SHORTEST_PATH('werKenntWen', 'UnitTests_Hamburger/Caesar', " + + " 'UnitTests_Berliner/Anton', {direction : 'outbound', algorithm : 'Floyd-Warshall'}) SORT e.startVertex, e.vertex._id RETURN e.paths[0].vertices"); +assertEqual(actual[0].length, 2); + +actual = getQueryResults("FOR e IN GRAPH_DISTANCE_TO('werKenntWen', 'UnitTests_Hamburger/Caesar', 'UnitTests_Frankfurter/Emil', " + + "{direction : 'outbound', weight: 'entfernung', defaultWeight : 80, algorithm : 'Floyd-Warshall'}) RETURN [e.startVertex, e.vertex._id, e.distance]"); +assertEqual(actual, + [ + [ + "UnitTests_Hamburger/Caesar", + "UnitTests_Frankfurter/Emil", + 830.1 + ] + ] +); + + +}, + +testGRAPH_SHORTEST_PATH_WITH_DIJSKTRA: function () { + var actual; + + actual = getQueryResults("FOR e IN GRAPH_SHORTEST_PATH('werKenntWen', 'UnitTests_Hamburger/Caesar', " + + " 'UnitTests_Frankfurter/Emil', {direction : 'outbound', algorithm : 'dijkstra'}) SORT e.startVertex, e.vertex._id RETURN [e.startVertex, e.vertex._id]"); + assertEqual(actual, + [ + [ + "UnitTests_Hamburger/Caesar", + "UnitTests_Frankfurter/Emil" ] - ); + ] + ); - actual = getQueryResults("FOR e IN GRAPH_DISTANCE_TO('werKenntWen', {gender : 'female'}, {gender : 'male', age : 30}, " + - "{direction : 'any'}) SORT e.startVertex, e.vertex._id SORT e.startVertex, e.vertex._id RETURN [e.startVertex, e.vertex._id, e.distance]"); - assertEqual(actual, [ - [ - "UnitTests_Berliner/Berta", - "UnitTests_Frankfurter/Fritz", - 4 - ], - [ - "UnitTests_Berliner/Berta", - "UnitTests_Hamburger/Caesar", - 1 + actual = getQueryResults("FOR e IN GRAPH_SHORTEST_PATH('werKenntWen', 'UnitTests_Hamburger/Caesar', " + + " 'UnitTests_Berliner/Anton', {direction : 'outbound', weight: 'entfernung', algorithm : 'dijkstra'}) SORT e.startVertex, e.vertex._id RETURN e.paths[0].vertices"); + assertEqual(actual[0].length, 3); - ], - [ - "UnitTests_Leipziger/Gerda", - "UnitTests_Frankfurter/Fritz", - 3 - ], - [ - "UnitTests_Leipziger/Gerda", - "UnitTests_Hamburger/Caesar", - 2 - ] + actual = getQueryResults("FOR e IN GRAPH_SHORTEST_PATH('werKenntWen', 'UnitTests_Hamburger/Caesar', " + + " 'UnitTests_Berliner/Anton', {direction : 'outbound', algorithm : 'dijkstra'}) SORT e.startVertex, e.vertex._id RETURN e.path.vertices"); + assertEqual(actual[0].length, 2); + + actual = getQueryResults("FOR e IN GRAPH_DISTANCE_TO('werKenntWen', 'UnitTests_Hamburger/Caesar', 'UnitTests_Frankfurter/Emil', " + + "{direction : 'outbound', weight: 'entfernung', defaultWeight : 80, algorithm : 'dijkstra'}) RETURN [e.startVertex, e.vertex._id, e.distance]"); + assertEqual(actual, + [ + [ + "UnitTests_Hamburger/Caesar", + "UnitTests_Frankfurter/Emil", + 830.1 ] - ); + ] + ); - }, +}, - testGRAPH_CLOSENESS_WITH_DIJSKTRA: function () { - var actual; - actual = getQueryResults("RETURN GRAPH_CLOSENESS('werKenntWen', {algorithm : 'dijkstra'})"); - - assertEqual(actual[0]["UnitTests_Berliner/Anton"].toFixed(2), 0.69); - assertEqual(actual[0]["UnitTests_Berliner/Berta"].toFixed(2), 0.92); - assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(2), 0.73); - assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"].toFixed(2), 0.55); - assertEqual(actual[0]["UnitTests_Hamburger/Caesar"].toFixed(2), 0.69); - assertEqual(actual[0]["UnitTests_Hamburger/Dieter"].toFixed(2), 0.92); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 1); +testGRAPH_CLOSENESS: function () { + var actual; + actual = getQueryResults("RETURN GRAPH_CLOSENESS('werKenntWen', {algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0]["UnitTests_Berliner/Anton"].toFixed(2), 0.69); + assertEqual(actual[0]["UnitTests_Berliner/Berta"].toFixed(2), 0.92); + assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(2), 0.73); + assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"].toFixed(2), 0.55); + assertEqual(actual[0]["UnitTests_Hamburger/Caesar"].toFixed(2), 0.69); + assertEqual(actual[0]["UnitTests_Hamburger/Dieter"].toFixed(2), 0.92); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 1); - actual = getQueryResults("RETURN GRAPH_CLOSENESS('werKenntWen', {algorithm : 'dijkstra', weight : 'entfernung', defaultWeight : 80})"); - assertEqual(actual[0]["UnitTests_Berliner/Anton"].toFixed(2), 0.89); - assertEqual(actual[0]["UnitTests_Berliner/Berta"].toFixed(2), 0.89); - assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(2), 0.63); - assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"].toFixed(2), 0.63); - assertEqual(actual[0]["UnitTests_Hamburger/Caesar"].toFixed(2), 0.54); - assertEqual(actual[0]["UnitTests_Hamburger/Dieter"].toFixed(2), 0.95); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 1); - - }, + actual = getQueryResults("RETURN GRAPH_CLOSENESS('werKenntWen', {weight : 'entfernung', defaultWeight : 80, algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0]["UnitTests_Berliner/Anton"].toFixed(2), 0.89); + assertEqual(actual[0]["UnitTests_Berliner/Berta"].toFixed(2), 0.89); + assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(2), 0.63); + assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"].toFixed(2), 0.63); + assertEqual(actual[0]["UnitTests_Hamburger/Caesar"].toFixed(2), 0.54); + assertEqual(actual[0]["UnitTests_Hamburger/Dieter"].toFixed(2), 0.95); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 1); - testGRAPH_CLOSENESS_OUTBOUND_WITH_DIJSKTRA: function () { - var actual; - actual = getQueryResults("RETURN GRAPH_CLOSENESS('werKenntWen', {algorithm : 'dijkstra', direction : 'outbound'})"); - assertEqual(actual[0]["UnitTests_Berliner/Anton"], 0); - assertEqual(actual[0]["UnitTests_Berliner/Berta"].toFixed(2), 0.94); - assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(1), 0.3); - assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 0); - assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 1); - assertEqual(actual[0]["UnitTests_Hamburger/Dieter"].toFixed(2), 0.46); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"].toFixed(2), 0.56); + actual = getQueryResults("RETURN GRAPH_ABSOLUTE_CLOSENESS('werKenntWen', {gender: 'male'}, {weight : 'entfernung', defaultWeight : 80})"); + assertEqual(actual[0]["UnitTests_Berliner/Anton"].toFixed(1), 1890.9); + assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(1), 2670.4); + assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"].toFixed(1), 2671.4); + assertEqual(actual[0]["UnitTests_Hamburger/Caesar"].toFixed(1), 3140.9); + assertEqual(actual[0]["UnitTests_Hamburger/Dieter"].toFixed(1), 1770.4); +}, - actual = getQueryResults("RETURN GRAPH_CLOSENESS('werKenntWen', {algorithm : 'dijkstra', weight : 'entfernung', defaultWeight : 80, direction : 'outbound'})"); - assertEqual(actual[0]["UnitTests_Berliner/Anton"], 0); - assertEqual(actual[0]["UnitTests_Berliner/Berta"], 1); - assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(1), 0.5); - assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 0); - assertEqual(actual[0]["UnitTests_Hamburger/Caesar"].toFixed(3), 0.001); - assertEqual(actual[0]["UnitTests_Hamburger/Dieter"].toFixed(3), 0.001); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"].toFixed(3), 0.002); - }, +testGRAPH_CLOSENESS_OUTBOUND: function () { + var actual; + actual = getQueryResults("RETURN GRAPH_CLOSENESS('werKenntWen', {direction : 'outbound', algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0]["UnitTests_Berliner/Anton"], 0); + assertEqual(actual[0]["UnitTests_Berliner/Berta"].toFixed(2), 0.94); + assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(1), 0.3); + assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 0); + assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 1); + assertEqual(actual[0]["UnitTests_Hamburger/Dieter"].toFixed(2), 0.46); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"].toFixed(2), 0.56); - testGRAPH_CLOSENESS_INBOUND_WITH_DIJSKTRA: function () { - var actual; - actual = getQueryResults("RETURN GRAPH_CLOSENESS('werKenntWen', {algorithm : 'dijkstra', direction : 'inbound'})"); - assertEqual(actual[0]["UnitTests_Berliner/Anton"].toFixed(2), 0.88); - assertEqual(actual[0]["UnitTests_Berliner/Berta"].toFixed(2), 0.44); - assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(2), 0.91); - assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 1); - assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 0); - assertEqual(actual[0]["UnitTests_Hamburger/Dieter"].toFixed(1), 0.8); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"].toFixed(2), 0.66); + actual = getQueryResults("RETURN GRAPH_CLOSENESS('werKenntWen', {weight : 'entfernung', defaultWeight : 80, direction : 'outbound', algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0]["UnitTests_Berliner/Anton"], 0); + assertEqual(actual[0]["UnitTests_Berliner/Berta"], 1); + assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(1), 0.5); + assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 0); + assertEqual(actual[0]["UnitTests_Hamburger/Caesar"].toFixed(3), 0.001); + assertEqual(actual[0]["UnitTests_Hamburger/Dieter"].toFixed(3), 0.001); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"].toFixed(3), 0.002); +}, - actual = getQueryResults("RETURN GRAPH_CLOSENESS('werKenntWen', {algorithm : 'dijkstra', weight : 'entfernung', defaultWeight : 80, direction : 'inbound'})"); - assertEqual(actual[0]["UnitTests_Berliner/Anton"], 1); - assertEqual(actual[0]["UnitTests_Berliner/Berta"].toFixed(4), 0.0004); - assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(4), 0.0009); - assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"].toFixed(1), 0.5); - assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 0); - assertEqual(actual[0]["UnitTests_Hamburger/Dieter"].toFixed(3), 0.002); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"].toFixed(4), 0.0007); - - }, +testGRAPH_CLOSENESS_INBOUND: function () { + var actual; + actual = getQueryResults("RETURN GRAPH_CLOSENESS('werKenntWen', {direction : 'inbound', algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0]["UnitTests_Berliner/Anton"].toFixed(2), 0.88); + assertEqual(actual[0]["UnitTests_Berliner/Berta"].toFixed(2), 0.44); + assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(2), 0.91); + assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 1); + assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 0); + assertEqual(actual[0]["UnitTests_Hamburger/Dieter"].toFixed(1), 0.8); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"].toFixed(2), 0.66); - testGRAPH_ECCENTRICITY_WITH_DIJSKTRA: function () { - var actual; - actual = getQueryResults("RETURN GRAPH_ECCENTRICITY('werKenntWen', {algorithm : 'dijkstra'})"); - assertEqual(actual[0]["UnitTests_Berliner/Anton"].toFixed(1), 0.6); - assertEqual(actual[0]["UnitTests_Berliner/Berta"].toFixed(2), 0.75); - assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(2), 0.75); - assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"].toFixed(1), 0.6); - assertEqual(actual[0]["UnitTests_Hamburger/Caesar"].toFixed(1), 0.6); - assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 1); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 1); + actual = getQueryResults("RETURN GRAPH_CLOSENESS('werKenntWen', {weight : 'entfernung', defaultWeight : 80, direction : 'inbound', algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0]["UnitTests_Berliner/Anton"], 1); + assertEqual(actual[0]["UnitTests_Berliner/Berta"].toFixed(4), 0.0004); + assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(4), 0.0009); + assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"].toFixed(1), 0.5); + assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 0); + assertEqual(actual[0]["UnitTests_Hamburger/Dieter"].toFixed(3), 0.002); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"].toFixed(4), 0.0007); +}, - actual = getQueryResults("RETURN GRAPH_ECCENTRICITY('werKenntWen')"); - assertEqual(actual[0]["UnitTests_Berliner/Anton"].toFixed(1), 0.6); - assertEqual(actual[0]["UnitTests_Berliner/Berta"].toFixed(2), 0.75); - assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(2), 0.75); - assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"].toFixed(1), 0.6); - assertEqual(actual[0]["UnitTests_Hamburger/Caesar"].toFixed(1), 0.6); - assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 1); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 1); +testGRAPH_ECCENTRICITY: function () { + var actual; + actual = getQueryResults("RETURN GRAPH_ECCENTRICITY('werKenntWen', {algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0]["UnitTests_Berliner/Anton"].toFixed(1), 0.6); + assertEqual(actual[0]["UnitTests_Berliner/Berta"].toFixed(2), 0.75); + assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(2), 0.75); + assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"].toFixed(1), 0.6); + assertEqual(actual[0]["UnitTests_Hamburger/Caesar"].toFixed(1), 0.6); + assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 1); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 1); + + actual = getQueryResults("RETURN GRAPH_ECCENTRICITY('werKenntWen', {algorithm : 'Floyd-Warshall', direction : 'inbound'})"); + assertEqual(actual[0]["UnitTests_Berliner/Anton"], 1); + assertEqual(actual[0]["UnitTests_Berliner/Berta"], 1); + assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(2), 0.25); + assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"].toFixed(1), 0.2); + assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 0); + assertEqual(actual[0]["UnitTests_Hamburger/Dieter"].toFixed(2), 0.33); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"].toFixed(1), 0.5); - actual = getQueryResults("RETURN GRAPH_ECCENTRICITY('werKenntWen', {algorithm : 'dijkstra', direction : 'inbound'})"); - assertEqual(actual[0]["UnitTests_Berliner/Anton"], 1); - assertEqual(actual[0]["UnitTests_Berliner/Berta"], 1); - assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(2), 0.25); - assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"].toFixed(1), 0.2); - assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 0); - assertEqual(actual[0]["UnitTests_Hamburger/Dieter"].toFixed(2), 0.33); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"].toFixed(1), 0.5); - - actual = getQueryResults("RETURN GRAPH_ECCENTRICITY('werKenntWen', {algorithm : 'dijkstra', weight : 'entfernung', defaultWeight : 80})"); - assertEqual(actual[0]["UnitTests_Berliner/Anton"].toFixed(2), 0.78); - assertEqual(actual[0]["UnitTests_Berliner/Berta"].toFixed(2), 0.78); - assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(2), 0.54); - assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"].toFixed(2), 0.54); - assertEqual(actual[0]["UnitTests_Hamburger/Caesar"].toFixed(2), 0.54); - assertEqual(actual[0]["UnitTests_Hamburger/Dieter"].toFixed(2), 0.85); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 1); - }, - - testGRAPH_DIAMETER_AND_RADIUS_WITH_DIJSKTRA: function () { - var actual; - actual = getQueryResults("RETURN GRAPH_RADIUS('werKenntWen', {algorithm : 'dijkstra'})"); - assertEqual(actual[0], 3); - - actual = getQueryResults("RETURN GRAPH_RADIUS('werKenntWen', {algorithm : 'dijkstra', weight : 'entfernung', defaultWeight : 80})"); - assertEqual(actual[0].toFixed(1), 450.1); - - actual = getQueryResults("RETURN GRAPH_DIAMETER('werKenntWen', {algorithm : 'dijkstra'})"); - assertEqual(actual[0], 5); - - actual = getQueryResults("RETURN GRAPH_DIAMETER('werKenntWen', {algorithm : 'dijkstra', weight : 'entfernung', defaultWeight : 80})"); - assertEqual(actual[0].toFixed(1), 830.3); - }, - - testGRAPH_SHORTEST_PATHWithExamples_WITH_DIJSKTRA: function () { - var actual; - - actual = getQueryResults("FOR e IN GRAPH_SHORTEST_PATH('werKenntWen', {gender : 'female'}, {gender : 'male', age : 30}, " + - "{direction : 'any'}) SORT e.startVertex, e.vertex._id RETURN [e.startVertex, e.vertex._id]"); - assertEqual(actual, [ - [ - "UnitTests_Berliner/Berta", - "UnitTests_Frankfurter/Fritz" - ], - [ - "UnitTests_Berliner/Berta", - "UnitTests_Hamburger/Caesar" - ], - [ - "UnitTests_Leipziger/Gerda", - "UnitTests_Frankfurter/Fritz" - ], - [ - "UnitTests_Leipziger/Gerda", - "UnitTests_Hamburger/Caesar" - ] - ] - ); - - actual = getQueryResults("FOR e IN GRAPH_DISTANCE_TO('werKenntWen', {gender : 'female'}, {gender : 'male', age : 30}, " + - "{direction : 'any'}) SORT e.startVertex, e.vertex._id SORT e.startVertex, e.vertex._id RETURN [e.startVertex, e.vertex._id, e.distance]"); - assertEqual(actual, [ - [ - "UnitTests_Berliner/Berta", - "UnitTests_Frankfurter/Fritz", - 4 - ], - [ - "UnitTests_Berliner/Berta", - "UnitTests_Hamburger/Caesar", - 1 - - ], - [ - "UnitTests_Leipziger/Gerda", - "UnitTests_Frankfurter/Fritz", - 3 - ], - [ - "UnitTests_Leipziger/Gerda", - "UnitTests_Hamburger/Caesar", - 2 - ] - ] - ); + actual = getQueryResults("RETURN GRAPH_ABSOLUTE_ECCENTRICITY('werKenntWen', {gender : 'female'}, {algorithm : 'Floyd-Warshall', direction : 'inbound'})"); + assertEqual(actual[0]["UnitTests_Berliner/Berta"], 1); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 2); - } - }; + actual = getQueryResults("RETURN GRAPH_ECCENTRICITY('werKenntWen', {weight : 'entfernung', defaultWeight : 80, algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0]["UnitTests_Berliner/Anton"].toFixed(2), 0.78); + assertEqual(actual[0]["UnitTests_Berliner/Berta"].toFixed(2), 0.78); + assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(2), 0.54); + assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"].toFixed(2), 0.54); + assertEqual(actual[0]["UnitTests_Hamburger/Caesar"].toFixed(2), 0.54); + assertEqual(actual[0]["UnitTests_Hamburger/Dieter"].toFixed(2), 0.85); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 1); + + +}, + +testGRAPH_BETWEENNESS: function () { + var actual; + + actual = getQueryResults("RETURN GRAPH_ABSOLUTE_BETWEENNESS('werKenntWen', {algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0]["UnitTests_Berliner/Anton"], 0); + assertEqual(actual[0]["UnitTests_Berliner/Berta"], 16); + assertEqual(actual[0]["UnitTests_Frankfurter/Emil"], 10); + assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 0); + assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 0); + assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 16); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 18); + + + actual = getQueryResults("RETURN GRAPH_BETWEENNESS('werKenntWen', {algorithm : 'Floyd-Warshall'})"); + + assertEqual(actual[0]["UnitTests_Berliner/Anton"], 0); + assertEqual(actual[0]["UnitTests_Berliner/Berta"].toFixed(2), 0.89); + assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(2), 0.56); + assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 0); + assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 0); + assertEqual(actual[0]["UnitTests_Hamburger/Dieter"].toFixed(2), 0.89); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 1); + + + actual = getQueryResults("RETURN GRAPH_ABSOLUTE_BETWEENNESS('werKenntWen', {algorithm : 'Floyd-Warshall', direction : 'inbound'})"); + assertEqual(actual[0]["UnitTests_Berliner/Anton"], 0); + assertEqual(actual[0]["UnitTests_Berliner/Berta"], 4); + assertEqual(actual[0]["UnitTests_Frankfurter/Emil"], 4); + assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 0); + assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 0); + assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 6); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 6); + + actual = getQueryResults("RETURN GRAPH_BETWEENNESS('werKenntWen', {algorithm : 'Floyd-Warshall', direction : 'inbound'})"); + assertEqual(actual[0]["UnitTests_Berliner/Anton"], 0); + assertEqual(actual[0]["UnitTests_Berliner/Berta"].toFixed(2), 0.67); + assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(2), 0.67); + assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 0); + assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 0); + assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 1); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 1); + + + + actual = getQueryResults("RETURN GRAPH_BETWEENNESS('werKenntWen', {weight : 'entfernung', defaultWeight : 80, algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0]["UnitTests_Berliner/Anton"], 0); + assertEqual(actual[0]["UnitTests_Berliner/Berta"], 1); + assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(2), 0.56); + assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 0); + assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 0); + assertEqual(actual[0]["UnitTests_Hamburger/Dieter"].toFixed(2), 0.89); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 1); + + +}, + +testGRAPH_DIAMETER_AND_RADIUS: function () { + var actual; + actual = getQueryResults("RETURN GRAPH_RADIUS('werKenntWen', {algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0], 3); + + actual = getQueryResults("RETURN GRAPH_RADIUS('werKenntWen', {weight : 'entfernung', defaultWeight : 80, algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0].toFixed(1), 450.1); + + actual = getQueryResults("RETURN GRAPH_DIAMETER('werKenntWen', {algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0], 5); + + actual = getQueryResults("RETURN GRAPH_DIAMETER('werKenntWen', {weight : 'entfernung', defaultWeight : 80, algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0].toFixed(1), 830.3); + + + + actual = getQueryResults("RETURN GRAPH_RADIUS('werKenntWen', {direction : 'inbound', algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0], 1); + + actual = getQueryResults("RETURN GRAPH_RADIUS('werKenntWen', {direction : 'inbound', weight : 'entfernung', defaultWeight : 80, algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0].toFixed(1), 250.1); + + actual = getQueryResults("RETURN GRAPH_DIAMETER('werKenntWen', {direction : 'inbound', algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0], 5); + + actual = getQueryResults("RETURN GRAPH_DIAMETER('werKenntWen', {direction : 'inbound', weight : 'entfernung', defaultWeight : 80, algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0].toFixed(1), 830.3); + + actual = getQueryResults("RETURN GRAPH_RADIUS('werKenntWen', {direction : 'outbound', algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0], 1); + + actual = getQueryResults("RETURN GRAPH_RADIUS('werKenntWen', {direction : 'outbound', weight : 'entfernung', defaultWeight : 80, algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0].toFixed(1), 0.2); + + actual = getQueryResults("RETURN GRAPH_DIAMETER('werKenntWen', {direction : 'outbound', algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0], 5); + + actual = getQueryResults("RETURN GRAPH_DIAMETER('werKenntWen', {direction : 'outbound', weight : 'entfernung', defaultWeight : 80, algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0].toFixed(1), 830.3); + + + +}, + +testGRAPH_SHORTEST_PATHWithExamples: function () { + var actual; + + actual = getQueryResults("FOR e IN GRAPH_SHORTEST_PATH('werKenntWen', {gender : 'female'}, {gender : 'male', age : 30}, " + + "{direction : 'any', algorithm : 'Floyd-Warshall'}) SORT e.startVertex, e.vertex._id RETURN [e.startVertex, e.vertex._id]"); + assertEqual(actual, [ + [ + "UnitTests_Berliner/Berta", + "UnitTests_Frankfurter/Fritz" + ], + [ + "UnitTests_Berliner/Berta", + "UnitTests_Hamburger/Caesar" + ], + [ + "UnitTests_Leipziger/Gerda", + "UnitTests_Frankfurter/Fritz" + ], + [ + "UnitTests_Leipziger/Gerda", + "UnitTests_Hamburger/Caesar" + ] + ] +); + +actual = getQueryResults("FOR e IN GRAPH_DISTANCE_TO('werKenntWen', {gender : 'female'}, {gender : 'male', age : 30}, " + + "{direction : 'any'}) SORT e.startVertex, e.vertex._id SORT e.startVertex, e.vertex._id RETURN [e.startVertex, e.vertex._id, e.distance]"); +assertEqual(actual, [ + [ + "UnitTests_Berliner/Berta", + "UnitTests_Frankfurter/Fritz", + 4 + ], + [ + "UnitTests_Berliner/Berta", + "UnitTests_Hamburger/Caesar", + 1 + + ], + [ + "UnitTests_Leipziger/Gerda", + "UnitTests_Frankfurter/Fritz", + 3 + ], + [ + "UnitTests_Leipziger/Gerda", + "UnitTests_Hamburger/Caesar", + 2 + ] +] +); + + +}, + +testGRAPH_CLOSENESS_WITH_DIJSKTRA: function () { + var actual; + actual = getQueryResults("RETURN GRAPH_CLOSENESS('werKenntWen', {algorithm : 'dijkstra'})"); + + assertEqual(actual[0]["UnitTests_Berliner/Anton"].toFixed(2), 0.69); + assertEqual(actual[0]["UnitTests_Berliner/Berta"].toFixed(2), 0.92); + assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(2), 0.73); + assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"].toFixed(2), 0.55); + assertEqual(actual[0]["UnitTests_Hamburger/Caesar"].toFixed(2), 0.69); + assertEqual(actual[0]["UnitTests_Hamburger/Dieter"].toFixed(2), 0.92); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 1); + + + actual = getQueryResults("RETURN GRAPH_CLOSENESS('werKenntWen', {algorithm : 'dijkstra', weight : 'entfernung', defaultWeight : 80})"); + assertEqual(actual[0]["UnitTests_Berliner/Anton"].toFixed(2), 0.89); + assertEqual(actual[0]["UnitTests_Berliner/Berta"].toFixed(2), 0.89); + assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(2), 0.63); + assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"].toFixed(2), 0.63); + assertEqual(actual[0]["UnitTests_Hamburger/Caesar"].toFixed(2), 0.54); + assertEqual(actual[0]["UnitTests_Hamburger/Dieter"].toFixed(2), 0.95); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 1); + +}, + + +testGRAPH_CLOSENESS_OUTBOUND_WITH_DIJSKTRA: function () { + var actual; + actual = getQueryResults("RETURN GRAPH_CLOSENESS('werKenntWen', {algorithm : 'dijkstra', direction : 'outbound'})"); + assertEqual(actual[0]["UnitTests_Berliner/Anton"], 0); + assertEqual(actual[0]["UnitTests_Berliner/Berta"].toFixed(2), 0.94); + assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(1), 0.3); + assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 0); + assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 1); + assertEqual(actual[0]["UnitTests_Hamburger/Dieter"].toFixed(2), 0.46); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"].toFixed(2), 0.56); + + + actual = getQueryResults("RETURN GRAPH_CLOSENESS('werKenntWen', {algorithm : 'dijkstra', weight : 'entfernung', defaultWeight : 80, direction : 'outbound'})"); + assertEqual(actual[0]["UnitTests_Berliner/Anton"], 0); + assertEqual(actual[0]["UnitTests_Berliner/Berta"], 1); + assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(1), 0.5); + assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 0); + assertEqual(actual[0]["UnitTests_Hamburger/Caesar"].toFixed(3), 0.001); + assertEqual(actual[0]["UnitTests_Hamburger/Dieter"].toFixed(3), 0.001); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"].toFixed(3), 0.002); +}, + + +testGRAPH_CLOSENESS_INBOUND_WITH_DIJSKTRA: function () { + var actual; + actual = getQueryResults("RETURN GRAPH_CLOSENESS('werKenntWen', {algorithm : 'dijkstra', direction : 'inbound'})"); + assertEqual(actual[0]["UnitTests_Berliner/Anton"].toFixed(2), 0.88); + assertEqual(actual[0]["UnitTests_Berliner/Berta"].toFixed(2), 0.44); + assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(2), 0.91); + assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 1); + assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 0); + assertEqual(actual[0]["UnitTests_Hamburger/Dieter"].toFixed(1), 0.8); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"].toFixed(2), 0.66); + + actual = getQueryResults("RETURN GRAPH_CLOSENESS('werKenntWen', {algorithm : 'dijkstra', weight : 'entfernung', defaultWeight : 80, direction : 'inbound'})"); + assertEqual(actual[0]["UnitTests_Berliner/Anton"], 1); + assertEqual(actual[0]["UnitTests_Berliner/Berta"].toFixed(4), 0.0004); + assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(4), 0.0009); + assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"].toFixed(1), 0.5); + assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 0); + assertEqual(actual[0]["UnitTests_Hamburger/Dieter"].toFixed(3), 0.002); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"].toFixed(4), 0.0007); + +}, + + +testGRAPH_ECCENTRICITY_WITH_DIJSKTRA: function () { + var actual; + actual = getQueryResults("RETURN GRAPH_ECCENTRICITY('werKenntWen', {algorithm : 'dijkstra'})"); + assertEqual(actual[0]["UnitTests_Berliner/Anton"].toFixed(1), 0.6); + assertEqual(actual[0]["UnitTests_Berliner/Berta"].toFixed(2), 0.75); + assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(2), 0.75); + assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"].toFixed(1), 0.6); + assertEqual(actual[0]["UnitTests_Hamburger/Caesar"].toFixed(1), 0.6); + assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 1); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 1); + + + actual = getQueryResults("RETURN GRAPH_ECCENTRICITY('werKenntWen')"); + assertEqual(actual[0]["UnitTests_Berliner/Anton"].toFixed(1), 0.6); + assertEqual(actual[0]["UnitTests_Berliner/Berta"].toFixed(2), 0.75); + assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(2), 0.75); + assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"].toFixed(1), 0.6); + assertEqual(actual[0]["UnitTests_Hamburger/Caesar"].toFixed(1), 0.6); + assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 1); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 1); + + + actual = getQueryResults("RETURN GRAPH_ECCENTRICITY('werKenntWen', {algorithm : 'dijkstra', direction : 'inbound'})"); + assertEqual(actual[0]["UnitTests_Berliner/Anton"], 1); + assertEqual(actual[0]["UnitTests_Berliner/Berta"], 1); + assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(2), 0.25); + assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"].toFixed(1), 0.2); + assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 0); + assertEqual(actual[0]["UnitTests_Hamburger/Dieter"].toFixed(2), 0.33); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"].toFixed(1), 0.5); + + actual = getQueryResults("RETURN GRAPH_ECCENTRICITY('werKenntWen', {algorithm : 'dijkstra', weight : 'entfernung', defaultWeight : 80})"); + assertEqual(actual[0]["UnitTests_Berliner/Anton"].toFixed(2), 0.78); + assertEqual(actual[0]["UnitTests_Berliner/Berta"].toFixed(2), 0.78); + assertEqual(actual[0]["UnitTests_Frankfurter/Emil"].toFixed(2), 0.54); + assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"].toFixed(2), 0.54); + assertEqual(actual[0]["UnitTests_Hamburger/Caesar"].toFixed(2), 0.54); + assertEqual(actual[0]["UnitTests_Hamburger/Dieter"].toFixed(2), 0.85); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 1); +}, + +testGRAPH_DIAMETER_AND_RADIUS_WITH_DIJSKTRA: function () { + var actual; + actual = getQueryResults("RETURN GRAPH_RADIUS('werKenntWen', {algorithm : 'dijkstra'})"); + assertEqual(actual[0], 3); + + actual = getQueryResults("RETURN GRAPH_RADIUS('werKenntWen', {algorithm : 'dijkstra', weight : 'entfernung', defaultWeight : 80})"); + assertEqual(actual[0].toFixed(1), 450.1); + + actual = getQueryResults("RETURN GRAPH_DIAMETER('werKenntWen', {algorithm : 'dijkstra'})"); + assertEqual(actual[0], 5); + + actual = getQueryResults("RETURN GRAPH_DIAMETER('werKenntWen', {algorithm : 'dijkstra', weight : 'entfernung', defaultWeight : 80})"); + assertEqual(actual[0].toFixed(1), 830.3); +}, + +testGRAPH_SHORTEST_PATHWithExamples_WITH_DIJSKTRA: function () { + var actual; + + actual = getQueryResults("FOR e IN GRAPH_SHORTEST_PATH('werKenntWen', {gender : 'female'}, {gender : 'male', age : 30}, " + + "{direction : 'any'}) SORT e.startVertex, e.vertex._id RETURN [e.startVertex, e.vertex._id]"); + assertEqual(actual, [ + [ + "UnitTests_Berliner/Berta", + "UnitTests_Frankfurter/Fritz" + ], + [ + "UnitTests_Berliner/Berta", + "UnitTests_Hamburger/Caesar" + ], + [ + "UnitTests_Leipziger/Gerda", + "UnitTests_Frankfurter/Fritz" + ], + [ + "UnitTests_Leipziger/Gerda", + "UnitTests_Hamburger/Caesar" + ] + ] +); + +actual = getQueryResults("FOR e IN GRAPH_DISTANCE_TO('werKenntWen', {gender : 'female'}, {gender : 'male', age : 30}, " + + "{direction : 'any'}) SORT e.startVertex, e.vertex._id SORT e.startVertex, e.vertex._id RETURN [e.startVertex, e.vertex._id, e.distance]"); +assertEqual(actual, [ + [ + "UnitTests_Berliner/Berta", + "UnitTests_Frankfurter/Fritz", + 4 + ], + [ + "UnitTests_Berliner/Berta", + "UnitTests_Hamburger/Caesar", + 1 + + ], + [ + "UnitTests_Leipziger/Gerda", + "UnitTests_Frankfurter/Fritz", + 3 + ], + [ + "UnitTests_Leipziger/Gerda", + "UnitTests_Hamburger/Caesar", + 2 + ] +] +); + + +} +}; } @@ -1663,9 +1794,9 @@ function ahuacatlQueryGeneralTraversalTestSuite() { function ahuacatlQueryGeneralCyclesSuite() { return { -//////////////////////////////////////////////////////////////////////////////// -/// @brief set up -//////////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////////////////////////////////////////////// + /// @brief set up + //////////////////////////////////////////////////////////////////////////////// setUp: function () { db._drop("UnitTests_Berliner"); @@ -1720,9 +1851,9 @@ function ahuacatlQueryGeneralCyclesSuite() { makeEdge(Berta._id, Anton._id, g[KenntAnderen], 3); }, -//////////////////////////////////////////////////////////////////////////////// -/// @brief tear down -//////////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////////////////////////////////////////////// + /// @brief tear down + //////////////////////////////////////////////////////////////////////////////// tearDown: function () { db._drop("UnitTests_Berliner"); @@ -1734,9 +1865,9 @@ function ahuacatlQueryGeneralCyclesSuite() { db._collection("_graphs").remove("_graphs/werKenntWen"); }, -//////////////////////////////////////////////////////////////////////////////// -/// @brief checks GRAPH_TRAVERSAL() -//////////////////////////////////////////////////////////////////////////////// + //////////////////////////////////////////////////////////////////////////////// + /// @brief checks GRAPH_TRAVERSAL() + //////////////////////////////////////////////////////////////////////////////// testGRAPH_SHORTEST_PATH: function () { var actual; @@ -1840,335 +1971,335 @@ function ahuacatlQueryGeneralCyclesSuite() { 0 ] ] - ); + ); - actual = getQueryResults("FOR e IN GRAPH_SHORTEST_PATH('werKenntWen', {}, " + - "{}, {direction : 'inbound', algorithm : 'djikstra'}) SORT e.startVertex, e.vertex._id RETURN [e.startVertex, e.vertex._id, e.distance]"); - assertEqual(actual, [ - [ - "UnitTests_Berliner/Anton", - "UnitTests_Berliner/Anton", - 0 - ], - [ - "UnitTests_Berliner/Anton", - "UnitTests_Berliner/Berta", - 1 - ], - [ - "UnitTests_Berliner/Anton", - "UnitTests_Frankfurter/Fritz", - 3 - ], - [ - "UnitTests_Berliner/Anton", - "UnitTests_Hamburger/Caesar", - 2 - ], - [ - "UnitTests_Berliner/Berta", - "UnitTests_Berliner/Anton", - 1 - ], - [ - "UnitTests_Berliner/Berta", - "UnitTests_Berliner/Berta", - 0 - ], - [ - "UnitTests_Berliner/Berta", - "UnitTests_Frankfurter/Fritz", - 2 - ], - [ - "UnitTests_Berliner/Berta", - "UnitTests_Hamburger/Caesar", - 1 - ], - [ - "UnitTests_Frankfurter/Emil", - "UnitTests_Frankfurter/Emil", - 0 - ], - [ - "UnitTests_Frankfurter/Fritz", - "UnitTests_Berliner/Anton", - 1 - ], - [ - "UnitTests_Frankfurter/Fritz", - "UnitTests_Berliner/Berta", - 2 - ], - [ - "UnitTests_Frankfurter/Fritz", - "UnitTests_Frankfurter/Fritz", - 0 - ], - [ - "UnitTests_Frankfurter/Fritz", - "UnitTests_Hamburger/Caesar", - 3 - ], - [ - "UnitTests_Hamburger/Caesar", - "UnitTests_Berliner/Anton", - 2 - ], - [ - "UnitTests_Hamburger/Caesar", - "UnitTests_Berliner/Berta", - 1 - ], - [ - "UnitTests_Hamburger/Caesar", - "UnitTests_Frankfurter/Fritz", - 1 - ], - [ - "UnitTests_Hamburger/Caesar", - "UnitTests_Hamburger/Caesar", - 0 - ], - [ - "UnitTests_Hamburger/Dieter", - "UnitTests_Hamburger/Dieter", - 0 - ], - [ - "UnitTests_Leipziger/Gerda", - "UnitTests_Leipziger/Gerda", - 0 - ] + actual = getQueryResults("FOR e IN GRAPH_SHORTEST_PATH('werKenntWen', {}, " + + "{}, {direction : 'inbound', algorithm : 'djikstra'}) SORT e.startVertex, e.vertex._id RETURN [e.startVertex, e.vertex._id, e.distance]"); + assertEqual(actual, [ + [ + "UnitTests_Berliner/Anton", + "UnitTests_Berliner/Anton", + 0 + ], + [ + "UnitTests_Berliner/Anton", + "UnitTests_Berliner/Berta", + 1 + ], + [ + "UnitTests_Berliner/Anton", + "UnitTests_Frankfurter/Fritz", + 3 + ], + [ + "UnitTests_Berliner/Anton", + "UnitTests_Hamburger/Caesar", + 2 + ], + [ + "UnitTests_Berliner/Berta", + "UnitTests_Berliner/Anton", + 1 + ], + [ + "UnitTests_Berliner/Berta", + "UnitTests_Berliner/Berta", + 0 + ], + [ + "UnitTests_Berliner/Berta", + "UnitTests_Frankfurter/Fritz", + 2 + ], + [ + "UnitTests_Berliner/Berta", + "UnitTests_Hamburger/Caesar", + 1 + ], + [ + "UnitTests_Frankfurter/Emil", + "UnitTests_Frankfurter/Emil", + 0 + ], + [ + "UnitTests_Frankfurter/Fritz", + "UnitTests_Berliner/Anton", + 1 + ], + [ + "UnitTests_Frankfurter/Fritz", + "UnitTests_Berliner/Berta", + 2 + ], + [ + "UnitTests_Frankfurter/Fritz", + "UnitTests_Frankfurter/Fritz", + 0 + ], + [ + "UnitTests_Frankfurter/Fritz", + "UnitTests_Hamburger/Caesar", + 3 + ], + [ + "UnitTests_Hamburger/Caesar", + "UnitTests_Berliner/Anton", + 2 + ], + [ + "UnitTests_Hamburger/Caesar", + "UnitTests_Berliner/Berta", + 1 + ], + [ + "UnitTests_Hamburger/Caesar", + "UnitTests_Frankfurter/Fritz", + 1 + ], + [ + "UnitTests_Hamburger/Caesar", + "UnitTests_Hamburger/Caesar", + 0 + ], + [ + "UnitTests_Hamburger/Dieter", + "UnitTests_Hamburger/Dieter", + 0 + ], + [ + "UnitTests_Leipziger/Gerda", + "UnitTests_Leipziger/Gerda", + 0 ] - ); - }, + ] + ); +}, - testGRAPH_CLOSENESS: function () { +testGRAPH_CLOSENESS: function () { - var actual; - actual = getQueryResults("RETURN GRAPH_ABSOLUTE_CLOSENESS('werKenntWen', {}, {algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0]["UnitTests_Berliner/Anton"], 4); - assertEqual(actual[0]["UnitTests_Berliner/Berta"], 4); - assertEqual(actual[0]["UnitTests_Frankfurter/Emil"], 0); - assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 4); - assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 4); - assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 0); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 0); + var actual; + actual = getQueryResults("RETURN GRAPH_ABSOLUTE_CLOSENESS('werKenntWen', {}, {algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0]["UnitTests_Berliner/Anton"], 4); + assertEqual(actual[0]["UnitTests_Berliner/Berta"], 4); + assertEqual(actual[0]["UnitTests_Frankfurter/Emil"], 0); + assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 4); + assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 4); + assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 0); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 0); - actual = getQueryResults("RETURN GRAPH_CLOSENESS('werKenntWen', {algorithm : 'Floyd-Warshall'})"); + actual = getQueryResults("RETURN GRAPH_CLOSENESS('werKenntWen', {algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0]["UnitTests_Berliner/Anton"], 1); - assertEqual(actual[0]["UnitTests_Berliner/Berta"], 1); - assertEqual(actual[0]["UnitTests_Frankfurter/Emil"], 0); - assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 1); - assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 1); - assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 0); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 0); + assertEqual(actual[0]["UnitTests_Berliner/Anton"], 1); + assertEqual(actual[0]["UnitTests_Berliner/Berta"], 1); + assertEqual(actual[0]["UnitTests_Frankfurter/Emil"], 0); + assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 1); + assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 1); + assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 0); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 0); - actual = getQueryResults("RETURN GRAPH_CLOSENESS('werKenntWen', {weight : 'entfernung', defaultWeight : 80, algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0]["UnitTests_Berliner/Anton"], 1); - assertEqual(actual[0]["UnitTests_Berliner/Berta"], 1); - assertEqual(actual[0]["UnitTests_Frankfurter/Emil"], 0); - assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"].toFixed(2), 0.53); - assertEqual(actual[0]["UnitTests_Hamburger/Caesar"].toFixed(2), 0.94); - assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 0); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 0); - }, + actual = getQueryResults("RETURN GRAPH_CLOSENESS('werKenntWen', {weight : 'entfernung', defaultWeight : 80, algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0]["UnitTests_Berliner/Anton"], 1); + assertEqual(actual[0]["UnitTests_Berliner/Berta"], 1); + assertEqual(actual[0]["UnitTests_Frankfurter/Emil"], 0); + assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"].toFixed(2), 0.53); + assertEqual(actual[0]["UnitTests_Hamburger/Caesar"].toFixed(2), 0.94); + assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 0); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 0); +}, - testGRAPH_CLOSENESS_OUTBOUND: function () { - var actual; - actual = getQueryResults("RETURN GRAPH_ABSOLUTE_CLOSENESS('werKenntWen',{}, {direction : 'outbound', algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0]["UnitTests_Berliner/Anton"], 4); - assertEqual(actual[0]["UnitTests_Berliner/Berta"], 4); - assertEqual(actual[0]["UnitTests_Frankfurter/Emil"], 0); - assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 6); - assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 6); - assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 0); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 0); +testGRAPH_CLOSENESS_OUTBOUND: function () { + var actual; + actual = getQueryResults("RETURN GRAPH_ABSOLUTE_CLOSENESS('werKenntWen',{}, {direction : 'outbound', algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0]["UnitTests_Berliner/Anton"], 4); + assertEqual(actual[0]["UnitTests_Berliner/Berta"], 4); + assertEqual(actual[0]["UnitTests_Frankfurter/Emil"], 0); + assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 6); + assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 6); + assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 0); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 0); - actual = getQueryResults("RETURN GRAPH_CLOSENESS('werKenntWen', {weight : 'entfernung', defaultWeight : 80, direction : 'outbound', algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0]["UnitTests_Berliner/Anton"].toFixed(2), 0.42); - assertEqual(actual[0]["UnitTests_Berliner/Berta"].toFixed(1), 0.7); - assertEqual(actual[0]["UnitTests_Frankfurter/Emil"], 0); - assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"].toFixed(1), 0.3); - assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 1); - assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 0); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 0); - }, + actual = getQueryResults("RETURN GRAPH_CLOSENESS('werKenntWen', {weight : 'entfernung', defaultWeight : 80, direction : 'outbound', algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0]["UnitTests_Berliner/Anton"].toFixed(2), 0.42); + assertEqual(actual[0]["UnitTests_Berliner/Berta"].toFixed(1), 0.7); + assertEqual(actual[0]["UnitTests_Frankfurter/Emil"], 0); + assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"].toFixed(1), 0.3); + assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 1); + assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 0); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 0); +}, - testGRAPH_CLOSENESS_INBOUND: function () { - var actual; - actual = getQueryResults("RETURN GRAPH_ABSOLUTE_CLOSENESS('werKenntWen', {}, {direction : 'inbound', algorithm : 'Floyd-Warshall'})"); +testGRAPH_CLOSENESS_INBOUND: function () { + var actual; + actual = getQueryResults("RETURN GRAPH_ABSOLUTE_CLOSENESS('werKenntWen', {}, {direction : 'inbound', algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0]["UnitTests_Berliner/Anton"], 6); - assertEqual(actual[0]["UnitTests_Berliner/Berta"], 4); - assertEqual(actual[0]["UnitTests_Frankfurter/Emil"], 0); - assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 6); - assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 4); - assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 0); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 0); + assertEqual(actual[0]["UnitTests_Berliner/Anton"], 6); + assertEqual(actual[0]["UnitTests_Berliner/Berta"], 4); + assertEqual(actual[0]["UnitTests_Frankfurter/Emil"], 0); + assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 6); + assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 4); + assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 0); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 0); - actual = getQueryResults("RETURN GRAPH_CLOSENESS('werKenntWen', {weight : 'entfernung', defaultWeight : 80, direction : 'inbound', algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0]["UnitTests_Berliner/Anton"].toFixed(2), 0.83); - assertEqual(actual[0]["UnitTests_Berliner/Berta"], 1); - assertEqual(actual[0]["UnitTests_Frankfurter/Emil"], 0); - assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"].toFixed(2), 0.37); - assertEqual(actual[0]["UnitTests_Hamburger/Caesar"].toFixed(2), 0.39); - assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 0); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 0); - }, + actual = getQueryResults("RETURN GRAPH_CLOSENESS('werKenntWen', {weight : 'entfernung', defaultWeight : 80, direction : 'inbound', algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0]["UnitTests_Berliner/Anton"].toFixed(2), 0.83); + assertEqual(actual[0]["UnitTests_Berliner/Berta"], 1); + assertEqual(actual[0]["UnitTests_Frankfurter/Emil"], 0); + assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"].toFixed(2), 0.37); + assertEqual(actual[0]["UnitTests_Hamburger/Caesar"].toFixed(2), 0.39); + assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 0); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 0); +}, - testGRAPH_ECCENTRICITY: function () { - var actual; +testGRAPH_ECCENTRICITY: function () { + var actual; - actual = getQueryResults("RETURN GRAPH_ABSOLUTE_ECCENTRICITY('werKenntWen',{}, {algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0]["UnitTests_Berliner/Anton"], 2); - assertEqual(actual[0]["UnitTests_Berliner/Berta"], 2); - assertEqual(actual[0]["UnitTests_Frankfurter/Emil"], 0); - assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 2); - assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 2); - assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 0); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 0); + actual = getQueryResults("RETURN GRAPH_ABSOLUTE_ECCENTRICITY('werKenntWen',{}, {algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0]["UnitTests_Berliner/Anton"], 2); + assertEqual(actual[0]["UnitTests_Berliner/Berta"], 2); + assertEqual(actual[0]["UnitTests_Frankfurter/Emil"], 0); + assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 2); + assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 2); + assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 0); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 0); - actual = getQueryResults("RETURN GRAPH_ABSOLUTE_ECCENTRICITY('werKenntWen',{}, {weight : 'entfernung', defaultWeight : 80, algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0]["UnitTests_Berliner/Anton"], 9); - assertEqual(actual[0]["UnitTests_Berliner/Berta"], 12); - assertEqual(actual[0]["UnitTests_Frankfurter/Emil"], 0); - assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 12); - assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 11); - assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 0); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 0); + actual = getQueryResults("RETURN GRAPH_ABSOLUTE_ECCENTRICITY('werKenntWen',{}, {weight : 'entfernung', defaultWeight : 80, algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0]["UnitTests_Berliner/Anton"], 9); + assertEqual(actual[0]["UnitTests_Berliner/Berta"], 12); + assertEqual(actual[0]["UnitTests_Frankfurter/Emil"], 0); + assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 12); + assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 11); + assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 0); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 0); - actual = getQueryResults("RETURN GRAPH_ECCENTRICITY('werKenntWen', {algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0]["UnitTests_Berliner/Anton"], 1); - assertEqual(actual[0]["UnitTests_Berliner/Berta"], 1); - assertEqual(actual[0]["UnitTests_Frankfurter/Emil"], 0); - assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 1); - assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 1); - assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 0); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 0); + actual = getQueryResults("RETURN GRAPH_ECCENTRICITY('werKenntWen', {algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0]["UnitTests_Berliner/Anton"], 1); + assertEqual(actual[0]["UnitTests_Berliner/Berta"], 1); + assertEqual(actual[0]["UnitTests_Frankfurter/Emil"], 0); + assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 1); + assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 1); + assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 0); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 0); - actual = getQueryResults("RETURN GRAPH_ECCENTRICITY('werKenntWen', {algorithm : 'Floyd-Warshall', direction : 'inbound'})"); - assertEqual(actual[0]["UnitTests_Berliner/Anton"].toFixed(2), 0.67); - assertEqual(actual[0]["UnitTests_Berliner/Berta"], 1); - assertEqual(actual[0]["UnitTests_Frankfurter/Emil"], 0); - assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"].toFixed(2), 0.67); - assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 1); - assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 0); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 0); + actual = getQueryResults("RETURN GRAPH_ECCENTRICITY('werKenntWen', {algorithm : 'Floyd-Warshall', direction : 'inbound'})"); + assertEqual(actual[0]["UnitTests_Berliner/Anton"].toFixed(2), 0.67); + assertEqual(actual[0]["UnitTests_Berliner/Berta"], 1); + assertEqual(actual[0]["UnitTests_Frankfurter/Emil"], 0); + assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"].toFixed(2), 0.67); + assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 1); + assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 0); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 0); - actual = getQueryResults("RETURN GRAPH_ABSOLUTE_ECCENTRICITY('werKenntWen', {gender : 'female'}, {algorithm : 'Floyd-Warshall', direction : 'inbound'})"); - assertEqual(actual[0]["UnitTests_Berliner/Berta"], 2); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 0); + actual = getQueryResults("RETURN GRAPH_ABSOLUTE_ECCENTRICITY('werKenntWen', {gender : 'female'}, {algorithm : 'Floyd-Warshall', direction : 'inbound'})"); + assertEqual(actual[0]["UnitTests_Berliner/Berta"], 2); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 0); - actual = getQueryResults("RETURN GRAPH_ECCENTRICITY('werKenntWen', {weight : 'entfernung', defaultWeight : 80, algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0]["UnitTests_Berliner/Anton"], 1); - assertEqual(actual[0]["UnitTests_Berliner/Berta"].toFixed(2), 0.75); - assertEqual(actual[0]["UnitTests_Frankfurter/Emil"], 0); - assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"].toFixed(2), 0.75); - assertEqual(actual[0]["UnitTests_Hamburger/Caesar"].toFixed(2), 0.82); - assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 0); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 0); + actual = getQueryResults("RETURN GRAPH_ECCENTRICITY('werKenntWen', {weight : 'entfernung', defaultWeight : 80, algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0]["UnitTests_Berliner/Anton"], 1); + assertEqual(actual[0]["UnitTests_Berliner/Berta"].toFixed(2), 0.75); + assertEqual(actual[0]["UnitTests_Frankfurter/Emil"], 0); + assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"].toFixed(2), 0.75); + assertEqual(actual[0]["UnitTests_Hamburger/Caesar"].toFixed(2), 0.82); + assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 0); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 0); - }, +}, - testGRAPH_BETWEENNESS: function () { - var actual; +testGRAPH_BETWEENNESS: function () { + var actual; - actual = getQueryResults("RETURN GRAPH_ABSOLUTE_BETWEENNESS('werKenntWen', {algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0]["UnitTests_Berliner/Anton"], 1); - assertEqual(actual[0]["UnitTests_Berliner/Berta"], 1); - assertEqual(actual[0]["UnitTests_Frankfurter/Emil"], 0); - assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 1); - assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 1); - assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 0); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 0); + actual = getQueryResults("RETURN GRAPH_ABSOLUTE_BETWEENNESS('werKenntWen', {algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0]["UnitTests_Berliner/Anton"], 1); + assertEqual(actual[0]["UnitTests_Berliner/Berta"], 1); + assertEqual(actual[0]["UnitTests_Frankfurter/Emil"], 0); + assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 1); + assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 1); + assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 0); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 0); - actual = getQueryResults("RETURN GRAPH_BETWEENNESS('werKenntWen', {algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0]["UnitTests_Berliner/Anton"], 1); - assertEqual(actual[0]["UnitTests_Berliner/Berta"], 1); - assertEqual(actual[0]["UnitTests_Frankfurter/Emil"], 0); - assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 1); - assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 1); - assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 0); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 0); + actual = getQueryResults("RETURN GRAPH_BETWEENNESS('werKenntWen', {algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0]["UnitTests_Berliner/Anton"], 1); + assertEqual(actual[0]["UnitTests_Berliner/Berta"], 1); + assertEqual(actual[0]["UnitTests_Frankfurter/Emil"], 0); + assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 1); + assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 1); + assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 0); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 0); - actual = getQueryResults("RETURN GRAPH_ABSOLUTE_BETWEENNESS('werKenntWen', {algorithm : 'Floyd-Warshall', direction : 'inbound'})"); - assertEqual(actual[0]["UnitTests_Berliner/Anton"], 2); - assertEqual(actual[0]["UnitTests_Berliner/Berta"], 3.5); - assertEqual(actual[0]["UnitTests_Frankfurter/Emil"], 0); - assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 0.5); - assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 2); - assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 0); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 0); + actual = getQueryResults("RETURN GRAPH_ABSOLUTE_BETWEENNESS('werKenntWen', {algorithm : 'Floyd-Warshall', direction : 'inbound'})"); + assertEqual(actual[0]["UnitTests_Berliner/Anton"], 2); + assertEqual(actual[0]["UnitTests_Berliner/Berta"], 3.5); + assertEqual(actual[0]["UnitTests_Frankfurter/Emil"], 0); + assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 0.5); + assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 2); + assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 0); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 0); - actual = getQueryResults("RETURN GRAPH_ABSOLUTE_BETWEENNESS('werKenntWen', {weight : 'entfernung', defaultWeight : 80, algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0]["UnitTests_Berliner/Anton"], 2); - assertEqual(actual[0]["UnitTests_Berliner/Berta"], 2); - assertEqual(actual[0]["UnitTests_Frankfurter/Emil"],0 ); - assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 0); - assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 0); - assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 0); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 0); + actual = getQueryResults("RETURN GRAPH_ABSOLUTE_BETWEENNESS('werKenntWen', {weight : 'entfernung', defaultWeight : 80, algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0]["UnitTests_Berliner/Anton"], 2); + assertEqual(actual[0]["UnitTests_Berliner/Berta"], 2); + assertEqual(actual[0]["UnitTests_Frankfurter/Emil"],0 ); + assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 0); + assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 0); + assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 0); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 0); - actual = getQueryResults("RETURN GRAPH_BETWEENNESS('werKenntWen', {weight : 'entfernung', defaultWeight : 80, algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0]["UnitTests_Berliner/Anton"], 1); - assertEqual(actual[0]["UnitTests_Berliner/Berta"], 1); - assertEqual(actual[0]["UnitTests_Frankfurter/Emil"], 0); - assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 0); - assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 0); - assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 0); - assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 0); + actual = getQueryResults("RETURN GRAPH_BETWEENNESS('werKenntWen', {weight : 'entfernung', defaultWeight : 80, algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0]["UnitTests_Berliner/Anton"], 1); + assertEqual(actual[0]["UnitTests_Berliner/Berta"], 1); + assertEqual(actual[0]["UnitTests_Frankfurter/Emil"], 0); + assertEqual(actual[0]["UnitTests_Frankfurter/Fritz"], 0); + assertEqual(actual[0]["UnitTests_Hamburger/Caesar"], 0); + assertEqual(actual[0]["UnitTests_Hamburger/Dieter"], 0); + assertEqual(actual[0]["UnitTests_Leipziger/Gerda"], 0); - }, +}, - testGRAPH_DIAMETER_AND_RADIUS: function () { - var actual; - actual = getQueryResults("RETURN GRAPH_RADIUS('werKenntWen', {algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0], 2); +testGRAPH_DIAMETER_AND_RADIUS: function () { + var actual; + actual = getQueryResults("RETURN GRAPH_RADIUS('werKenntWen', {algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0], 2); - actual = getQueryResults("RETURN GRAPH_RADIUS('werKenntWen', {weight : 'entfernung', defaultWeight : 80, algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0], 9); + actual = getQueryResults("RETURN GRAPH_RADIUS('werKenntWen', {weight : 'entfernung', defaultWeight : 80, algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0], 9); - actual = getQueryResults("RETURN GRAPH_DIAMETER('werKenntWen', {algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0], 2); + actual = getQueryResults("RETURN GRAPH_DIAMETER('werKenntWen', {algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0], 2); - actual = getQueryResults("RETURN GRAPH_DIAMETER('werKenntWen', {weight : 'entfernung', defaultWeight : 80, algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0], 12); + actual = getQueryResults("RETURN GRAPH_DIAMETER('werKenntWen', {weight : 'entfernung', defaultWeight : 80, algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0], 12); - actual = getQueryResults("RETURN GRAPH_RADIUS('werKenntWen', {direction : 'inbound', algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0], 2); + actual = getQueryResults("RETURN GRAPH_RADIUS('werKenntWen', {direction : 'inbound', algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0], 2); - actual = getQueryResults("RETURN GRAPH_RADIUS('werKenntWen', {direction : 'inbound', weight : 'entfernung', defaultWeight : 80, algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0], 13); + actual = getQueryResults("RETURN GRAPH_RADIUS('werKenntWen', {direction : 'inbound', weight : 'entfernung', defaultWeight : 80, algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0], 13); - actual = getQueryResults("RETURN GRAPH_DIAMETER('werKenntWen', {direction : 'inbound', algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0], 3); + actual = getQueryResults("RETURN GRAPH_DIAMETER('werKenntWen', {direction : 'inbound', algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0], 3); - actual = getQueryResults("RETURN GRAPH_DIAMETER('werKenntWen', {direction : 'inbound', weight : 'entfernung', defaultWeight : 80, algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0], 16); + actual = getQueryResults("RETURN GRAPH_DIAMETER('werKenntWen', {direction : 'inbound', weight : 'entfernung', defaultWeight : 80, algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0], 16); - actual = getQueryResults("RETURN GRAPH_RADIUS('werKenntWen', {direction : 'outbound', algorithm : 'Floyd-Warshall'})"); - assertEqual(actual[0], 2); + actual = getQueryResults("RETURN GRAPH_RADIUS('werKenntWen', {direction : 'outbound', algorithm : 'Floyd-Warshall'})"); + assertEqual(actual[0], 2); - } - }; +} +}; } From f6e16315de225c04bfc6bf587cf53c308fa54b38 Mon Sep 17 00:00:00 2001 From: Michael Hackstein Date: Fri, 17 Oct 2014 16:56:05 +0200 Subject: [PATCH 2/9] Fixed a bug and a conceptional misunderstanding in GRAPH_NEIGHBORS --- js/server/modules/org/arangodb/ahuacatl.js | 32 +- js/server/tests/ahuacatl-general-graph.js | 713 +++++++++++++++++++-- 2 files changed, 669 insertions(+), 76 deletions(-) diff --git a/js/server/modules/org/arangodb/ahuacatl.js b/js/server/modules/org/arangodb/ahuacatl.js index 0cc1609fd5..55ee18fee2 100644 --- a/js/server/modules/org/arangodb/ahuacatl.js +++ b/js/server/modules/org/arangodb/ahuacatl.js @@ -4653,10 +4653,23 @@ function TRAVERSAL_EDGE_EXAMPLE_FILTER (config, vertex, edge, path) { function TRAVERSAL_VERTEX_FILTER (config, vertex, path) { "use strict"; - - if (! MATCHES(vertex, config.filterVertexExamples)) { + if (config.filterVertexExamples && !MATCHES(vertex, config.filterVertexExamples)) { + if (config.filterVertexCollections + && config.vertexFilterMethod.indexOf("exclude") === -1 + && config.filterVertexCollections.indexOf(vertex._id.split("/")[0]) === -1 + ) { + if (config.vertexFilterMethod.indexOf("prune") === -1) { + return ["exclude"]; + } + return ["prune", "exclude"]; + } return config.vertexFilterMethod; } + if (config.filterVertexCollections + && config.filterVertexCollections.indexOf(vertex._id.split("/")[0]) === -1 + ){ + return ["exclude"]; + } } //////////////////////////////////////////////////////////////////////////////// @@ -4789,6 +4802,11 @@ function TRAVERSAL_FUNC (func, config.vertexFilterMethod = params.vertexFilterMethod || ["prune", "exclude"]; } } + if (params.filterVertexCollections) { + config.filter = config.filter || TRAVERSAL_VERTEX_FILTER; + config.vertexFilterMethod = config.vertexFilterMethod || ["prune", "exclude"]; + config.filterVertexCollections = params.filterVertexCollections; + } if (params._sort) { config.sort = function (l, r) { return l._key < r._key ? -1 : 1; }; @@ -6068,13 +6086,6 @@ function GENERAL_GRAPH_NEIGHBORS (graphName, options.direction = 'any'; } - if (options.vertexCollectionRestriction) { - if (options.direction === "inbound") { - options.endVertexCollectionRestriction = options.vertexCollectionRestriction; - } else { - options.startVertexCollectionRestriction = options.vertexCollectionRestriction; - } - } if (options.neighborExamples) { if (typeof options.neighborExamples === "string") { options.neighborExamples = {_id : options.neighborExamples}; @@ -6094,6 +6105,9 @@ function GENERAL_GRAPH_NEIGHBORS (graphName, if (options.edgeCollectionRestriction) { params.edgeCollectionRestriction = options.edgeCollectionRestriction; } + if (options.vertexCollectionRestriction) { + params.filterVertexCollections = options.vertexCollectionRestriction; + } fromVertices.forEach(function (v) { var e = TRAVERSAL_FUNC("GRAPH_NEIGHBORS", factory, diff --git a/js/server/tests/ahuacatl-general-graph.js b/js/server/tests/ahuacatl-general-graph.js index 51f4d1721a..cb482d8b67 100644 --- a/js/server/tests/ahuacatl-general-graph.js +++ b/js/server/tests/ahuacatl-general-graph.js @@ -52,6 +52,10 @@ function ahuacatlQueryGeneralEdgesTestSuite() { var AQL_VERTICES = "FOR e IN GRAPH_VERTICES(@name, @example, @options) SORT e._id RETURN e"; var AQL_EDGES = "FOR e IN GRAPH_EDGES(@name, @example, @options) SORT e.what RETURN e.what"; + var AQL_NEIGHBORS = "FOR e IN GRAPH_NEIGHBORS(@name, @example, @options) SORT e.vertex._id, e.path.edges[0].what RETURN e"; + + var startExample = [{hugo : true}, {heinz : 1}]; + var vertexExample = {_key: "v1"}; return { @@ -154,22 +158,22 @@ function ahuacatlQueryGeneralEdgesTestSuite() { } }; var actual = getRawQueryResults(AQL_VERTICES, bindVars); - assertEqual(actual[0]._id, 'UnitTestsAhuacatlOrphan/orphan'); assertEqual(actual.length, 1); + assertEqual(actual[0]._id, 'UnitTestsAhuacatlOrphan/orphan'); }, testVerticesExample: function () { var bindVars = { name: gN, - example: [{hugo : true}, {heinz : 1}], + example: startExample, options: {direction : 'any'} }; var actual = getRawQueryResults(AQL_VERTICES, bindVars); + assertEqual(actual.length, 4); assertEqual(actual[0]._id, 'UnitTestsAhuacatlVertex1/v1'); assertEqual(actual[1]._id, 'UnitTestsAhuacatlVertex1/v2'); assertEqual(actual[2]._id, 'UnitTestsAhuacatlVertex2/v3'); assertEqual(actual[3]._id, 'UnitTestsAhuacatlVertex4/v8'); - assertEqual(actual.length, 4); }, testVerticesWithInboundEdges: function () { @@ -179,8 +183,8 @@ function ahuacatlQueryGeneralEdgesTestSuite() { options: {direction : 'inbound'} }; var actual = getRawQueryResults(AQL_VERTICES, bindVars); - assertEqual(actual[0]._id, 'UnitTestsAhuacatlVertex3/v5'); assertEqual(actual.length, 1); + assertEqual(actual[0]._id, 'UnitTestsAhuacatlVertex3/v5'); }, testVerticesWithInboundEdgesHasNoInboundEdges: function () { @@ -196,14 +200,14 @@ function ahuacatlQueryGeneralEdgesTestSuite() { testVerticesWithInboundEdgesAndExample: function () { var bindVars = { name: gN, - example: [{hugo : true}, {heinz : 1}], + example: startExample, options: {direction : 'inbound'} }; var actual = getRawQueryResults(AQL_VERTICES, bindVars); + assertEqual(actual.length, 3); assertEqual(actual[0]._id, 'UnitTestsAhuacatlVertex1/v1'); assertEqual(actual[1]._id, 'UnitTestsAhuacatlVertex1/v2'); assertEqual(actual[2]._id, 'UnitTestsAhuacatlVertex4/v8'); - assertEqual(actual.length, 3); }, testVerticesWithInboundEdgesRestrictedHasNoInbound: function() { @@ -229,9 +233,9 @@ function ahuacatlQueryGeneralEdgesTestSuite() { } }; var actual = getRawQueryResults(AQL_VERTICES, bindVars); + assertEqual(actual.length, 2); assertEqual(actual[0]._id, v3 + '/v5'); assertEqual(actual[1]._id, v3 + '/v6'); - assertEqual(actual.length, 2); }, testVerticesWithOutboundEdgesRestrictedHasOutbound: function() { @@ -244,9 +248,9 @@ function ahuacatlQueryGeneralEdgesTestSuite() { } }; var actual = getRawQueryResults(AQL_VERTICES, bindVars); + assertEqual(actual.length, 2); assertEqual(actual[0]._id, v2 + '/v3'); assertEqual(actual[1]._id, v2 + '/v4'); - assertEqual(actual.length, 2); }, testVerticesWithOutboundEdgesRestrictedHasNoOutbound: function() { @@ -271,84 +275,662 @@ function ahuacatlQueryGeneralEdgesTestSuite() { //////////////////////////////////////////////////////////////////////////////// testEdgesAny: function () { - var actual; - actual = getQueryResults("FOR e IN GRAPH_EDGES('bla3', 'UnitTestsAhuacatlVertex1/v1', {direction : 'any'}) SORT e.what RETURN e.what"); + var bindVars = { + name: gN, + example: v1 + "/v1", + options: {direction : 'any'} + }; + var actual = getRawQueryResults(AQL_EDGES, bindVars); assertEqual(actual, [ "v1->v2", "v1->v5", "v2->v1" ]); }, testEdgesAnyRestricted: function () { - var actual; - actual = getQueryResults("FOR e IN GRAPH_EDGES('bla3', 'UnitTestsAhuacatlVertex1/v1', {direction : 'any' , edgeCollectionRestriction: ['UnitTestsAhuacatlEdge1']}) " + - "SORT e.what RETURN e.what"); + var bindVars = { + name: gN, + example: v1 + "/v1", + options: { + direction : 'any', + edgeCollectionRestriction: [e1] + } + }; + var actual = getRawQueryResults(AQL_EDGES, bindVars); assertEqual(actual, [ "v1->v2", "v2->v1" ]); }, testEdgesAnyStartExample: function () { - var actual; - actual = getQueryResults("FOR e IN GRAPH_EDGES('bla3', [{hugo : true}, {heinz : 1}], {direction : 'any'}) " + - "SORT e.what RETURN e.what"); - assertEqual(actual, [ "v1->v2", + var bindVars = { + name: gN, + example: startExample, + options: {direction : 'any'} + }; + var actual = getRawQueryResults(AQL_EDGES, bindVars); + assertEqual(actual, [ + "v1->v2", "v1->v5", "v2->v1", "v2->v5", "v3->v5", "v3->v6", - "v3->v8" ]); + "v3->v8" + ]); }, testEdgesAnyStartExampleEdgeExample: function () { - var actual; - actual = getQueryResults("FOR e IN GRAPH_EDGES('bla3', 'UnitTestsAhuacatlVertex1/v1', {direction : 'any' , edgeExamples : [{'what' : 'v2->v1'}]}) SORT e.what RETURN e.what"); - assertEqual(actual, [ "v2->v1" ]); + var bindVars = { + name: gN, + example: v1 + "/v1", + options: { + direction : 'any', + edgeExamples: [{what: 'v2->v1'}] + } + }; + var actual = getRawQueryResults(AQL_EDGES, bindVars); + assertEqual(actual.length, 1); + assertEqual(actual[0], "v2->v1"); }, + testEdgesInbound: function() { + var bindVars = { + name: gN, + example: v1 + "/v1", + options: {direction : 'inbound'} + }; + var actual = getRawQueryResults(AQL_EDGES, bindVars); + assertEqual(actual, [ "v2->v1"]); + }, + + testEdgesInboundStartExample: function() { + var bindVars = { + name: gN, + example: startExample, + options: {direction : 'inbound'} + }; + var actual = getRawQueryResults(AQL_EDGES, bindVars); + assertEqual(actual.length, 3); + assertEqual(actual[0], "v1->v2"); + assertEqual(actual[1], "v2->v1"); + assertEqual(actual[2], "v3->v8"); + }, + + testEdgesInboundStartExampleRestricted: function() { + var bindVars = { + name: gN, + example: startExample, + options: { + direction : 'inbound', + edgeCollectionRestriction: [e2] + } + }; + var actual = getRawQueryResults(AQL_EDGES, bindVars); + assertEqual(actual.length, 1); + assertEqual(actual[0], "v3->v8"); + }, + + testEdgesInboundStartExampleEdgeExample: function() { + var bindVars = { + name: gN, + example: startExample, + options: { + direction : 'inbound', + edgeExamples: [{'what' : 'v3->v8'}] + } + }; + var actual = getRawQueryResults(AQL_EDGES, bindVars); + assertEqual(actual.length, 1); + assertEqual(actual[0], "v3->v8"); + }, + + testEdgesOutbound: function() { + var bindVars = { + name: gN, + example: v1 + "/v1", + options: {direction : 'outbound'} + }; + var actual = getRawQueryResults(AQL_EDGES, bindVars); + assertEqual(actual[0], "v1->v2"); + assertEqual(actual[1], "v1->v5"); + }, + + testEdgesOutboundStartExample: function() { + var bindVars = { + name: gN, + example: startExample, + options: {direction : 'outbound'} + }; + var actual = getRawQueryResults(AQL_EDGES, bindVars); + assertEqual(actual.length, 7); + assertEqual(actual[0], "v1->v2"); + assertEqual(actual[1], "v1->v5"); + assertEqual(actual[2], "v2->v1"); + assertEqual(actual[3], "v2->v5"); + assertEqual(actual[4], "v3->v5"); + assertEqual(actual[5], "v3->v6"); + assertEqual(actual[6], "v3->v8"); + }, + + testEdgesOutboundStartExampleRestricted: function() { + var bindVars = { + name: gN, + example: startExample, + options: { + direction : 'outbound', + edgeCollectionRestriction: [e2] + } + }; + var actual = getRawQueryResults(AQL_EDGES, bindVars); + assertEqual(actual.length, 5); + assertEqual(actual[0], "v1->v5"); + assertEqual(actual[1], "v2->v5"); + assertEqual(actual[2], "v3->v5"); + assertEqual(actual[3], "v3->v6"); + assertEqual(actual[4], "v3->v8"); + }, + //////////////////////////////////////////////////////////////////////////////// - /// @brief checks GRAPH_NEIGHBORS() + /// Test Neighbors //////////////////////////////////////////////////////////////////////////////// - testNeighborsAnyStartExampleEdgeExample: function () { - var actual; - actual = getQueryResults("FOR e IN GRAPH_NEIGHBORS('bla3', 'UnitTestsAhuacatlVertex1/v1', {direction : 'any' , edgeExamples : [{'what' : 'v2->v1'}]}) SORT e.what RETURN e"); + + //////////////////////////////////////////////////////////////////////////////// + /// Any direction + //////////////////////////////////////////////////////////////////////////////// + + testNeighborsAny: function () { + var bindVars = { + name: gN, + example: v1 + "/v1", + options: { + direction : 'any' + } + }; + var actual = getRawQueryResults(AQL_NEIGHBORS, bindVars); + assertEqual(actual.length, 3); + assertEqual(actual[0].path.edges[0].what, "v1->v2"); + assertEqual(actual[0].path.edges.length, 1); + assertEqual(actual[0].vertex._key, "v2"); + assertEqual(actual[1].path.edges[0].what, "v2->v1"); + assertEqual(actual[1].path.edges.length, 1); + assertEqual(actual[1].vertex._key, "v2"); + assertEqual(actual[2].path.edges[0].what, "v1->v5"); + assertEqual(actual[2].path.edges.length, 1); + assertEqual(actual[2].vertex._key, "v5"); + }, + + testNeighborsAnyEdgeExample: function () { + var bindVars = { + name: gN, + example: v1 + "/v1", + options: { + direction : 'any', + edgeExamples : [{'what' : 'v2->v1'}] + } + }; + var actual = getRawQueryResults(AQL_NEIGHBORS, bindVars); + assertEqual(actual.length, 1); assertEqual(actual[0].path.edges[0].what, "v2->v1"); + assertEqual(actual[0].path.edges.length, 1); assertEqual(actual[0].vertex._key, "v2"); }, + testNeighborsAnyStartExample: function () { + var bindVars = { + name: gN, + example: startExample, + options: { + direction : 'any' + } + }; + var actual = getRawQueryResults(AQL_NEIGHBORS, bindVars); + assertEqual(actual.length, 10); + assertEqual(actual[0].path.edges[0].what, "v1->v2"); + assertEqual(actual[0].path.edges.length, 1); + assertEqual(actual[0].vertex._key, "v1"); + assertEqual(actual[1].path.edges[0].what, "v2->v1"); + assertEqual(actual[1].path.edges.length, 1); + assertEqual(actual[1].vertex._key, "v1"); + assertEqual(actual[2].path.edges[0].what, "v1->v2"); + assertEqual(actual[2].path.edges.length, 1); + assertEqual(actual[2].vertex._key, "v2"); + assertEqual(actual[3].path.edges[0].what, "v2->v1"); + assertEqual(actual[3].path.edges.length, 1); + assertEqual(actual[3].vertex._key, "v2"); + assertEqual(actual[4].path.edges[0].what, "v3->v8"); + assertEqual(actual[4].path.edges.length, 1); + assertEqual(actual[4].vertex._key, "v3"); + assertEqual(actual[5].path.edges[0].what, "v1->v5"); + assertEqual(actual[5].path.edges.length, 1); + assertEqual(actual[5].vertex._key, "v5"); + assertEqual(actual[6].path.edges[0].what, "v2->v5"); + assertEqual(actual[6].path.edges.length, 1); + assertEqual(actual[6].vertex._key, "v5"); + assertEqual(actual[7].path.edges[0].what, "v3->v5"); + assertEqual(actual[7].path.edges.length, 1); + assertEqual(actual[7].vertex._key, "v5"); + assertEqual(actual[8].path.edges[0].what, "v3->v6"); + assertEqual(actual[8].path.edges.length, 1); + assertEqual(actual[8].vertex._key, "v6"); + assertEqual(actual[9].path.edges[0].what, "v3->v8"); + assertEqual(actual[9].path.edges.length, 1); + assertEqual(actual[9].vertex._key, "v8"); + }, + + testNeighborsAnyVertexExample: function () { + var bindVars = { + name: gN, + example: {}, + options: { + direction : 'any', + neighborExamples: vertexExample + } + }; + var actual = getRawQueryResults(AQL_NEIGHBORS, bindVars); + assertEqual(actual.length, 3); + assertEqual(actual[0].path.edges[0].what, "v1->v2"); + assertEqual(actual[0].path.edges.length, 1); + assertEqual(actual[0].vertex._key, "v1"); + assertEqual(actual[1].path.edges[0].what, "v1->v5"); + assertEqual(actual[1].path.edges.length, 1); + assertEqual(actual[1].vertex._key, "v1"); + assertEqual(actual[2].path.edges[0].what, "v2->v1"); + assertEqual(actual[2].path.edges.length, 1); + assertEqual(actual[2].vertex._key, "v1"); + }, + testNeighborsAnyStartExampleRestrictEdges: function () { + var bindVars = { + name: gN, + example: startExample, + options: { + direction : 'any', + edgeCollectionRestriction: e2 + } + }; + var actual = getRawQueryResults(AQL_NEIGHBORS, bindVars); + assertEqual(actual.length, 6); + assertEqual(actual[0].path.edges[0].what, "v3->v8"); + assertEqual(actual[0].path.edges.length, 1); + assertEqual(actual[0].vertex._key, "v3"); + assertEqual(actual[1].path.edges[0].what, "v1->v5"); + assertEqual(actual[1].path.edges.length, 1); + assertEqual(actual[1].vertex._key, "v5"); + assertEqual(actual[2].path.edges[0].what, "v2->v5"); + assertEqual(actual[2].path.edges.length, 1); + assertEqual(actual[2].vertex._key, "v5"); + assertEqual(actual[3].path.edges[0].what, "v3->v5"); + assertEqual(actual[3].path.edges.length, 1); + assertEqual(actual[3].vertex._key, "v5"); + assertEqual(actual[4].path.edges[0].what, "v3->v6"); + assertEqual(actual[4].path.edges.length, 1); + assertEqual(actual[4].vertex._key, "v6"); + assertEqual(actual[5].path.edges[0].what, "v3->v8"); + assertEqual(actual[5].path.edges.length, 1); + assertEqual(actual[5].vertex._key, "v8"); + }, + + testNeighborsAnyStartExampleRestrictVertices: function () { + var bindVars = { + name: gN, + example: startExample, + options: { + direction : 'any', + vertexCollectionRestriction: [v1, v3] + } + }; + var actual = getRawQueryResults(AQL_NEIGHBORS, bindVars); + assertEqual(actual.length, 8); + assertEqual(actual[0].path.edges[0].what, "v1->v2"); + assertEqual(actual[0].path.edges.length, 1); + assertEqual(actual[0].vertex._key, "v1"); + assertEqual(actual[1].path.edges[0].what, "v2->v1"); + assertEqual(actual[1].path.edges.length, 1); + assertEqual(actual[1].vertex._key, "v1"); + assertEqual(actual[2].path.edges[0].what, "v1->v2"); + assertEqual(actual[2].path.edges.length, 1); + assertEqual(actual[2].vertex._key, "v2"); + assertEqual(actual[3].path.edges[0].what, "v2->v1"); + assertEqual(actual[3].path.edges.length, 1); + assertEqual(actual[3].vertex._key, "v2"); + assertEqual(actual[4].path.edges[0].what, "v1->v5"); + assertEqual(actual[4].path.edges.length, 1); + assertEqual(actual[4].vertex._key, "v5"); + assertEqual(actual[5].path.edges[0].what, "v2->v5"); + assertEqual(actual[5].path.edges.length, 1); + assertEqual(actual[5].vertex._key, "v5"); + assertEqual(actual[6].path.edges[0].what, "v3->v5"); + assertEqual(actual[6].path.edges.length, 1); + assertEqual(actual[6].vertex._key, "v5"); + assertEqual(actual[7].path.edges[0].what, "v3->v6"); + assertEqual(actual[7].path.edges.length, 1); + assertEqual(actual[7].vertex._key, "v6"); + }, + + testNeighborsAnyStartExampleRestrictEdgesAndVertices: function () { + var bindVars = { + name: gN, + example: startExample, + options: { + direction : 'any', + vertexCollectionRestriction: [v1, v3], + edgeCollectionRestriction: e2 + } + }; + var actual = getRawQueryResults(AQL_NEIGHBORS, bindVars); + assertEqual(actual.length, 4); + assertEqual(actual[0].path.edges[0].what, "v1->v5"); + assertEqual(actual[0].path.edges.length, 1); + assertEqual(actual[0].vertex._key, "v5"); + assertEqual(actual[1].path.edges[0].what, "v2->v5"); + assertEqual(actual[1].path.edges.length, 1); + assertEqual(actual[1].vertex._key, "v5"); + assertEqual(actual[2].path.edges[0].what, "v3->v5"); + assertEqual(actual[2].path.edges.length, 1); + assertEqual(actual[2].vertex._key, "v5"); + assertEqual(actual[3].path.edges[0].what, "v3->v6"); + assertEqual(actual[3].path.edges.length, 1); + assertEqual(actual[3].vertex._key, "v6"); + }, + + //////////////////////////////////////////////////////////////////////////////// - /// @brief checks EDGES() + /// direction outbound //////////////////////////////////////////////////////////////////////////////// + + testNeighborsOutbound: function () { + var bindVars = { + name: gN, + example: v1 + "/v1", + options: { + direction : 'outbound' + } + }; + var actual = getRawQueryResults(AQL_NEIGHBORS, bindVars); + assertEqual(actual.length, 2); + assertEqual(actual[0].path.edges[0].what, "v1->v2"); + assertEqual(actual[0].path.edges.length, 1); + assertEqual(actual[0].vertex._key, "v2"); + assertEqual(actual[1].path.edges[0].what, "v1->v5"); + assertEqual(actual[1].path.edges.length, 1); + assertEqual(actual[1].vertex._key, "v5"); + }, - testEdgesIn: function () { - var actual; - - actual = getQueryResults("FOR e IN GRAPH_EDGES('bla3', 'UnitTestsAhuacatlVertex3/v5', {direction : 'inbound'}) SORT e.what RETURN e.what"); - assertEqual(actual, [ "v1->v5", "v2->v5", "v3->v5"]); - - actual = getQueryResults("FOR e IN GRAPH_EDGES('bla3', 'UnitTestsAhuacatlVertex3/v5', {direction : 'inbound' ,edgeCollectionRestriction: ['UnitTestsAhuacatlEdge2']}) SORT e.what RETURN e.what"); - assertEqual(actual, [ "v1->v5", "v2->v5", "v3->v5"]); - - actual = getQueryResults("FOR e IN GRAPH_EDGES('bla3', 'UnitTestsAhuacatlVertex3/v5', {direction : 'inbound' , edgeExamples : [{'what' : 'v2->v5'}]}) SORT e.what RETURN e.what"); - assertEqual(actual, [ "v2->v5" ]); - - actual = getQueryResults("FOR e IN GRAPH_NEIGHBORS('bla3', 'UnitTestsAhuacatlVertex3/v5', {direction : 'inbound' , edgeExamples : [{'what' : 'v2->v5'}]}) SORT e.what RETURN e"); - assertEqual(actual[0].path.edges[0].what, "v2->v5"); + testNeighborsOutboundEdgeExample: function () { + var bindVars = { + name: gN, + example: v1 + "/v1", + options: { + direction : 'outbound', + edgeExamples : [{'what' : 'v1->v2'}, {'what' : 'v2->v1'}] + } + }; + var actual = getRawQueryResults(AQL_NEIGHBORS, bindVars); + assertEqual(actual.length, 1); + assertEqual(actual[0].path.edges[0].what, "v1->v2"); + assertEqual(actual[0].path.edges.length, 1); assertEqual(actual[0].vertex._key, "v2"); }, + testNeighborsOutboundStartExample: function () { + var bindVars = { + name: gN, + example: startExample, + options: { + direction : 'outbound' + } + }; + var actual = getRawQueryResults(AQL_NEIGHBORS, bindVars); + assertEqual(actual.length, 7); + assertEqual(actual[0].path.edges[0].what, "v2->v1"); + assertEqual(actual[0].path.edges.length, 1); + assertEqual(actual[0].vertex._key, "v1"); + assertEqual(actual[1].path.edges[0].what, "v1->v2"); + assertEqual(actual[1].path.edges.length, 1); + assertEqual(actual[1].vertex._key, "v2"); + assertEqual(actual[2].path.edges[0].what, "v1->v5"); + assertEqual(actual[2].path.edges.length, 1); + assertEqual(actual[2].vertex._key, "v5"); + assertEqual(actual[3].path.edges[0].what, "v2->v5"); + assertEqual(actual[3].path.edges.length, 1); + assertEqual(actual[3].vertex._key, "v5"); + assertEqual(actual[4].path.edges[0].what, "v3->v5"); + assertEqual(actual[4].path.edges.length, 1); + assertEqual(actual[4].vertex._key, "v5"); + assertEqual(actual[5].path.edges[0].what, "v3->v6"); + assertEqual(actual[5].path.edges.length, 1); + assertEqual(actual[5].vertex._key, "v6"); + assertEqual(actual[6].path.edges[0].what, "v3->v8"); + assertEqual(actual[6].path.edges.length, 1); + assertEqual(actual[6].vertex._key, "v8"); + }, + + testNeighborsOutboundVertexExample: function () { + var bindVars = { + name: gN, + example: {}, + options: { + direction : 'outbound', + neighborExamples: vertexExample + } + }; + var actual = getRawQueryResults(AQL_NEIGHBORS, bindVars); + assertEqual(actual.length, 1); + assertEqual(actual[0].path.edges[0].what, "v2->v1"); + assertEqual(actual[0].path.edges.length, 1); + assertEqual(actual[0].vertex._key, "v1"); + }, + testNeighborsOutboundStartExampleRestrictEdges: function () { + var bindVars = { + name: gN, + example: startExample, + options: { + direction : 'outbound', + edgeCollectionRestriction: e2 + } + }; + var actual = getRawQueryResults(AQL_NEIGHBORS, bindVars); + assertEqual(actual.length, 5); + assertEqual(actual[0].path.edges[0].what, "v1->v5"); + assertEqual(actual[0].path.edges.length, 1); + assertEqual(actual[0].vertex._key, "v5"); + assertEqual(actual[1].path.edges[0].what, "v2->v5"); + assertEqual(actual[1].path.edges.length, 1); + assertEqual(actual[1].vertex._key, "v5"); + assertEqual(actual[2].path.edges[0].what, "v3->v5"); + assertEqual(actual[2].path.edges.length, 1); + assertEqual(actual[2].vertex._key, "v5"); + assertEqual(actual[3].path.edges[0].what, "v3->v6"); + assertEqual(actual[3].path.edges.length, 1); + assertEqual(actual[3].vertex._key, "v6"); + assertEqual(actual[4].path.edges[0].what, "v3->v8"); + assertEqual(actual[4].path.edges.length, 1); + assertEqual(actual[4].vertex._key, "v8"); + }, + + testNeighborsOutboundStartExampleRestrictVertices: function () { + var bindVars = { + name: gN, + example: startExample, + options: { + direction : 'outbound', + vertexCollectionRestriction: [v1, v3] + } + }; + var actual = getRawQueryResults(AQL_NEIGHBORS, bindVars); + assertEqual(actual.length, 6); + assertEqual(actual[0].path.edges[0].what, "v2->v1"); + assertEqual(actual[0].path.edges.length, 1); + assertEqual(actual[0].vertex._key, "v1"); + assertEqual(actual[1].path.edges[0].what, "v1->v2"); + assertEqual(actual[1].path.edges.length, 1); + assertEqual(actual[1].vertex._key, "v2"); + assertEqual(actual[2].path.edges[0].what, "v1->v5"); + assertEqual(actual[2].path.edges.length, 1); + assertEqual(actual[2].vertex._key, "v5"); + assertEqual(actual[3].path.edges[0].what, "v2->v5"); + assertEqual(actual[3].path.edges.length, 1); + assertEqual(actual[3].vertex._key, "v5"); + assertEqual(actual[4].path.edges[0].what, "v3->v5"); + assertEqual(actual[4].path.edges.length, 1); + assertEqual(actual[4].vertex._key, "v5"); + assertEqual(actual[5].path.edges[0].what, "v3->v6"); + assertEqual(actual[5].path.edges.length, 1); + assertEqual(actual[5].vertex._key, "v6"); + }, + + testNeighborsOutboundStartExampleRestrictEdgesAndVertices: function () { + var bindVars = { + name: gN, + example: startExample, + options: { + direction : 'outbound', + vertexCollectionRestriction: [v1, v3], + edgeCollectionRestriction: e2 + } + }; + var actual = getRawQueryResults(AQL_NEIGHBORS, bindVars); + assertEqual(actual.length, 4); + assertEqual(actual[0].path.edges[0].what, "v1->v5"); + assertEqual(actual[0].path.edges.length, 1); + assertEqual(actual[0].vertex._key, "v5"); + assertEqual(actual[1].path.edges[0].what, "v2->v5"); + assertEqual(actual[1].path.edges.length, 1); + assertEqual(actual[1].vertex._key, "v5"); + assertEqual(actual[2].path.edges[0].what, "v3->v5"); + assertEqual(actual[2].path.edges.length, 1); + assertEqual(actual[2].vertex._key, "v5"); + assertEqual(actual[3].path.edges[0].what, "v3->v6"); + assertEqual(actual[3].path.edges.length, 1); + assertEqual(actual[3].vertex._key, "v6"); + }, //////////////////////////////////////////////////////////////////////////////// - /// @brief checks EDGES() + /// inbound direction + //////////////////////////////////////////////////////////////////////////////// + + testNeighborsInbound: function () { + var bindVars = { + name: gN, + example: v1 + "/v1", + options: { + direction : 'inbound' + } + }; + var actual = getRawQueryResults(AQL_NEIGHBORS, bindVars); + assertEqual(actual.length, 1); + assertEqual(actual[0].path.edges[0].what, "v2->v1"); + assertEqual(actual[0].path.edges.length, 1); + assertEqual(actual[0].vertex._key, "v2"); + }, + + testNeighborsInboundEdgeExample: function () { + var bindVars = { + name: gN, + example: v1 + "/v1", + options: { + direction : 'inbound', + edgeExamples : [{'what' : 'v2->v1'}] + } + }; + var actual = getRawQueryResults(AQL_NEIGHBORS, bindVars); + assertEqual(actual.length, 1); + assertEqual(actual[0].path.edges[0].what, "v2->v1"); + assertEqual(actual[0].path.edges.length, 1); + assertEqual(actual[0].vertex._key, "v2"); + }, + + testNeighborsInboundStartExample: function () { + var bindVars = { + name: gN, + example: startExample, + options: { + direction : 'inbound' + } + }; + var actual = getRawQueryResults(AQL_NEIGHBORS, bindVars); + assertEqual(actual.length, 3); + assertEqual(actual[0].path.edges[0].what, "v1->v2"); + assertEqual(actual[0].path.edges.length, 1); + assertEqual(actual[0].vertex._key, "v1"); + assertEqual(actual[1].path.edges[0].what, "v2->v1"); + assertEqual(actual[1].path.edges.length, 1); + assertEqual(actual[1].vertex._key, "v2"); + assertEqual(actual[2].path.edges[0].what, "v3->v8"); + assertEqual(actual[2].path.edges.length, 1); + assertEqual(actual[2].vertex._key, "v3"); + }, + + testNeighborsInboundNeighborExample: function () { + var bindVars = { + name: gN, + example: {}, + options: { + direction : 'inbound', + neighborExamples: vertexExample + } + }; + var actual = getRawQueryResults(AQL_NEIGHBORS, bindVars); + assertEqual(actual.length, 2); + assertEqual(actual[0].path.edges[0].what, "v1->v2"); + assertEqual(actual[0].path.edges.length, 1); + assertEqual(actual[0].vertex._key, "v1"); + assertEqual(actual[1].path.edges[0].what, "v1->v5"); + assertEqual(actual[1].path.edges.length, 1); + assertEqual(actual[1].vertex._key, "v1"); + }, + + testNeighborsInboundStartExampleRestrictEdges: function () { + var bindVars = { + name: gN, + example: startExample, + options: { + direction : 'inbound', + edgeCollectionRestriction: e2 + } + }; + var actual = getRawQueryResults(AQL_NEIGHBORS, bindVars); + assertEqual(actual.length, 1); + assertEqual(actual[0].path.edges[0].what, "v3->v8"); + assertEqual(actual[0].path.edges.length, 1); + assertEqual(actual[0].vertex._key, "v3"); + }, + + testNeighborsInboundStartExampleRestrictVertices: function () { + var bindVars = { + name: gN, + example: startExample, + options: { + direction : 'inbound', + vertexCollectionRestriction: [v1, v3] + } + }; + var actual = getRawQueryResults(AQL_NEIGHBORS, bindVars); + assertEqual(actual.length, 2); + assertEqual(actual[0].path.edges[0].what, "v1->v2"); + assertEqual(actual[0].path.edges.length, 1); + assertEqual(actual[0].vertex._key, "v1"); + assertEqual(actual[1].path.edges[0].what, "v2->v1"); + assertEqual(actual[1].path.edges.length, 1); + assertEqual(actual[1].vertex._key, "v2"); + }, + + testNeighborsInboundStartExampleRestrictEdgesAndVertices: function () { + var bindVars = { + name: gN, + example: startExample, + options: { + direction : 'inbound', + vertexCollectionRestriction: [v1, v3], + edgeCollectionRestriction: e2 + } + }; + var actual = getRawQueryResults(AQL_NEIGHBORS, bindVars); + assertEqual(actual.length, 0); + }, + + //////////////////////////////////////////////////////////////////////////////// + /// @brief checks EDGES() OLD //////////////////////////////////////////////////////////////////////////////// testEdgesOut: function () { var actual; - actual = getQueryResults("FOR e IN GRAPH_EDGES('bla3', 'UnitTestsAhuacatlVertex1/v1', {direction : 'outbound'}) SORT e.what RETURN e.what"); - assertEqual(actual, [ "v1->v2", "v1->v5"]); - - actual = getQueryResults("FOR e IN GRAPH_EDGES('bla3', 'UnitTestsAhuacatlVertex1/v1', {direction : 'outbound' ,edgeCollectionRestriction: 'UnitTestsAhuacatlEdge2'}) SORT e.what RETURN e.what"); - assertEqual(actual, [ "v1->v5"]); - actual = getQueryResults("FOR e IN GRAPH_EDGES('bla3', 'UnitTestsAhuacatlVertex1/v1', {direction : 'outbound' ,edgeExamples : [{'what' : 'v2->v5'}]}) SORT e.what RETURN e.what"); - assertEqual(actual, []); - actual = getQueryResults("FOR e IN GRAPH_NEIGHBORS('bla3', 'UnitTestsAhuacatlVertex1/v1', {direction : 'outbound' ,minDepth : 1, maxDepth : 3}) SORT e.vertex._key RETURN e"); assertEqual(actual[0].vertex._key, "v1"); assertEqual(actual[1].vertex._key, "v2"); @@ -359,13 +941,6 @@ function ahuacatlQueryGeneralEdgesTestSuite() { assertEqual(actual[0].vertex._key, "v1"); assertEqual(actual[1].vertex._key, "v2"); - actual = getRawQueryResults("FOR e IN GRAPH_VERTICES('bla3', [{hugo : true}, {heinz : 1}], {direction : 'outbound'}) SORT e._id RETURN e"); - assertEqual(actual[0]._id, 'UnitTestsAhuacatlVertex1/v1'); - assertEqual(actual[1]._id, 'UnitTestsAhuacatlVertex1/v2'); - assertEqual(actual[2]._id, 'UnitTestsAhuacatlVertex2/v3'); - assertTrue(actual.length === 3); - - actual = getQueryResults("FOR e IN GRAPH_NEIGHBORS('bla3', 'UnitTestsAhuacatlVertex1/v1', {direction : 'outbound'}) SORT e.what RETURN e"); assertEqual(actual[0].path.edges[0].what, "v1->v2"); assertEqual(actual[0].vertex._key, "v2"); @@ -527,23 +1102,27 @@ function ahuacatlQueryGeneralCommonTestSuite() { /// @brief checks GRAPH_COMMON_NEIGHBORS() //////////////////////////////////////////////////////////////////////////////// - testCommonNeighborsMixedOptions: function () { + testCommonNeighborsMixedOptionsDistinctFilters: function () { var actual = getQueryResults("FOR e IN GRAPH_COMMON_NEIGHBORS('bla3', {} , {}, " + "{direction : 'outbound', vertexCollectionRestriction : 'UnitTestsAhuacatlVertex1'}, " + "{direction : 'inbound', minDepth : 1, maxDepth : 2, vertexCollectionRestriction : 'UnitTestsAhuacatlVertex2'}) SORT TO_STRING(e) RETURN e"); - assertEqual(Object.keys(actual[0])[0], "UnitTestsAhuacatlVertex1/v2"); - assertEqual(Object.keys(actual[0][Object.keys(actual[0])[0]]).sort(), ["UnitTestsAhuacatlVertex2/v5", "UnitTestsAhuacatlVertex2/v7", "UnitTestsAhuacatlVertex2/v8"]); + assertEqual(actual.length, 0); + }, - assertEqual(actual[0][Object.keys(actual[0])[0]]["UnitTestsAhuacatlVertex2/v5"].length, 1); - assertEqual(actual[0][Object.keys(actual[0])[0]]["UnitTestsAhuacatlVertex2/v8"].length, 1); - assertEqual(actual[0][Object.keys(actual[0])[0]]["UnitTestsAhuacatlVertex2/v7"].length, 2); + testCommonNeighborsMixedOptionsFilterBasedOnOneCollectionOnly: function () { + var actual = getQueryResults("FOR e IN GRAPH_COMMON_NEIGHBORS('bla3', {} , {}, " + + "{direction : 'outbound', vertexCollectionRestriction : 'UnitTestsAhuacatlVertex2'}, " + + "{direction : 'inbound', minDepth : 1, maxDepth : 2, vertexCollectionRestriction : 'UnitTestsAhuacatlVertex2'}) SORT TO_STRING(e) RETURN e"); - assertEqual(Object.keys(actual[1])[0], "UnitTestsAhuacatlVertex1/v1"); - assertEqual(Object.keys(actual[1][Object.keys(actual[1])[0]]).sort(), ["UnitTestsAhuacatlVertex2/v5", "UnitTestsAhuacatlVertex2/v6", "UnitTestsAhuacatlVertex2/v7", "UnitTestsAhuacatlVertex2/v8"]); + assertEqual(Object.keys(actual[0])[0], "UnitTestsAhuacatlVertex1/v3"); + assertEqual(Object.keys(actual[0][Object.keys(actual[0])[0]]).sort(), ["UnitTestsAhuacatlVertex1/v1", "UnitTestsAhuacatlVertex1/v2"]); + + assertEqual(actual[0][Object.keys(actual[0])[0]]["UnitTestsAhuacatlVertex1/v1"].length, 1); + assertEqual(actual[0][Object.keys(actual[0])[0]]["UnitTestsAhuacatlVertex1/v2"].length, 1); + + assertEqual(Object.keys(actual[1])[0], "UnitTestsAhuacatlVertex1/v2"); + assertEqual(Object.keys(actual[1][Object.keys(actual[1])[0]]).sort(), ["UnitTestsAhuacatlVertex2/v7"]); - assertEqual(actual[1][Object.keys(actual[1])[0]]["UnitTestsAhuacatlVertex2/v6"].length, 1); - assertEqual(actual[1][Object.keys(actual[1])[0]]["UnitTestsAhuacatlVertex2/v5"].length, 1); - assertEqual(actual[1][Object.keys(actual[1])[0]]["UnitTestsAhuacatlVertex2/v8"].length, 1); assertEqual(actual[1][Object.keys(actual[1])[0]]["UnitTestsAhuacatlVertex2/v7"].length, 1); }, From cfd284955d10fc25f97d531180d68d43a7fdb6df Mon Sep 17 00:00:00 2001 From: Michael Hackstein Date: Sun, 19 Oct 2014 21:04:58 +0200 Subject: [PATCH 3/9] Documentation fix of GRAPH_NEIGHBORS vertex restriction. --- js/server/modules/org/arangodb/ahuacatl.js | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/js/server/modules/org/arangodb/ahuacatl.js b/js/server/modules/org/arangodb/ahuacatl.js index 55ee18fee2..66657acda4 100644 --- a/js/server/modules/org/arangodb/ahuacatl.js +++ b/js/server/modules/org/arangodb/ahuacatl.js @@ -4589,7 +4589,6 @@ function TRAVERSAL_VISITOR (config, result, vertex, path) { function TRAVERSAL_NEIGHBOR_VISITOR (config, result, vertex, path) { "use strict"; - result.push(CLONE({ vertex: vertex, path: path, startVertex : config.startVertex })); } @@ -6038,8 +6037,8 @@ function GRAPH_NEIGHBORS (vertexCollection, /// * *edgeCollectionRestriction* : One or multiple edge /// collection names. Only edges from these collections will be considered for the path. /// * *vertexCollectionRestriction* : One or multiple vertex -/// collection names. Only vertices from these collections will be considered as -/// neighbor. +/// collection names. Only vertices from these collections will be contained in the +/// result. This does not effect vertices on the path. /// * *minDepth* : Defines the minimal /// depth a path to a neighbor must have to be returned (default is 1). /// * *maxDepth* : Defines the maximal @@ -6082,14 +6081,12 @@ function GENERAL_GRAPH_NEIGHBORS (graphName, } options.fromVertexExample = vertexExample; - if (! options.direction) { + if (! options.hasOwnProperty("direction")) { options.direction = 'any'; } - if (options.neighborExamples) { - if (typeof options.neighborExamples === "string") { - options.neighborExamples = {_id : options.neighborExamples}; - } + if (options.hasOwnProperty("neighborExamples") && typeof options.neighborExamples === "string") { + options.neighborExamples = {_id : options.neighborExamples}; } var neighbors = [], params = TRAVERSAL_PARAMS(), From db7b23bdb87753d8b168d73e530b950c858a8d0f Mon Sep 17 00:00:00 2001 From: Max Neunhoeffer Date: Mon, 20 Oct 2014 09:04:32 +0200 Subject: [PATCH 4/9] Fix cloning of VarOverview. --- arangod/Aql/ExecutionNode.cpp | 14 +++++--------- arangod/Aql/ExecutionNode.h | 4 ++++ 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/arangod/Aql/ExecutionNode.cpp b/arangod/Aql/ExecutionNode.cpp index 88673ba3e5..d4bbfc9ab1 100644 --- a/arangod/Aql/ExecutionNode.cpp +++ b/arangod/Aql/ExecutionNode.cpp @@ -798,7 +798,7 @@ void ExecutionNode::VarOverview::clear () { } ExecutionNode::VarOverview* ExecutionNode::VarOverview::clone (ExecutionPlan* otherPlan, ExecutionPlan* plan) { - VarOverview* other = new VarOverview(); + std::unique_ptr other(new VarOverview()); other->nrRegsHere = nrRegsHere; other->nrRegs = nrRegs; @@ -807,14 +807,10 @@ ExecutionNode::VarOverview* ExecutionNode::VarOverview::clone (ExecutionPlan* ot other->varInfo = varInfo; - /* we don't need these. - for (auto en: subQueryNodes) { - auto otherId = en->id(); - auto otherEN = otherPlan->getNodeById(otherId); - other->subQueryNodes.push_back(otherEN); - } - */ - return other; + // No need to clone subQueryNodes because this was only used during + // the buildup. + + return other.release(); } void ExecutionNode::VarOverview::after (ExecutionNode *en) { diff --git a/arangod/Aql/ExecutionNode.h b/arangod/Aql/ExecutionNode.h index b12fc05f16..35a7e7f515 100644 --- a/arangod/Aql/ExecutionNode.h +++ b/arangod/Aql/ExecutionNode.h @@ -536,9 +536,13 @@ namespace triagens { unsigned int depth; unsigned int totalNrRegs; + private: + // This is used to tell all nodes and share a pointer to ourselves shared_ptr* me; + public: + VarOverview () : depth(0), totalNrRegs(0), me(nullptr) { nrRegsHere.push_back(0); From 6eb207333651bd39481e6bb39db3d329a172fd0d Mon Sep 17 00:00:00 2001 From: Max Neunhoeffer Date: Mon, 20 Oct 2014 09:14:01 +0200 Subject: [PATCH 5/9] Rename VarOverview into RegisterPlan, because that is what it is. --- arangod/Aql/ExecutionBlock.cpp | 100 ++++++++++++++++----------------- arangod/Aql/ExecutionNode.cpp | 72 ++++++++++++------------ arangod/Aql/ExecutionNode.h | 24 ++++---- 3 files changed, 98 insertions(+), 98 deletions(-) diff --git a/arangod/Aql/ExecutionBlock.cpp b/arangod/Aql/ExecutionBlock.cpp index 0fb18c32fd..90fc682b25 100644 --- a/arangod/Aql/ExecutionBlock.cpp +++ b/arangod/Aql/ExecutionBlock.cpp @@ -571,7 +571,7 @@ int SingletonBlock::getOrSkipSome (size_t, // atLeast, } if(! skipping){ - result = new AqlItemBlock(1, getPlanNode()->getVarOverview()->nrRegs[getPlanNode()->getDepth()]); + result = new AqlItemBlock(1, getPlanNode()->getRegisterPlan()->nrRegs[getPlanNode()->getDepth()]); try { if (_inputRegisterValues != nullptr) { skipped++; @@ -697,7 +697,7 @@ AqlItemBlock* EnumerateCollectionBlock::getSome (size_t, // atLeast, size_t available = _documents.size() - _posInAllDocs; size_t toSend = (std::min)(atMost, available); - unique_ptr res(new AqlItemBlock(toSend, getPlanNode()->getVarOverview()->nrRegs[getPlanNode()->getDepth()])); + unique_ptr res(new AqlItemBlock(toSend, getPlanNode()->getRegisterPlan()->nrRegs[getPlanNode()->getDepth()])); // automatically freed if we throw TRI_ASSERT(curRegs <= res->getNrRegs()); @@ -718,7 +718,7 @@ AqlItemBlock* EnumerateCollectionBlock::getSome (size_t, // atLeast, } // The result is in the first variable of this depth, - // we do not need to do a lookup in getPlanNode()->_varOverview->varInfo, + // we do not need to do a lookup in getPlanNode()->_registerPlan->varInfo, // but can just take cur->getNrRegs() as registerId: res->setValue(j, static_cast(curRegs), AqlValue(reinterpret_cast inVars = e->variables(); for (auto v : inVars) { inVarsCur.push_back(v); - auto it = getPlanNode()->getVarOverview()->varInfo.find(v->id); - TRI_ASSERT(it != getPlanNode()->getVarOverview()->varInfo.end()); + auto it = getPlanNode()->getRegisterPlan()->varInfo.find(v->id); + TRI_ASSERT(it != getPlanNode()->getRegisterPlan()->varInfo.end()); TRI_ASSERT(it->second.registerId < ExecutionNode::MaxRegisterId); inRegsCur.push_back(it->second.registerId); } @@ -1062,7 +1062,7 @@ AqlItemBlock* IndexRangeBlock::getSome (size_t, // atLeast if (toSend > 0) { - res.reset(new AqlItemBlock(toSend, getPlanNode()->getVarOverview()->nrRegs[getPlanNode()->getDepth()])); + res.reset(new AqlItemBlock(toSend, getPlanNode()->getRegisterPlan()->nrRegs[getPlanNode()->getDepth()])); // automatically freed should we throw TRI_ASSERT(curRegs <= res->getNrRegs()); @@ -1084,7 +1084,7 @@ AqlItemBlock* IndexRangeBlock::getSome (size_t, // atLeast } // The result is in the first variable of this depth, - // we do not need to do a lookup in getPlanNode()->_varOverview->varInfo, + // we do not need to do a lookup in getPlanNode()->_registerPlan->varInfo, // but can just take cur->getNrRegs() as registerId: res->setValue(j, static_cast(curRegs), AqlValue(reinterpret_castgetVarOverview()->varInfo.find(en->_inVariable->id); - if (it == en->getVarOverview()->varInfo.end()){ + auto it = en->getRegisterPlan()->varInfo.find(en->_inVariable->id); + if (it == en->getRegisterPlan()->varInfo.end()){ THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_INTERNAL, "variable not found"); } _inVarRegId = (*it).second.registerId; @@ -1620,7 +1620,7 @@ AqlItemBlock* EnumerateListBlock::getSome (size_t, size_t atMost) { size_t toSend = (std::min)(atMost, sizeInVar - _index); // create the result - res.reset(new AqlItemBlock(toSend, getPlanNode()->getVarOverview()->nrRegs[getPlanNode()->getDepth()])); + res.reset(new AqlItemBlock(toSend, getPlanNode()->getRegisterPlan()->nrRegs[getPlanNode()->getDepth()])); inheritRegisters(cur, res.get(), _pos); @@ -1794,9 +1794,9 @@ CalculationBlock::CalculationBlock (ExecutionEngine* engine, for (auto it = inVars.begin(); it != inVars.end(); ++it) { _inVars.push_back(*it); - auto it2 = en->getVarOverview()->varInfo.find((*it)->id); + auto it2 = en->getRegisterPlan()->varInfo.find((*it)->id); - TRI_ASSERT(it2 != en->getVarOverview()->varInfo.end()); + TRI_ASSERT(it2 != en->getRegisterPlan()->varInfo.end()); TRI_ASSERT(it2->second.registerId < ExecutionNode::MaxRegisterId); _inRegs.push_back(it2->second.registerId); } @@ -1809,8 +1809,8 @@ CalculationBlock::CalculationBlock (ExecutionEngine* engine, TRI_ASSERT(_inRegs.size() == 1); } - auto it3 = en->getVarOverview()->varInfo.find(en->_outVariable->id); - TRI_ASSERT(it3 != en->getVarOverview()->varInfo.end()); + auto it3 = en->getRegisterPlan()->varInfo.find(en->_outVariable->id); + TRI_ASSERT(it3 != en->getRegisterPlan()->varInfo.end()); _outReg = it3->second.registerId; TRI_ASSERT(_outReg < ExecutionNode::MaxRegisterId); } @@ -1905,8 +1905,8 @@ SubqueryBlock::SubqueryBlock (ExecutionEngine* engine, _outReg(ExecutionNode::MaxRegisterId), _subquery(subquery) { - auto it = en->getVarOverview()->varInfo.find(en->_outVariable->id); - TRI_ASSERT(it != en->getVarOverview()->varInfo.end()); + auto it = en->getRegisterPlan()->varInfo.find(en->_outVariable->id); + TRI_ASSERT(it != en->getRegisterPlan()->varInfo.end()); _outReg = it->second.registerId; TRI_ASSERT(_outReg < ExecutionNode::MaxRegisterId); } @@ -1973,8 +1973,8 @@ FilterBlock::FilterBlock (ExecutionEngine* engine, : ExecutionBlock(engine, en), _inReg(ExecutionNode::MaxRegisterId) { - auto it = en->getVarOverview()->varInfo.find(en->_inVariable->id); - TRI_ASSERT(it != en->getVarOverview()->varInfo.end()); + auto it = en->getRegisterPlan()->varInfo.find(en->_inVariable->id); + TRI_ASSERT(it != en->getRegisterPlan()->varInfo.end()); _inReg = it->second.registerId; TRI_ASSERT(_inReg < ExecutionNode::MaxRegisterId); } @@ -2154,33 +2154,33 @@ AggregateBlock::AggregateBlock (ExecutionEngine* engine, for (auto p : en->_aggregateVariables) { // We know that planRegisters() has been run, so - // getPlanNode()->_varOverview is set up - auto itOut = en->getVarOverview()->varInfo.find(p.first->id); - TRI_ASSERT(itOut != en->getVarOverview()->varInfo.end()); + // getPlanNode()->_registerPlan is set up + auto itOut = en->getRegisterPlan()->varInfo.find(p.first->id); + TRI_ASSERT(itOut != en->getRegisterPlan()->varInfo.end()); - auto itIn = en->getVarOverview()->varInfo.find(p.second->id); - TRI_ASSERT(itIn != en->getVarOverview()->varInfo.end()); + auto itIn = en->getRegisterPlan()->varInfo.find(p.second->id); + TRI_ASSERT(itIn != en->getRegisterPlan()->varInfo.end()); TRI_ASSERT((*itIn).second.registerId < ExecutionNode::MaxRegisterId); TRI_ASSERT((*itOut).second.registerId < ExecutionNode::MaxRegisterId); _aggregateRegisters.emplace_back(make_pair((*itOut).second.registerId, (*itIn).second.registerId)); } if (en->_outVariable != nullptr) { - auto it = en->getVarOverview()->varInfo.find(en->_outVariable->id); - TRI_ASSERT(it != en->getVarOverview()->varInfo.end()); + auto it = en->getRegisterPlan()->varInfo.find(en->_outVariable->id); + TRI_ASSERT(it != en->getRegisterPlan()->varInfo.end()); _groupRegister = (*it).second.registerId; TRI_ASSERT(_groupRegister > 0 && _groupRegister < ExecutionNode::MaxRegisterId); // construct a mapping of all register ids to variable names // we need this mapping to generate the grouped output - for (size_t i = 0; i < en->getVarOverview()->varInfo.size(); ++i) { + for (size_t i = 0; i < en->getRegisterPlan()->varInfo.size(); ++i) { _variableNames.push_back(""); // initialize with some default value } // iterate over all our variables - for (auto it = en->getVarOverview()->varInfo.begin(); - it != en->getVarOverview()->varInfo.end(); ++it) { + for (auto it = en->getRegisterPlan()->varInfo.begin(); + it != en->getRegisterPlan()->varInfo.end(); ++it) { // find variable in the global variable map auto itVar = en->_variableMap.find((*it).first); @@ -2239,7 +2239,7 @@ int AggregateBlock::getOrSkipSome (size_t atLeast, unique_ptr res; if (! skipping) { - res.reset(new AqlItemBlock(atMost, getPlanNode()->getVarOverview()->nrRegs[getPlanNode()->getDepth()])); + res.reset(new AqlItemBlock(atMost, getPlanNode()->getRegisterPlan()->nrRegs[getPlanNode()->getDepth()])); TRI_ASSERT(cur->getNrRegs() <= res->getNrRegs()); inheritRegisters(cur, res.get(), _pos); @@ -2402,8 +2402,8 @@ SortBlock::SortBlock (ExecutionEngine* engine, _stable(en->_stable) { for (auto p : en->_elements) { - auto it = en->getVarOverview()->varInfo.find(p.first->id); - TRI_ASSERT(it != en->getVarOverview()->varInfo.end()); + auto it = en->getRegisterPlan()->varInfo.find(p.first->id); + TRI_ASSERT(it != en->getRegisterPlan()->varInfo.end()); TRI_ASSERT(it->second.registerId < ExecutionNode::MaxRegisterId); _sortRegisters.push_back(make_pair(it->second.registerId, p.second)); } @@ -2698,8 +2698,8 @@ AqlItemBlock* ReturnBlock::getSome (size_t atLeast, // Let's steal the actual result and throw away the vars: auto ep = static_cast(getPlanNode()); - auto it = ep->getVarOverview()->varInfo.find(ep->_inVariable->id); - TRI_ASSERT(it != ep->getVarOverview()->varInfo.end()); + auto it = ep->getRegisterPlan()->varInfo.find(ep->_inVariable->id); + TRI_ASSERT(it != ep->getRegisterPlan()->varInfo.end()); RegisterId const registerId = it->second.registerId; AqlItemBlock* stripped = new AqlItemBlock(n, 1); @@ -2852,8 +2852,8 @@ RemoveBlock::~RemoveBlock () { void RemoveBlock::work (std::vector& blocks) { auto ep = static_cast(getPlanNode()); - auto it = ep->getVarOverview()->varInfo.find(ep->_inVariable->id); - TRI_ASSERT(it != ep->getVarOverview()->varInfo.end()); + auto it = ep->getRegisterPlan()->varInfo.find(ep->_inVariable->id); + TRI_ASSERT(it != ep->getRegisterPlan()->varInfo.end()); RegisterId const registerId = it->second.registerId; auto trxCollection = _trx->trxCollection(_collection->cid()); @@ -2929,8 +2929,8 @@ InsertBlock::~InsertBlock () { void InsertBlock::work (std::vector& blocks) { auto ep = static_cast(getPlanNode()); - auto it = ep->getVarOverview()->varInfo.find(ep->_inVariable->id); - TRI_ASSERT(it != ep->getVarOverview()->varInfo.end()); + auto it = ep->getRegisterPlan()->varInfo.find(ep->_inVariable->id); + TRI_ASSERT(it != ep->getRegisterPlan()->varInfo.end()); RegisterId const registerId = it->second.registerId; auto trxCollection = _trx->trxCollection(_collection->cid()); @@ -3041,16 +3041,16 @@ UpdateBlock::~UpdateBlock () { void UpdateBlock::work (std::vector& blocks) { auto ep = static_cast(getPlanNode()); - auto it = ep->getVarOverview()->varInfo.find(ep->_inDocVariable->id); - TRI_ASSERT(it != ep->getVarOverview()->varInfo.end()); + auto it = ep->getRegisterPlan()->varInfo.find(ep->_inDocVariable->id); + TRI_ASSERT(it != ep->getRegisterPlan()->varInfo.end()); RegisterId const docRegisterId = it->second.registerId; RegisterId keyRegisterId = 0; // default initialization bool const hasKeyVariable = (ep->_inKeyVariable != nullptr); if (hasKeyVariable) { - it = ep->getVarOverview()->varInfo.find(ep->_inKeyVariable->id); - TRI_ASSERT(it != ep->getVarOverview()->varInfo.end()); + it = ep->getRegisterPlan()->varInfo.find(ep->_inKeyVariable->id); + TRI_ASSERT(it != ep->getRegisterPlan()->varInfo.end()); keyRegisterId = it->second.registerId; } @@ -3159,16 +3159,16 @@ ReplaceBlock::~ReplaceBlock () { void ReplaceBlock::work (std::vector& blocks) { auto ep = static_cast(getPlanNode()); - auto it = ep->getVarOverview()->varInfo.find(ep->_inDocVariable->id); - TRI_ASSERT(it != ep->getVarOverview()->varInfo.end()); + auto it = ep->getRegisterPlan()->varInfo.find(ep->_inDocVariable->id); + TRI_ASSERT(it != ep->getRegisterPlan()->varInfo.end()); RegisterId const registerId = it->second.registerId; RegisterId keyRegisterId = 0; // default initialization bool const hasKeyVariable = (ep->_inKeyVariable != nullptr); if (hasKeyVariable) { - it = ep->getVarOverview()->varInfo.find(ep->_inKeyVariable->id); - TRI_ASSERT(it != ep->getVarOverview()->varInfo.end()); + it = ep->getRegisterPlan()->varInfo.find(ep->_inKeyVariable->id); + TRI_ASSERT(it != ep->getRegisterPlan()->varInfo.end()); keyRegisterId = it->second.registerId; } @@ -3265,9 +3265,9 @@ GatherBlock::GatherBlock (ExecutionEngine* engine, if (! _isSimple) { for (auto p : en->getElements()) { // We know that planRegisters has been run, so - // getPlanNode()->_varOverview is set up - auto it = en->getVarOverview()->varInfo.find(p.first->id); - TRI_ASSERT(it != en->getVarOverview()->varInfo.end()); + // getPlanNode()->_registerPlan is set up + auto it = en->getRegisterPlan()->varInfo.find(p.first->id); + TRI_ASSERT(it != en->getRegisterPlan()->varInfo.end()); TRI_ASSERT(it->second.registerId < ExecutionNode::MaxRegisterId); _sortRegisters.emplace_back(make_pair(it->second.registerId, p.second)); } @@ -3974,8 +3974,8 @@ DistributeBlock::DistributeBlock (ExecutionEngine* engine, VariableId varId = ep->_varId; // get the register id of the variable to inspect . . . - auto it = ep->getVarOverview()->varInfo.find(varId); - TRI_ASSERT(it != ep->getVarOverview()->varInfo.end()); + auto it = ep->getRegisterPlan()->varInfo.find(varId); + TRI_ASSERT(it != ep->getRegisterPlan()->varInfo.end()); _regId = (*it).second.registerId; } diff --git a/arangod/Aql/ExecutionNode.cpp b/arangod/Aql/ExecutionNode.cpp index d4bbfc9ab1..16cf4b86db 100644 --- a/arangod/Aql/ExecutionNode.cpp +++ b/arangod/Aql/ExecutionNode.cpp @@ -222,11 +222,11 @@ ExecutionNode::ExecutionNode (ExecutionPlan* plan, _plan(plan), _depth(JsonHelper::checkAndGetNumericValue(json.json(), "depth")) { - TRI_ASSERT(_varOverview.get() == nullptr); - _varOverview.reset(new VarOverview()); - _varOverview->clear(); - _varOverview->depth = _depth; - _varOverview->totalNrRegs = JsonHelper::checkAndGetNumericValue(json.json(), "totalNrRegs"); + TRI_ASSERT(_registerPlan.get() == nullptr); + _registerPlan.reset(new RegisterPlan()); + _registerPlan->clear(); + _registerPlan->depth = _depth; + _registerPlan->totalNrRegs = JsonHelper::checkAndGetNumericValue(json.json(), "totalNrRegs"); auto jsonVarInfoList = json.get("varInfoList"); if (! jsonVarInfoList.isList()) { @@ -234,7 +234,7 @@ ExecutionNode::ExecutionNode (ExecutionPlan* plan, } size_t len = jsonVarInfoList.size(); - _varOverview->varInfo.reserve(len); + _registerPlan->varInfo.reserve(len); for (size_t i = 0; i < len; i++) { auto jsonVarInfo = jsonVarInfoList.at(i); @@ -245,7 +245,7 @@ ExecutionNode::ExecutionNode (ExecutionPlan* plan, RegisterId registerId = JsonHelper::checkAndGetNumericValue (jsonVarInfo.json(), "RegisterId"); unsigned int depth = JsonHelper::checkAndGetNumericValue(jsonVarInfo.json(), "depth"); - _varOverview->varInfo.emplace(make_pair(variableId, VarInfo(depth, registerId))); + _registerPlan->varInfo.emplace(make_pair(variableId, VarInfo(depth, registerId))); } auto jsonNrRegsList = json.get("nrRegs"); @@ -254,10 +254,10 @@ ExecutionNode::ExecutionNode (ExecutionPlan* plan, } len = jsonNrRegsList.size(); - _varOverview->nrRegs.reserve(len); + _registerPlan->nrRegs.reserve(len); for (size_t i = 0; i < len; i++) { RegisterId oneReg = JsonHelper::getNumericValue(jsonNrRegsList.at(i).json(), 0); - _varOverview->nrRegs.push_back(oneReg); + _registerPlan->nrRegs.push_back(oneReg); } auto jsonNrRegsHereList = json.get("nrRegsHere"); @@ -266,10 +266,10 @@ ExecutionNode::ExecutionNode (ExecutionPlan* plan, } len = jsonNrRegsHereList.size(); - _varOverview->nrRegsHere.reserve(len); + _registerPlan->nrRegsHere.reserve(len); for (size_t i = 0; i < len; i++) { RegisterId oneReg = JsonHelper::getNumericValue(jsonNrRegsHereList.at(i).json(), 0); - _varOverview->nrRegsHere.push_back(oneReg); + _registerPlan->nrRegsHere.push_back(oneReg); } auto jsonRegsToClearList = json.get("regsToClear"); @@ -375,9 +375,9 @@ void ExecutionNode::CloneHelper (ExecutionNode* other, TRI_ASSERT(var != nullptr); other->_varsValid.insert(var); } - if (_varOverview.get() != nullptr) { - auto othervarOverview = std::shared_ptr(_varOverview->clone(plan, _plan)); - other->_varOverview = othervarOverview; + if (_registerPlan.get() != nullptr) { + auto otherRegisterPlan = std::shared_ptr(_registerPlan->clone(plan, _plan)); + other->_registerPlan = otherRegisterPlan; } } else { @@ -387,7 +387,7 @@ void ExecutionNode::CloneHelper (ExecutionNode* other, other->_varUsageValid = _varUsageValid; other->_varsUsedLater = _varsUsedLater; other->_varsValid = _varsValid; - other->_varOverview = _varOverview; + other->_registerPlan = _registerPlan; } plan->registerNode(other); @@ -636,9 +636,9 @@ triagens::basics::Json ExecutionNode::toJsonHelperGeneric (triagens::basics::Jso if (verbose) { json("depth", triagens::basics::Json(static_cast(_depth))); - if (_varOverview) { - triagens::basics::Json jsonVarInfoList(triagens::basics::Json::List, _varOverview->varInfo.size()); - for (auto oneVarInfo: _varOverview->varInfo) { + if (_registerPlan) { + triagens::basics::Json jsonVarInfoList(triagens::basics::Json::List, _registerPlan->varInfo.size()); + for (auto oneVarInfo: _registerPlan->varInfo) { triagens::basics::Json jsonOneVarInfoArray(triagens::basics::Json::Array, 2); jsonOneVarInfoArray( "VariableId", @@ -650,18 +650,18 @@ triagens::basics::Json ExecutionNode::toJsonHelperGeneric (triagens::basics::Jso } json("varInfoList", jsonVarInfoList); - triagens::basics::Json jsonNRRegsList(triagens::basics::Json::List, _varOverview->nrRegs.size()); - for (auto oneRegisterID: _varOverview->nrRegs) { + triagens::basics::Json jsonNRRegsList(triagens::basics::Json::List, _registerPlan->nrRegs.size()); + for (auto oneRegisterID: _registerPlan->nrRegs) { jsonNRRegsList(triagens::basics::Json(static_cast(oneRegisterID))); } json("nrRegs", jsonNRRegsList); - triagens::basics::Json jsonNRRegsHereList(triagens::basics::Json::List, _varOverview->nrRegsHere.size()); - for (auto oneRegisterID: _varOverview->nrRegsHere) { + triagens::basics::Json jsonNRRegsHereList(triagens::basics::Json::List, _registerPlan->nrRegsHere.size()); + for (auto oneRegisterID: _registerPlan->nrRegsHere) { jsonNRRegsHereList(triagens::basics::Json(static_cast(oneRegisterID))); } json("nrRegsHere", jsonNRRegsHereList); - json("totalNrRegs", triagens::basics::Json(static_cast(_varOverview->totalNrRegs))); + json("totalNrRegs", triagens::basics::Json(static_cast(_registerPlan->totalNrRegs))); } else { json("varInfoList", triagens::basics::Json(triagens::basics::Json::List)); @@ -719,12 +719,12 @@ struct RegisterPlanningDebugger : public WalkerWorker { std::cout << ep->getTypeString() << " "; std::cout << "regsUsedHere: "; for (auto v : ep->getVariablesUsedHere()) { - std::cout << ep->getVarOverview()->varInfo.find(v->id)->second.registerId + std::cout << ep->getRegisterPlan()->varInfo.find(v->id)->second.registerId << " "; } std::cout << "regsSetHere: "; for (auto v : ep->getVariablesSetHere()) { - std::cout << ep->getVarOverview()->varInfo.find(v->id)->second.registerId + std::cout << ep->getRegisterPlan()->varInfo.find(v->id)->second.registerId << " "; } std::cout << "regsToClear: "; @@ -742,12 +742,12 @@ struct RegisterPlanningDebugger : public WalkerWorker { void ExecutionNode::planRegisters (ExecutionNode* super) { // std::cout << triagens::arango::ServerState::instance()->getId() << ": PLAN REGISTERS\n"; // The super is only for the case of subqueries. - shared_ptr v; + shared_ptr v; if (super == nullptr) { - v.reset(new VarOverview()); + v.reset(new RegisterPlan()); } else { - v.reset(new VarOverview(*(super->_varOverview), super->_depth)); + v.reset(new RegisterPlan(*(super->_registerPlan), super->_depth)); } v->setSharedPtr(&v); @@ -769,12 +769,12 @@ void ExecutionNode::planRegisters (ExecutionNode* super) { } // ----------------------------------------------------------------------------- -// --SECTION-- struct ExecutionNode::VarOverview +// --SECTION-- struct ExecutionNode::RegisterPlan // ----------------------------------------------------------------------------- // Copy constructor used for a subquery: -ExecutionNode::VarOverview::VarOverview (VarOverview const& v, - unsigned int newdepth) +ExecutionNode::RegisterPlan::RegisterPlan (RegisterPlan const& v, + unsigned int newdepth) : varInfo(v.varInfo), nrRegsHere(v.nrRegsHere), nrRegs(v.nrRegs), @@ -788,7 +788,7 @@ ExecutionNode::VarOverview::VarOverview (VarOverview const& v, nrRegs.push_back(nrRegs.back()); } -void ExecutionNode::VarOverview::clear () { +void ExecutionNode::RegisterPlan::clear () { varInfo.clear(); nrRegsHere.clear(); nrRegs.clear(); @@ -797,8 +797,8 @@ void ExecutionNode::VarOverview::clear () { totalNrRegs = 0; } -ExecutionNode::VarOverview* ExecutionNode::VarOverview::clone (ExecutionPlan* otherPlan, ExecutionPlan* plan) { - std::unique_ptr other(new VarOverview()); +ExecutionNode::RegisterPlan* ExecutionNode::RegisterPlan::clone (ExecutionPlan* otherPlan, ExecutionPlan* plan) { + std::unique_ptr other(new RegisterPlan()); other->nrRegsHere = nrRegsHere; other->nrRegs = nrRegs; @@ -813,7 +813,7 @@ ExecutionNode::VarOverview* ExecutionNode::VarOverview::clone (ExecutionPlan* ot return other.release(); } -void ExecutionNode::VarOverview::after (ExecutionNode *en) { +void ExecutionNode::RegisterPlan::after (ExecutionNode *en) { switch (en->getType()) { case ExecutionNode::ENUMERATE_COLLECTION: case ExecutionNode::INDEX_RANGE: { @@ -964,7 +964,7 @@ void ExecutionNode::VarOverview::after (ExecutionNode *en) { } en->_depth = depth; - en->_varOverview = *me; + en->_registerPlan = *me; // Now find out which registers ought to be erased after this node: if (en->getType() != ExecutionNode::RETURN) { diff --git a/arangod/Aql/ExecutionNode.h b/arangod/Aql/ExecutionNode.h index 35a7e7f515..29e0ae8512 100644 --- a/arangod/Aql/ExecutionNode.h +++ b/arangod/Aql/ExecutionNode.h @@ -513,7 +513,7 @@ namespace triagens { } }; - struct VarOverview : public WalkerWorker { + struct RegisterPlan : public WalkerWorker { // The following are collected for global usage in the ExecutionBlock, // although they are stored here in the node: @@ -539,11 +539,11 @@ namespace triagens { private: // This is used to tell all nodes and share a pointer to ourselves - shared_ptr* me; + shared_ptr* me; public: - VarOverview () + RegisterPlan () : depth(0), totalNrRegs(0), me(nullptr) { nrRegsHere.push_back(0); nrRegs.push_back(0); @@ -551,13 +551,13 @@ namespace triagens { void clear (); - void setSharedPtr (shared_ptr* shared) { + void setSharedPtr (shared_ptr* shared) { me = shared; } // Copy constructor used for a subquery: - VarOverview (VarOverview const& v, unsigned int newdepth); - ~VarOverview () {}; + RegisterPlan (RegisterPlan const& v, unsigned int newdepth); + ~RegisterPlan () {}; virtual bool enterSubquery (ExecutionNode*, ExecutionNode*) { @@ -566,7 +566,7 @@ namespace triagens { virtual void after (ExecutionNode *eb); - VarOverview* clone(ExecutionPlan* otherPlan, ExecutionPlan* plan); + RegisterPlan* clone(ExecutionPlan* otherPlan, ExecutionPlan* plan); }; @@ -577,12 +577,12 @@ namespace triagens { void planRegisters (ExecutionNode* super = nullptr); //////////////////////////////////////////////////////////////////////////////// -/// @brief get varOverview +/// @brief get RegisterPlan //////////////////////////////////////////////////////////////////////////////// - VarOverview const* getVarOverview () const { - TRI_ASSERT(_varOverview.get() != nullptr); - return _varOverview.get(); + RegisterPlan const* getRegisterPlan () const { + TRI_ASSERT(_registerPlan.get() != nullptr); + return _registerPlan.get(); } //////////////////////////////////////////////////////////////////////////////// @@ -706,7 +706,7 @@ namespace triagens { /// @brief info about variables, filled in by planRegisters //////////////////////////////////////////////////////////////////////////////// - std::shared_ptr _varOverview; + std::shared_ptr _registerPlan; //////////////////////////////////////////////////////////////////////////////// /// @brief depth of the current frame, will be filled in by planRegisters From a783081742d0f918b5151f9922d447da924a2c1a Mon Sep 17 00:00:00 2001 From: Michael Hackstein Date: Mon, 20 Oct 2014 09:36:35 +0200 Subject: [PATCH 6/9] Made useage of the model more backbone like in queryView --- js/apps/system/aardvark/frontend/js/views/queryView.js | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/js/apps/system/aardvark/frontend/js/views/queryView.js b/js/apps/system/aardvark/frontend/js/views/queryView.js index 9c46614413..f2354a011f 100644 --- a/js/apps/system/aardvark/frontend/js/views/queryView.js +++ b/js/apps/system/aardvark/frontend/js/views/queryView.js @@ -411,8 +411,8 @@ this.collection.each(function(model) { self.customQueries.push({ - name: model.attributes.name, - value: model.attributes.value + name: model.get("name"), + value: model.get("value") }); }); }, From 5510f7eee838a596ab90c81ce694c48b45f4ded2 Mon Sep 17 00:00:00 2001 From: Jan Steemann Date: Mon, 20 Oct 2014 09:51:33 +0200 Subject: [PATCH 7/9] indentation --- arangod/Aql/ExecutionBlock.cpp | 10 +++++----- arangod/Aql/ExecutionBlock.h | 11 +++++++---- 2 files changed, 12 insertions(+), 9 deletions(-) diff --git a/arangod/Aql/ExecutionBlock.cpp b/arangod/Aql/ExecutionBlock.cpp index 0fb18c32fd..dc1917c139 100644 --- a/arangod/Aql/ExecutionBlock.cpp +++ b/arangod/Aql/ExecutionBlock.cpp @@ -3821,7 +3821,7 @@ bool BlockWithClients::preInitCursor () { int ScatterBlock::initializeCursor (AqlItemBlock* items, size_t pos) { - if (!preInitCursor()) { + if (! preInitCursor()) { return TRI_ERROR_NO_ERROR; } @@ -3842,7 +3842,7 @@ int ScatterBlock::initializeCursor (AqlItemBlock* items, size_t pos) { /// @brief hasMoreForShard: any more for shard ? //////////////////////////////////////////////////////////////////////////////// -bool ScatterBlock::hasMoreForShard (std::string const& shardId){ +bool ScatterBlock::hasMoreForShard (std::string const& shardId) { size_t clientId = getClientId(shardId); if (_doneForClient.at(clientId)) { @@ -3897,7 +3897,7 @@ int64_t ScatterBlock::remainingForShard (std::string const& shardId) { int ScatterBlock::getOrSkipSomeForShard (size_t atLeast, size_t atMost, bool skipping, AqlItemBlock*& result, - size_t& skipped, std::string const& shardId){ + size_t& skipped, std::string const& shardId) { TRI_ASSERT(0 < atLeast && atLeast <= atMost); TRI_ASSERT(result == nullptr && skipped == 0); @@ -3967,8 +3967,8 @@ DistributeBlock::DistributeBlock (ExecutionEngine* engine, DistributeNode const* ep, std::vector const& shardIds, Collection const* collection) - : BlockWithClients(engine, ep, shardIds), - _collection(collection) { + : BlockWithClients(engine, ep, shardIds), + _collection(collection) { // get the variable to inspect . . . VariableId varId = ep->_varId; diff --git a/arangod/Aql/ExecutionBlock.h b/arangod/Aql/ExecutionBlock.h index 1a64de131d..7ffe6a7e7e 100644 --- a/arangod/Aql/ExecutionBlock.h +++ b/arangod/Aql/ExecutionBlock.h @@ -1684,13 +1684,15 @@ namespace triagens { ScatterBlock (ExecutionEngine* engine, ScatterNode const* ep, std::vector const& shardIds) - : BlockWithClients(engine, ep, shardIds) {} + : BlockWithClients(engine, ep, shardIds) { + } //////////////////////////////////////////////////////////////////////////////// /// @brief destructor //////////////////////////////////////////////////////////////////////////////// - ~ScatterBlock () {} + ~ScatterBlock () { + } //////////////////////////////////////////////////////////////////////////////// /// @brief initializeCursor @@ -1755,7 +1757,8 @@ namespace triagens { /// @brief destructor //////////////////////////////////////////////////////////////////////////////// - ~DistributeBlock () {} + ~DistributeBlock () { + } //////////////////////////////////////////////////////////////////////////////// /// @brief initializeCursor @@ -1767,7 +1770,7 @@ namespace triagens { /// @brief remainingForShard: remaining for shard ? //////////////////////////////////////////////////////////////////////////////// - int64_t remainingForShard (std::string const& shardId){ + int64_t remainingForShard (std::string const& shardId) { return -1; } From 4cbb5ea9394242c4ee1599db8e4682cb428c57fd Mon Sep 17 00:00:00 2001 From: Jan Steemann Date: Mon, 20 Oct 2014 09:58:46 +0200 Subject: [PATCH 8/9] fixed wrong if statement --- arangod/V8Server/v8-query.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/arangod/V8Server/v8-query.cpp b/arangod/V8Server/v8-query.cpp index 72bde27fea..af85b8be65 100644 --- a/arangod/V8Server/v8-query.cpp +++ b/arangod/V8Server/v8-query.cpp @@ -280,7 +280,7 @@ static int SetupExampleObject (v8::Handle const example, static TRI_index_operator_t* SetupConditionsSkiplist (TRI_index_t* idx, TRI_shaper_t* shaper, v8::Handle conditions) { - TRI_index_operator_t* lastOperator = 0; + TRI_index_operator_t* lastOperator = nullptr; size_t numEq = 0; size_t lastNonEq = 0; @@ -449,7 +449,7 @@ static TRI_index_operator_t* SetupConditionsSkiplist (TRI_index_t* idx, MEM_ERROR: TRI_FreeJson(TRI_UNKNOWN_MEM_ZONE, parameters); - if (lastOperator == nullptr) { + if (lastOperator != nullptr) { TRI_FreeIndexOperator(lastOperator); } From 5c1d01068adbf9bc78152292fd8e3c0909ce21f4 Mon Sep 17 00:00:00 2001 From: Jan Steemann Date: Mon, 20 Oct 2014 10:00:41 +0200 Subject: [PATCH 9/9] log a warning if an AQL user functions throws an exception --- js/server/modules/org/arangodb/aql.js | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/js/server/modules/org/arangodb/aql.js b/js/server/modules/org/arangodb/aql.js index 00aaf3d60e..e799ad086e 100644 --- a/js/server/modules/org/arangodb/aql.js +++ b/js/server/modules/org/arangodb/aql.js @@ -33,6 +33,7 @@ var TRAVERSAL = require("org/arangodb/graph/traversal"); var ArangoError = require("org/arangodb").ArangoError; var ShapedJson = INTERNAL.ShapedJson; var isCoordinator = require("org/arangodb/cluster").isCoordinator(); +var console = require("console"); // ----------------------------------------------------------------------------- // --SECTION-- private variables @@ -491,9 +492,14 @@ function FCALL_USER (name, parameters) { } if (UserFunctions[prefix].hasOwnProperty(name)) { - var result = UserFunctions[prefix][name].func.apply(null, parameters); - - return FIX_VALUE(result); + try { + var result = UserFunctions[prefix][name].func.apply(null, parameters); + return FIX_VALUE(result); + } + catch (err) { + console.warn("AQL user function '%s' returned an exception. result is converted to null", name); + return null; + } } THROW(INTERNAL.errors.ERROR_QUERY_FUNCTION_NOT_FOUND, NORMALIZE_FNAME(name));