public void ExhaustMergeAppendStepToNodeQuery()
 {
     var query = new NodeReference(123).OutV<object>().ExhaustMerge();
     Assert.IsInstanceOf<IGremlinNodeQuery<object>>(query);
     Assert.AreEqual("g.v(p0).outV.exhaustMerge", query.QueryText);
     Assert.AreEqual(123, query.QueryParameters["p0"]);
 }

 public void InShouldAppendStepToGremlinQueryWithNoFilter()
 {
     var query = new NodeReference(123).In<object>("REL");
     Assert.AreEqual("g.v(p0).in(p1)", query.QueryText);
     Assert.AreEqual(123, query.QueryParameters["p0"]);
     Assert.AreEqual("REL", query.QueryParameters["p1"]);
 }

 public void GremlinDistinctAppendStepToRelationshipQuery()
 {
     var query = new NodeReference(123).OutE().GremlinDistinct();
     Assert.IsInstanceOf<IGremlinRelationshipQuery>(query);
     Assert.AreEqual("g.v(p0).outE.dedup()", query.QueryText);
     Assert.AreEqual(123, query.QueryParameters["p0"]);
 }

 public void EmitPropertyShouldAppendStepToTypedRelationshipQuery()
 {
     var query = new NodeReference(123).OutE<object>().EmitProperty("foo");
     Assert.IsInstanceOf<IGremlinRelationshipQuery<object>>(query);
     Assert.AreEqual("g.v(p0).outE.foo", query.QueryText);
     Assert.AreEqual(123, query.QueryParameters["p0"]);
 }

 public void GremlinDistinctAppendStepToNodeQuery()
 {
     var query = new NodeReference(123).OutV<object>().GremlinDistinct();
     Assert.IsInstanceOf<IGremlinNodeQuery<object>>(query);
     Assert.AreEqual("g.v(p0).outV.dedup()", query.QueryText);
     Assert.AreEqual(123, query.QueryParameters["p0"]);
 }

 public void ClientShouldReturnClientFromReference()
 {
     var client = Substitute.For<IGraphClient>();
     var reference = new NodeReference<object>(123, client);
     var node = new Node<object>(new object(), reference);
     Assert.AreEqual(client, ((IGremlinQuery)node).Client);
 }

		/// <summary>
		/// Represents a request for sensor data.
		/// </summary>
		/// <param name="Types">Readout types to read.</param>
		/// <param name="From">From what timestamp readout is desired.</param>
		/// <param name="To">To what timestamp readout is desired.</param>
		/// <param name="Nodes">Nodes to read.</param>
		public ReadoutRequest (ReadoutType Types, DateTime From, DateTime To, NodeReference[] Nodes)
		{
			this.types = Types;
			this.from = From;
			this.to = To;
			this.nodes = Nodes;
		}

 public void BackVShouldAppendStep()
 {
     var query = new NodeReference(123).BackV<object>("foo");
     Assert.AreEqual("g.v(p0).back(p1)", query.QueryText);
     Assert.AreEqual(123, query.QueryParameters["p0"]);
     Assert.AreEqual("foo", query.QueryParameters["p1"]);
 }

 public void GremlinHasNextAppendStepToTypedRelationshipQuery()
 {
     var query = new NodeReference(123).OutE<object>().GremlinHasNext();
     Assert.IsInstanceOf<IGremlinRelationshipQuery<object>>(query);
     Assert.AreEqual("g.v(p0).outE.hasNext()", query.QueryText);
     Assert.AreEqual(123, query.QueryParameters["p0"]);
 }

 public void ExhaustMergeAppendStepToRelationshipQuery()
 {
     var query = new NodeReference(123).OutE().ExhaustMerge();
     Assert.IsInstanceOf<IGremlinRelationshipQuery>(query);
     Assert.AreEqual("g.v(p0).outE.exhaustMerge", query.QueryText);
     Assert.AreEqual(123, query.QueryParameters["p0"]);
 }

 public void OutVShouldAppendStepToNodeReference()
 {
     var node = new NodeReference(123);
     var query = node.OutV<object>();
     Assert.AreEqual("g.v(p0).outV", query.QueryText);
     Assert.AreEqual(123, query.QueryParameters["p0"]);
 }

        // graph constructor is marked INTERNAL because we want the client to use the
        // static class factory method CreateGraph(), which redirects here after doing checks.
        // For opening existing graphs,
        // we provide another method called OpenGraph() which redirects here also.
        internal GlGraph(string graph_name)
        {
            bool creating_new = !GlobalsGraphAdmin.AllGraphs().Contains(graph_name);

            _GlNodeRef = GlobalsGraphAdmin.ActiveConnection().CreateNodeReference(graph_name);

            if (creating_new)
                _GlNodeRef.Set(GlobalsGraphAdmin.GL_GRAPH_FLAG); // format identifier, causes persistence
            else
            {
                // opening an existing graph. Start by initializing the existing nodes
                string loop_node_guid = _GlNodeRef.NextSubscript(GlobalsGraphAdmin.GL_NODES_SUBSCRIPT, "");
                while (loop_node_guid != "")
                {
                    Guid new_guid = Guid.Empty;

                    if (Guid.TryParse(loop_node_guid, out new_guid))
                        AllNodesByGuid.Add(new_guid, new GlGraphNode(this, new_guid));
                    else
                        _GlNodeRef.Kill(GlobalsGraphAdmin.GL_NODES_SUBSCRIPT, loop_node_guid); // clean up bad data

                    loop_node_guid = _GlNodeRef.NextSubscript(GlobalsGraphAdmin.GL_NODES_SUBSCRIPT, loop_node_guid);
                }

                // now loop again and load the edges
                foreach (GlGraphNode loop_node in AllNodes)
                {
                    loop_node.InitializeEdges();
                }
            }
        }

 public void CypherShouldStartQueryFromCurrentNodeReference()
 {
     var graphClient = Substitute.For<IRawGraphClient>();
     var reference = new NodeReference(123, graphClient);
     var query = reference.StartCypher("foo").Query;
     Assert.AreEqual("START foo=node({p0})", query.QueryText);
     Assert.AreEqual(123, query.QueryParameters["p0"]);
 }

 public void LoopVShouldAppendStep()
 {
     var query = new NodeReference(123).LoopV<object>("foo", 6);
     Assert.AreEqual("g.v(p0).loop(p1){ it.loops < p2 }", query.QueryText);
     Assert.AreEqual(123, query.QueryParameters["p0"]);
     Assert.AreEqual("foo", query.QueryParameters["p1"]);
     Assert.AreEqual(6, query.QueryParameters["p2"]);
 }

 public void IfThenElseVShouldAppendSteps()
 {
     var query = new NodeReference(123).IfThenElse(
         new GremlinIterator().OutV<object>().GremlinHasNext(),
         null,
         null);
     Assert.AreEqual("g.v(p0).ifThenElse{it.outV.hasNext()}{}{}", query.QueryText);
 }

 public void InEShouldAppendStepToGremlinQueryWithLabel()
 {
     var query = new NodeReference(123).InE("FOO");
     Assert.AreEqual("g.v(p0).inE.filter{ it[p1].equals(p2) }", query.QueryText);
     Assert.AreEqual(123, query.QueryParameters["p0"]);
     Assert.AreEqual("label", query.QueryParameters["p1"]);
     Assert.AreEqual("FOO", query.QueryParameters["p2"]);
 }

 public void AsShouldAppendStepToRelationshipQuery()
 {
     var query = new NodeReference(123).OutE().As("foo");
     Assert.IsInstanceOf<IGremlinRelationshipQuery>(query);
     Assert.AreEqual("g.v(p0).outE.as(p1)", query.QueryText);
     Assert.AreEqual(123, query.QueryParameters["p0"]);
     Assert.AreEqual("foo", query.QueryParameters["p1"]);
 }

 public void AsShouldAppendStepToNodeQuery()
 {
     var query = new NodeReference(123).OutV<object>().As("foo");
     Assert.IsInstanceOf<IGremlinNodeQuery<object>>(query);
     Assert.AreEqual("g.v(p0).outV.as(p1)", query.QueryText);
     Assert.AreEqual(123, query.QueryParameters["p0"]);
     Assert.AreEqual("foo", query.QueryParameters["p1"]);
 }

 public void CypherQueryShouldPreserveClientReference()
 {
     var client = Substitute.For<IRawGraphClient>();
     var reference = new NodeReference<object>(123, client);
     var node = new Node<object>(new object(), reference);
     var queryBuilder = (IAttachedReference)node.StartCypher("foo");
     Assert.AreEqual(client, queryBuilder.Client);
 }

 public void CopySplitVShouldMoveInlineBlockVariablesToTheOuterScopeInFinallyQueryUsingStoreV()
 {
     var query = new NodeReference(123).CopySplitE(new IdentityPipe().Out<object>("foo").StoreV<object>("xyz"), new IdentityPipe().Out<object>("bar")).Out<object>("baz");
     Assert.AreEqual("xyz = [];g.v(p0)._.copySplit(_().out(p1).store(xyz), _().out(p2)).out(p3)", query.QueryText);
     Assert.AreEqual(123, query.QueryParameters["p0"]);
     Assert.AreEqual("foo", query.QueryParameters["p1"]);
     Assert.AreEqual("bar", query.QueryParameters["p2"]);
     Assert.AreEqual("baz", query.QueryParameters["p3"]);
 }