rgraphum 0.0.1.alpha

data/test/lib/rgraphum/graph_test.rb

@@ -0,0 +1,512 @@
+# -*- coding: utf-8 -*-
+
+require 'rgraphum'
+require 'test_helper'
+
+class RgraphumTest < MiniTest::Test
+  def setup
+    make_test_graph
+  end
+
+  def test_constractor
+    hash_vertices = [
+      {id: 1, label: "hoge" },
+      {id: 2, label: "huga" },
+    ]
+    hash_edges = [
+      {id: 1, source: 1, target: 2, weight: 1},
+      {id: 2, source: 2, target: 1, weight: 1},
+    ]
+
+    @graph = Rgraphum::Graph.new(vertices: hash_vertices, edges: hash_edges)
+
+    assert_instance_of Rgraphum::Vertices, @graph.vertices
+    assert_instance_of Rgraphum::Edges,    @graph.edges
+
+    @graph.vertices.each do |vertex|
+      assert_instance_of Rgraphum::Vertex, vertex
+    end
+    @graph.edges.each do |edge|
+      assert_instance_of Rgraphum::Edge, edge
+    end
+
+    rg_assert_equal @graph.vertices[0].edges[0].source, @graph.vertices[0]
+    rg_assert_equal @graph.vertices[0].edges[1].source, @graph.vertices[1]
+    rg_assert_equal @graph.vertices[1].edges[0].source, @graph.vertices[0]
+    rg_assert_equal @graph.vertices[1].edges[1].source, @graph.vertices[1]
+
+    rg_assert_equal @graph.vertices[0].edges[0].target, @graph.vertices[1]
+    rg_assert_equal @graph.vertices[0].edges[1].target, @graph.vertices[0]
+    rg_assert_equal @graph.vertices[1].edges[0].target, @graph.vertices[1]
+    rg_assert_equal @graph.vertices[1].edges[1].target, @graph.vertices[0]
+  end
+
+  def test_basic_method
+    assert_instance_of Rgraphum::Vertices, @graph_a.vertices
+    assert_instance_of Rgraphum::Edges,    @graph_a.edges
+
+    assert @graph_a.vertices.graph
+    assert @graph_a.edges.graph
+
+    # 基本統計量
+    assert_equal 2, @graph_a.m
+    assert_equal 2, @graph_b.m
+    assert_equal 2, @graph_a.m_with_weight
+    assert_equal 4, @graph_b.m_with_weight
+    assert_equal 2, @graph_a.average_degree
+    assert_equal 2, @graph_b.average_degree
+
+    # vertex_ids
+    assert_equal [1, 2], @graph_a.vertices.id
+    assert_equal 1, @graph_a.vertices.id.first
+    assert_equal 2, @graph_a.vertices.id.last
+
+    # edges
+    edges = @graph_a.edges
+
+    assert edges
+    assert_equal 2, edges.size
+    assert_same edges[0].target, edges[1].source
+    assert_same edges[0].source, edges[1].target
+    assert_same @graph_a.vertices[0], edges[0].source
+    assert_same @graph_a.vertices[0], edges[1].target
+    assert_same @graph_a.vertices[1], edges[1].source
+    assert_same @graph_a.vertices[1], edges[0].target
+
+    assert_equal 2, @graph_a.vertices[0].edges.size
+    assert_equal 2, @graph_a.vertices[1].edges.size
+
+
+    edge_ids = @graph_a.edges.id
+    # edge_ids
+    assert edge_ids
+    assert_equal 1, edge_ids.first
+    assert_equal 2, edge_ids.last
+
+    @graph_a.vertices = [{label: "hoge"}, {label: "hoge"}]
+    vertices = @graph_a.vertices
+    rg_assert_equal [{id: 0, label: "hoge"}, {id: 1, label: "hoge"}], vertices
+  end
+
+  def test_delete_edge
+    delete_edge = @graph_a.edges.where(id: 1).first
+    remain_edge = @graph_a.edges.where(id: 2).first
+    @graph_a.edges.delete(delete_edge)
+    rg_assert_equal ([remain_edge]), @graph_a.edges
+    rg_assert_equal ([remain_edge]), @graph_a.vertices[0].edges
+
+    delete_edge = @graph_b.edges.where(id: 1).first
+    remain_edge = @graph_b.vertices[0].edges.where(id: 2).first
+    @graph_b.vertices[0].edges.delete(delete_edge)
+    rg_assert_equal ([remain_edge]), @graph_b.edges
+    rg_assert_equal ([remain_edge]), @graph_b.vertices[0].edges
+  end
+
+  def test_delete_edge_with_id
+    remain_edge = @graph_a.edges.where(id: 2).first
+    @graph_a.edges.delete(1)
+    rg_assert_equal ([remain_edge]), @graph_a.edges
+    rg_assert_equal ([remain_edge]), @graph_a.vertices[0].edges
+
+    remain_edge = @graph_b.vertices[0].edges.where(id: 2).first
+    @graph_b.vertices[0].edges.delete(1)
+    rg_assert_equal ([remain_edge]), @graph_b.edges
+    rg_assert_equal ([remain_edge]), @graph_b.vertices[0].edges
+  end
+
+  def test_vertex
+    assert_equal 2, @graph_a.vertices[0].degree
+    assert_equal 2, @graph_a.vertices[0].degree_weight
+  end
+
+  def test_find_by_some_key
+    # find_by_labbel
+    vertex = @graph_a.vertices.where(label: "hoge").first
+    rg_assert_equal @graph_a.vertices[0], vertex
+    assert_same @graph_a.vertices[0], vertex
+  end
+
+  def test_where_condition
+    vertex = @graph_a.vertices.where(label: "hoge").first
+    rg_assert_equal @graph_a.vertices[0], vertex
+    assert_same @graph_a.vertices[0], vertex
+  end
+
+  def test_id_aspect!
+    id_aspect_vertices =  @graph_a.id_aspect!.vertices
+    rg_assert_equal [ {:id=>1, :label=>"hoge" }, {:id=>2, :label=>"huga"} ], id_aspect_vertices
+    expected = [
+      {:id=>1, :source=>1, :target=>2, :weight=>1 },
+      {:id=>2, :source=>2, :target=>1, :weight=>1 },
+    ]
+    rg_assert_equal expected, id_aspect_vertices[0].edges
+    expected = [
+      {:id=>1, :source=>1, :target=>2, :weight=>1 },
+      {:id=>2, :source=>2, :target=>1, :weight=>1 },
+    ]
+    rg_assert_equal expected, id_aspect_vertices[1].edges
+  end
+
+  def test_real_aspect!
+    real_aspect_vertices = @graph_a.real_aspect!.vertices
+
+    assert_equal 2, real_aspect_vertices.size
+    rg_assert_equal real_aspect_vertices[0], real_aspect_vertices[0].edges[0].source
+    rg_assert_equal real_aspect_vertices[1], real_aspect_vertices[0].edges[0].target
+    rg_assert_equal real_aspect_vertices[1], real_aspect_vertices[1].edges[1].source
+    rg_assert_equal real_aspect_vertices[0], real_aspect_vertices[1].edges[1].target
+  end
+
+  def test_compact_with
+    Rgraphum::Vertex.class_eval {
+      field :hoge
+    }
+    @graph_a.vertices.each { |vertex| vertex.hoge = vertex.label }
+    graph = @graph_a + @graph_a
+    graph = graph.compact_with(:hoge, graph)
+
+    graph.id_aspect!
+
+    expected = [
+      { :id=>1, :source=>1, :target=>2, :weight=>2 },
+      { :id=>2, :source=>2, :target=>1, :weight=>2 },
+    ]
+    rg_assert_equal expected, graph.edges
+
+    expected = [
+      { :id=>1, :label=>"hoge", :hoge =>"hoge" },
+      { :id=>2, :label=>"huga", :hoge =>"huga" },
+    ]
+    rg_assert_equal expected, graph.vertices
+
+    expected = [
+      { :id=>1, :source=>1, :target=>2, :weight=>2 },
+      { :id=>2, :source=>2, :target=>1, :weight=>2 },
+    ]
+    rg_assert_equal expected, graph.vertices[0].edges
+    expected = [
+      { :id=>1, :source=>1, :target=>2, :weight=>2 },
+      { :id=>2, :source=>2, :target=>1, :weight=>2 },
+    ]
+    rg_assert_equal expected, graph.vertices[1].edges
+  end
+
+  def test_compact_with_label
+    graph = @graph_a + @graph_a
+    graph.compact_with_label.id_aspect!
+
+    expected = [
+      { :id=>1, :source=>1, :target=>2, :weight=>2 },
+      { :id=>2, :source=>2, :target=>1, :weight=>2 },
+    ]
+    rg_assert_equal expected, graph.edges
+
+    expected = [
+      { :id=>1, :label=>"hoge" },
+      { :id=>2, :label=>"huga" },
+    ]
+    rg_assert_equal expected, graph.vertices
+
+    expected = [
+      { :id=>1, :source=>1, :target=>2, :weight=>2 },
+      { :id=>2, :source=>2, :target=>1, :weight=>2 },
+    ]
+    rg_assert_equal expected, graph.vertices[0].edges
+    expected = [
+      { :id=>1, :source=>1, :target=>2, :weight=>2 },
+      { :id=>2, :source=>2, :target=>1, :weight=>2 },
+    ]
+    rg_assert_equal expected, graph.vertices[1].edges
+  end
+
+  def test_add_vertex_with_no_id_added_id
+    @graph = Rgraphum::Graph.new
+    @graph.vertices = [{ :label => "huga" },{ :label => "huga" }]
+    assert_equal ([0,1]), @graph.vertices.id
+
+    @graph.vertices << { :label => "piyo" }
+    rg_assert_equal ( { :id => 2, :label => "piyo" } ), @graph.vertices.where(label: "piyo").first
+    assert_equal ([0,1,2]), @graph.vertices.id
+  end
+
+  def test_add_edge_with_no_id_add_id
+    #  0 - 1
+    #   \ /
+    #    2
+    #   / \
+    #  3 - 4
+
+    # add edge to graph
+    @graph = Rgraphum::Graph.new
+    @graph.vertices = [
+      { id: 0, label: "A", community_id: 1 },
+      { id: 1, label: "B", community_id: 1 },
+      {id:2,label:"C"},
+      {id:3,label:"D"},
+      {id:4,label:"E"},
+    ]
+    @graph.edges = [
+      {source:0,target:1,weight:1},
+      {source:0,target:2,weight:1},
+      {source:1,target:2,weight:1},
+      {source:2,target:3,weight:1},
+      {source:2,target:4,weight:1},
+      {source:3,target:4,weight:1},
+    ]
+
+    @graph.id_aspect!
+    rg_assert_equal({id:0,source:0,target:1,weight:1}, @graph.edges[0])
+    rg_assert_equal({id:1,source:0,target:2,weight:1}, @graph.edges[1])
+    rg_assert_equal({id:2,source:1,target:2,weight:1}, @graph.edges[2])
+    rg_assert_equal({id:3,source:2,target:3,weight:1}, @graph.edges[3])
+    rg_assert_equal({id:4,source:2,target:4,weight:1}, @graph.edges[4])
+    rg_assert_equal({id:5,source:3,target:4,weight:1}, @graph.edges[5])
+
+    # add edge to vertex
+    @graph = Rgraphum::Graph.new
+    @graph.vertices = [
+      { id: 0, label: "A", community_id: 1 },
+      { id: 1, label: "B", community_id: 1 },
+      {id:2,label:"C"},
+      {id:3,label:"D"},
+      {id:4,label:"E"},
+    ]
+    @graph.vertices[0].edges << {source:0,target:1,weight:1}
+    @graph.vertices[0].edges << {source:0,target:2,weight:1}
+    @graph.vertices[1].edges << {source:1,target:2,weight:1}
+    @graph.vertices[2].edges << {source:2,target:3,weight:1}
+    @graph.vertices[2].edges << {source:2,target:4,weight:1}
+    @graph.vertices[3].edges << {source:3,target:4,weight:1}
+
+    @graph.id_aspect!
+    rg_assert_equal({id:0,source:0,target:1,weight:1}, @graph.edges[0])
+    rg_assert_equal({id:1,source:0,target:2,weight:1}, @graph.edges[1])
+    rg_assert_equal({id:2,source:1,target:2,weight:1}, @graph.edges[2])
+    rg_assert_equal({id:3,source:2,target:3,weight:1}, @graph.edges[3])
+    rg_assert_equal({id:4,source:2,target:4,weight:1}, @graph.edges[4])
+    rg_assert_equal({id:5,source:3,target:4,weight:1}, @graph.edges[5])
+
+  end
+  def test_add_edge_with_id_aspect
+    @graph = Rgraphum::Graph.new
+    @graph.vertices = [{ :label => "hoge" },{:label => "huga"}]
+    rg_assert_equal ([{ :id => 0, :label => "hoge"}, {:id => 1, :label => "huga"}]), @graph.vertices
+
+    @graph.edges << { :source => 1, :target =>0 }
+    @graph.id_aspect!
+    rg_assert_equal [ { :id => 0, :source => 1, :target => 0, :weight => 1}], @graph.edges
+
+    @graph.real_aspect!
+    @graph.edges << { :source => 0, :target => 1 }
+    @graph.id_aspect!
+    rg_assert_equal [ { :id => 0, :source => 1, :target => 0, :weight => 1 },{ :id => 1, :source => 0, :target => 1, :weight => 1}], @graph.edges
+  end
+
+  def test_edges_input_with_array
+    @graph = Rgraphum::Graph.new
+    @graph.vertices = [
+      {:id => 1, :label => "hoge" },
+      {:id => 2, :label => "huga" },
+    ]
+    @graph.edges = [
+      {:source => 1, :target => 2, :weight => 1},
+      {:source => 2, :target => 1, :weight => 1},
+    ]
+    @graph.id_aspect!
+    rg_assert_equal [ {:id => 0, :source => 1, :target => 2, :weight => 1},{ :id => 1, :source => 2, :target => 1, :weight => 1}], @graph.edges
+  end
+
+  def test_divide_by_time
+    @graph = Rgraphum::Graph.new
+    @graph.vertices = [
+      {:id => 1, :label => "hoge", :start => Time.parse("2010-01-01 12:05"), :end => Time.parse("2010-01-01 12:05" )},
+      {:id => 2, :label => "huga", :start => Time.parse("2010-01-02 12:05"), :end => Time.parse("2010-01-02 13:35" )},
+    ]
+    @graph.edges = [
+      { :source => 1, :target => 2, :weight => 1, :start => Time.parse("2010-01-01 12:05"), :end => Time.parse("2010-01-01 12:05") },
+      { :source => 2, :target => 1, :weight => 1, :start => Time.parse("2010-01-02 12:05"), :end => Time.parse("2010-01-02 13:35") },
+      { :source => 2, :target => 1, :weight => 1, :start => Time.parse("2010-01-02 12:26"), :end => Time.parse("2010-01-02 13:19:59") },
+      { :source => 2, :target => 1, :weight => 1, :start => Time.parse("2010-01-02 12:40")                                            },
+    ]
+
+    @graph.divide_by_time
+
+    vertices = @graph.vertices.sort_by{ |vertex| vertex.start }
+    assert_equal "2010-01-01 12:00:00 +0900", vertices[0].start.to_s
+    assert_equal "2010-01-01 12:19:59 +0900", vertices[0].end.to_s
+
+    assert_equal "2010-01-02 12:00:00 +0900", vertices[1].start.to_s
+    assert_equal "2010-01-02 12:19:59 +0900", vertices[1].end.to_s
+
+    assert_equal "2010-01-02 12:20:00 +0900", vertices[2].start.to_s
+    assert_equal "2010-01-02 12:39:59 +0900", vertices[2].end.to_s
+
+    assert_equal "2010-01-02 12:40:00 +0900", vertices[3].start.to_s
+    assert_equal "2010-01-02 12:59:59 +0900", vertices[3].end.to_s
+
+    assert_equal "2010-01-02 13:00:00 +0900", vertices[4].start.to_s
+    assert_equal "2010-01-02 13:19:59 +0900", vertices[4].end.to_s
+
+    assert_equal "2010-01-02 13:20:00 +0900", vertices[5].start.to_s
+    assert_equal "2010-01-02 13:39:59 +0900", vertices[5].end.to_s
+
+    assert_nil vertices[6]
+
+
+    edges = @graph.edges.sort_by{ |edge| edge.start }
+    # edges.each { |edge| p "###########"; p edge.id; p edge.source.id; p edge.target.id; p edge.start; p edge.end  }
+    assert_equal "2010-01-01 12:00:00 +0900", edges[0].start.to_s
+    assert_equal "2010-01-01 12:19:59 +0900", edges[0].end.to_s
+
+    assert_equal "2010-01-02 12:00:00 +0900", edges[1].start.to_s
+    assert_equal "2010-01-02 12:19:59 +0900", edges[1].end.to_s
+
+    assert_equal "2010-01-02 12:20:00 +0900", edges[2].start.to_s
+    assert_equal "2010-01-02 12:39:59 +0900", edges[2].end.to_s
+
+    assert_equal "2010-01-02 12:40:00 +0900", edges[3].start.to_s
+    assert_equal "2010-01-02 12:59:59 +0900", edges[3].end.to_s
+
+    assert_equal "2010-01-02 13:00:00 +0900", edges[4].start.to_s
+    assert_equal "2010-01-02 13:19:59 +0900", edges[4].end.to_s
+
+    assert_equal "2010-01-02 13:20:00 +0900", edges[5].start.to_s
+    assert_equal "2010-01-02 13:39:59 +0900", edges[5].end.to_s
+
+    assert_nil edges[6]
+
+    assert_equal 1, edges[0].weight
+    assert_equal 1, edges[1].weight
+    assert_equal 2, edges[2].weight
+    assert_equal 3, edges[3].weight
+    assert_equal 2, edges[4].weight
+    assert_equal 1, edges[5].weight
+  end
+
+  def test_graph_dump_and_load
+    #   2
+    #  / \
+    # 1   4
+    #  \ /
+    #   3
+    vertex1 = Rgraphum::Vertex.new({id: 1, label: "vertex 1" })
+    vertex2 = Rgraphum::Vertex.new({id: 2, label: "vertex 2" })
+    vertex3 = Rgraphum::Vertex.new({id: 3, label: "vertex 3" })
+    vertex4 = Rgraphum::Vertex.new({id: 4, label: "vertex 4" })
+    vertices = [vertex1, vertex2, vertex3, vertex4]
+    edges = [
+      Rgraphum::Edge.new({source: vertex1, target: vertex2}),
+      Rgraphum::Edge.new({source: vertex2, target: vertex4}),
+      Rgraphum::Edge.new({source: vertex1, target: vertex3}),
+      Rgraphum::Edge.new({source: vertex3, target: vertex4}),
+    ]
+    graph = Rgraphum::Graph.new(vertices: vertices, edges: edges)
+
+    data = Marshal.dump(graph)
+    graph_dash = Marshal.load(data)
+
+    assert_equal graph, graph_dash
+  end
+
+  def test_graphs_dump_and_load
+    #   2      2 - 5
+    #  / \    /   /
+    # 1   4  1   /
+    #  \ /    \ /
+    #   3      6
+    vertex1 = Rgraphum::Vertex.new({id: 1, label: "vertex 1" })
+    vertex2 = Rgraphum::Vertex.new({id: 2, label: "vertex 2" })
+    vertex3 = Rgraphum::Vertex.new({id: 3, label: "vertex 3" })
+    vertex4 = Rgraphum::Vertex.new({id: 4, label: "vertex 4" })
+    vertex5 = Rgraphum::Vertex.new({id: 5, label: "vertex 5" })
+    vertex6 = Rgraphum::Vertex.new({id: 6, label: "vertex 6" })
+
+    vertices1 = [vertex1, vertex2, vertex3, vertex4]
+    edges1 = [
+      Rgraphum::Edge.new({source: vertex1, target: vertex2}),
+      Rgraphum::Edge.new({source: vertex2, target: vertex4}),
+      Rgraphum::Edge.new({source: vertex1, target: vertex3}),
+      Rgraphum::Edge.new({source: vertex3, target: vertex4}),
+    ]
+    graph1 = Rgraphum::Graph.new(vertices: vertices1, edges: edges1)
+
+    vertices2 = [vertex1, vertex2, vertex5, vertex6]
+    edges2 = [
+      Rgraphum::Edge.new({source: vertex1, target: vertex2}),
+      Rgraphum::Edge.new({source: vertex2, target: vertex5}),
+      Rgraphum::Edge.new({source: vertex1, target: vertex6}),
+      Rgraphum::Edge.new({source: vertex6, target: vertex5}),
+    ]
+    graph2 = Rgraphum::Graph.new(vertices: vertices2, edges: edges2)
+
+    graphs = [graph1, graph2, graph1]
+
+    data = Marshal.dump(graphs)
+    graphs_dash = Marshal.load(data)
+
+    assert_equal graphs, graphs_dash
+    rg_refute_equal graphs_dash[0], graphs_dash[1]
+    assert_equal graphs_dash[0], graphs_dash[2]
+    assert_same  graphs_dash[0], graphs_dash[2]
+    assert_same  graphs_dash[0].vertices[0], graphs_dash[2].vertices[0]
+    assert_same  graphs_dash[0].edges[0],    graphs_dash[2].edges[0]
+
+    assert_same  graphs_dash[0].edges[0], graphs_dash[0].vertices[0].edges[0]
+  end
+
+  def test_rgraphum_marshal
+    vertex1 = Rgraphum::Vertex.new({id: 1, label: "vertex 1" })
+    vertex2 = Rgraphum::Vertex.new({id: 2, label: "vertex 2" })
+    vertices = [vertex1, vertex2]
+    edges = [
+      Rgraphum::Edge.new({source: vertex1, target: vertex2}),
+    ]
+    graph = Rgraphum::Graph.new(vertices: vertices, edges: edges)
+
+    tempfile = Tempfile.new("graph.txt")
+    graph.dump_to(tempfile.path)
+    graph_dash = Rgraphum::Graph.load_from(tempfile.path)
+
+    assert_equal graph, graph_dash
+  end
+
+  def test_simurate_1
+    after_graph = @graph_a.simulate("BAModel", round: 1)
+    assert_equal @graph_a.vertices.size + 1, after_graph.vertices.size 
+    assert_equal @graph_a.edges.size    + 1, after_graph.edges.size 
+  end
+
+  def test_simurate_2
+    after_graph = @graph_a.simulate("BAModel", round: 1, edge_size: 2)
+    assert_equal @graph_a.vertices.size + 1, after_graph.vertices.size 
+    assert_equal @graph_a.edges.size    + 2, after_graph.edges.size 
+  end
+
+  def test_simurate_3
+    after_graph = @graph_a.simulate("BAModel", round: 2, edge_size: 2)
+    assert_equal @graph_a.vertices.size + 2, after_graph.vertices.size 
+    assert_equal @graph_a.edges.size    + 4, after_graph.edges.size 
+  end
+
+  private
+
+  def make_test_graph
+    @graph_a = Rgraphum::Graph.new
+    @graph_a.vertices = [
+      {:id => 1, :label => "hoge" },
+      {:id => 2, :label => "huga" },
+    ]
+    vertices_a = @graph_a.vertices
+    @graph_a.edges << { :id => 1, :source => vertices_a[0], :target => vertices_a[1], :weight => 1}
+    @graph_a.edges << { :id => 2, :source => vertices_a[1], :target => vertices_a[0], :weight => 1}
+
+    @graph_b = Rgraphum::Graph.new
+    vertices_b = @graph_b.vertices = [
+      {:id => 1, :label => "piyo" },
+      {:id => 2, :label => "hogeratte" },
+    ]
+    vertices_b = @graph_b.vertices
+    @graph_b.edges << { :id => 1, :source => vertices_b[0], :target => vertices_b[1], :weight => 2 }
+    @graph_b.edges << { :id => 2, :source => vertices_b[1], :target => vertices_b[0], :weight => 2 }
+  end
+end

data/test/lib/rgraphum/gremlin_test.rb

@@ -0,0 +1,145 @@
+# -*- coding: utf-8 -*-
+
+require 'rgraphum'
+require 'test_helper'
+
+class RgraphumGremlinTest < MiniTest::Test
+  # FIXME
+  class Rgraphum::Vertex
+    field :name, :age, :lang
+  end
+
+  def setup
+    make_gremlin_sample
+  end
+
+  def test_v
+    rg_assert_equal ({id:1,name:"marko", age:29}), @graph.v(1)
+    rg_assert_equal [{id:1,name:"marko",age:29},{id:2,name:"vadas",age:27},{id:3,name:"lop",lang:"java"}], @graph.v(1,2,3)
+    rg_assert_equal [{id:1,name:"marko",age:29},{id:2,name:"vadas",age:27},{id:3,name:"lop",lang:"java"}], @graph.v([1,2,3])
+  end
+
+  def test_e
+    assert_equal 10, @graph.e(10).id
+    assert_equal [10,11,12], @graph.e(10,11,12).id
+    assert_equal [10,11,12], @graph.e([10,11,12]).id
+  end
+
+  def test_addVertex
+    g = Rgraphum::Graph.new
+    rg_assert_equal({id:0}, g.addVertex())
+    rg_assert_equal({id:100}, g.addVertex(100))
+
+    rg_assert_equal({id:101,name:"stephen"}, g.addVertex(nil,{name:"stephen"}))
+  end
+
+  def test_addEdge
+    g = Rgraphum::Graph.new
+    v1 = g.addVertex(100)
+    v2 = g.addVertex(200)
+
+    e = g.addEdge(v1,v2,'friend')
+    rg_assert_equal v1, e.outV
+    rg_assert_equal v2, e.inV
+
+    e = g.addEdge(1000,v1,v2,'friend')
+    rg_assert_equal({:id=>1000, :source=>{:id=>100}, :target=>{:id=>200}, :label=>"friend", :weight=>1}, e)
+
+    e = g.addEdge(nil,v1,v2,'friend',{weight:0.75})
+    rg_assert_equal({:id=>1001, :source=>{:id=>100}, :target=>{:id=>200}, :label=>"friend", :weight=>0.75}, e)
+    
+  end
+
+  def test_both
+    v = @graph.v(4)
+    rg_assert_equal [{id:1,name:"marko",age:29},{id:5,name:"ripple",lang:"java"},{id:3,name:"lop",lang:"java"}], v.both
+    rg_assert_equal [{id:1,name:"marko",age:29}], v.both('knows')
+    rg_assert_equal [{id:1,name:"marko",age:29},{id:5,name:"ripple",lang:"java"},{id:3,name:"lop",lang:"java"}], v.both('knows','created')
+  end
+
+  def test_bothE
+    v = @graph.v(4)
+    assert_equal [8,10,11], v.bothE.id
+    assert_equal [8], v.bothE('knows').id
+    assert_equal [8,10,11], v.bothE('knows','created').id
+  end
+
+  def test_outV_inV_both_V
+    e = @graph.e(12)
+    rg_assert_equal({id:6,name:"peter",age:35}, e.outV)
+    rg_assert_equal({id:3,name:"lop",lang:"java"}, e.inV)
+    rg_assert_equal [{id:6,name:"peter", age:35},{id:3,name:"lop",lang:"java"}], e.bothV
+  end
+
+  def test_id
+    v = @graph.V(:name,"marko")
+    assert_equal [1], v.id
+
+    v[0].id = 2000
+    assert_equal [2000], v.id
+  end
+
+  def test_V
+    assert_equal [1,2,3,4,5,6], @graph.V.id
+    rg_assert_equal [{id:1,name:"marko",age:29}], @graph.V(:name,"marko")
+    assert_equal ["marko"], @graph.V(:name,"marko").name
+  end
+
+  def test_E
+    assert_equal [7,8,9,10,11,12], @graph.E.id
+    assert_equal [0.5,1.0,0.4,1.0,0.4,0.2], @graph.E.weight
+  end
+
+  def test_in_inE
+    v = @graph.v(4)
+    rg_assert_equal [{id:1,name:"marko",age:29}], v.inE.outV
+    rg_assert_equal [{id:1,name:"marko",age:29}], v.in
+
+    v = @graph.v(3)
+    rg_assert_equal [{id:1,name:"marko",age:29},{id:4,name:"josh",age:32},{id:6,name:"peter", age:35}], v.in('created')
+    rg_assert_equal [{id:1,name:"marko",age:29},{id:4,name:"josh",age:32},{id:6,name:"peter", age:35}], v.inE('created').outV
+  end
+
+  def test_out_outE
+    v = @graph.v(1)
+    rg_assert_equal [{id:2,name:"vadas",age:27},{id:4,name:"josh",age:32},{id:3,name:"lop",lang:"java"}], v.outE.inV
+    rg_assert_equal [{id:2,name:"vadas",age:27},{id:4,name:"josh",age:32},{id:3,name:"lop",lang:"java"}], v.out
+
+    rg_assert_equal [{id:2,name:"vadas",age:27},{id:4,name:"josh",age:32}], v.outE('knows').inV
+    rg_assert_equal [{id:2,name:"vadas",age:27},{id:4,name:"josh",age:32}], v.out('knows')
+  end
+
+  def test_has
+    assert_equal ["marko"],         @graph.V.has(:name, "marko").name
+    assert_equal [0.5,1.0],         @graph.v(1).outE.has(:weight, Rgraphum::T.gte, 0.5 ).weight
+    assert_equal ["marko", "vadas", "josh", "peter"], @graph.V.has("age").name
+    assert_equal ["lop", "ripple"], @graph.V.has("age", nil ).name
+  end
+
+  def test_has_not
+    assert_equal [1.0,0.4],                           @graph.v(1).outE.hasNot(:weight, Rgraphum::T.eq, 0.5 ).weight
+    assert_equal ["marko", "vadas", "josh", "peter"], @graph.V.hasNot("age", nil ).name
+  end
+
+  private
+
+  def make_gremlin_sample
+    @graph = Rgraphum::Graph.new
+
+    # add vertices
+    @graph.vertices << {id:1,name:"marko", age:29            }
+    @graph.vertices << {id:2,name:"vadas", age:27            }
+    @graph.vertices << {id:3,name:"lop",          lang:"java"}
+    @graph.vertices << {id:4,name:"josh",  age:32            }
+    @graph.vertices << {id:5,name:"ripple",       lang:"java"}
+    @graph.vertices << {id:6,name:"peter", age:35}
+
+    # add vertices
+    @graph.edges << {id:7, label:"knows",  weight:0.5,source:1,target:2}
+    @graph.edges << {id:8, label:"knows",  weight:1.0,source:1,target:4}
+    @graph.edges << {id:9, label:"created",weight:0.4,source:1,target:3}
+    @graph.edges << {id:10,label:"created",weight:1.0,source:4,target:5}
+    @graph.edges << {id:11,label:"created",weight:0.4,source:4,target:3}
+    @graph.edges << {id:12,label:"created",weight:0.2,source:6,target:3}
+  end
+end

data/test/lib/rgraphum/importers/idg_json_edges.json

@@ -0,0 +1,20 @@
+{
+  "result": [{
+      "@type": "d", "@rid": "#-2:0", "@version": 0, 
+"in": "#6:0", 
+"out": "#6:1", 
+"statusIds": "999999999999999999", 
+"weight": 1.0, 
+"created_at": 1373554121, 
+  "@fieldTypes": "weight=f,created_at=l"
+    }, {
+      "@type": "d", "@rid": "#-2:1", "@version": 0, 
+"in": "#6:2", 
+"out": "#6:1", 
+"statusIds": "999999999999999999", 
+"weight": 1.0, 
+"created_at": 1373553637, 
+  "@fieldTypes": "weight=f,created_at=l"
+    }
+  ]
+}