ruby-graphviz_c 1.1.0

data/test/helper.rb

@@ -0,0 +1,13 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'test/unit'
+require 'pathname'
+
+cur = Pathname.new(File.expand_path("..", __FILE__))
+lib = cur.join('..', 'lib')
+
+$LOAD_PATH.unshift(lib.to_s, cur.to_s)
+require 'graphviz'
+require 'graphviz/theory'
+require 'graphviz/math/matrix'
+require 'graphviz/utils/colors'

data/test/support.rb

@@ -0,0 +1,95 @@
+require 'helper'
+require 'stringio'
+
+# hack so that the example scripts don't unnecessarily unshift @todo
+class << $:
+  def unshift path
+    include?(path) ? self : super    # super will return self, too
+  end
+end
+
+module TestSupport
+  extend self
+
+  # @todo move to app?
+  def windows?
+    /mswin|mingw/ =~ RUBY_PLATFORM
+  end
+
+  def dev_null
+    windows? ? 'NUL' : '/dev/null'
+  end
+end
+
+module IoHack
+
+  #
+  # this is a ridiculous hack to capture what was written to $stdout/$stderr for testing
+  # an alternative is to use Open3.popen3 on external calls which has overhead
+  # and OS dependencies.
+  #
+  # This hack would apparently not be as bad on 1.9, which would allow you to simply
+  # set $stdout and $stderr to instances of StringIO
+  #
+  # I don't know what is the 'right way' to test this kind of thing
+  #
+
+  class IoHackStream < File
+    #
+    # pre 1.9 you can't assign $stdout and $stderr to anything other than
+    # an IO::File instance.  what we *want* is to have them be StringIOs that
+    # we can read from like strings for testing.  So this is a crazy proxy
+    # around StringIO.    Note it makes *all* methods except a few protected,
+    # which for me was failing silently when i forgot to make the appropriate
+    # ones public.  hack!
+    #
+
+    except = %w(inspect kind_of?)
+    except += except.map{|x| x.to_sym } # for Ruby 1.9
+    these = ancestors[0].instance_methods
+    # these = [1,2,3].map{|x| ancestors[x].instance_methods(false)}.flatten
+    eraseme = (these - except)
+    eraseme.each{ |name| protected name }
+    attr_reader :io
+    def initialize()
+      @io = StringIO.new
+      super(TestSupport.dev_null, 'r+') # probably doesn't matter the mode
+    end
+    these = %w(write << puts)
+    these.each do |name|
+      define_method(name) do |*a|
+        @io.send(name, *a)
+      end
+    end
+  end
+
+  def fake_popen2 path
+    push_io
+    require path  # caller assumes responsibility for exceptions vis-a-vis stack
+    pop_io
+  end
+
+  def io_stack
+    @io_stack ||= []
+  end
+
+  def push_io
+    io_stack.push [$stdout, $stderr]
+    $stdout = IoHackStream.new
+    $stderr = IoHackStream.new
+    nil
+  end
+
+  def pop_io
+    fail('stack empty') unless io_stack.any?
+    result = [$stdout, $stderr]
+    $stdout, $stderr = io_stack.pop
+    result.each_with_index do |io,idx|
+      if io.kind_of? IoHackStream
+        io.io.seek(0)
+        result[idx] = io.io.read
+      end
+    end
+    result
+  end
+end

data/test/test_dot_script.rb

@@ -0,0 +1,47 @@
+require 'helper'
+
+class GraphVizDOTScriptTest < Test::Unit::TestCase
+  def setup
+    @script = GraphViz::DOTScript.new
+  end
+
+  def test_appends_a_newline_character_if_it_is_missing
+    str = "Test without newline"
+    @script.append(str)
+    assert_equal @script.to_s, str + "\n"
+  end
+
+  def test_does_not_append_a_newline_if_already_present
+    str = "Linebreak follows at my tail:\n"
+    @script.append(str)
+    assert_equal @script.to_s, str
+  end
+
+  def test_can_prepend_lines_to_its_content
+    start_content = "I want to be at the top!\n"
+    additional_content = "No way!\n"
+
+    @script.append(start_content)
+    @script.prepend(additional_content)
+
+    assert_equal @script.to_s, additional_content + start_content
+  end
+
+  def test_can_add_types_with_data
+    data = "some random data"
+    @script.add_type("node_attr", data)
+    assert_match(/\s*node\s*\[\s*#{data}\s*\]\s*/, @script.to_s)
+  end
+
+  def test_does_nothing_if_data_is_empty
+    @script.add_type("anything", "")
+    assert_equal true, @script.to_s.empty?
+  end
+
+  def test_raises_an_argument_error_on_unknown_types
+    assert_raise ArgumentError do
+      @script.add_type("invalid", "some data")
+    end
+  end
+end
+

data/test/test_examples.rb

@@ -0,0 +1,151 @@
+#require File.expand_path('support.rb', File.dirname(__FILE__))
+require 'support'
+
+class GraphVizTest < Test::Unit::TestCase
+
+  #
+  # you can run a subset of all the samples like this:
+  #  ruby test/test_examples.rb  --name='/sample3[6-9]/'
+  #
+  # The above will run samples 36, 37, 38, and 39
+  #
+
+
+  include IoHack
+
+  RootDir    = File.expand_path('../..', __FILE__)
+  ExampleDir = File.join(RootDir,'examples')
+  OutputDir  = File.join(File.dirname(__FILE__),'output')
+  # OutputDir  = File.join(RootDir,'test','output')
+
+
+  # the below tests write to stdout. the other tests write to filesystem
+
+  Skips = {
+    #'35' => 'hanging for me',
+    '33' => 'FamilyTree is broken',
+    '36' => 'hangs for me',
+    '53' => 'FamilyTree is broken',
+    '57' => 'will not be able to find the graphml script',
+    '98' => 'This test is just for debug',
+    '99' => 'FamilyTree is broken'
+  }
+
+
+  def test_sample07
+    assert_output_pattern(/\Adigraph structs \{.+\}\n\Z/m, '07')
+  end
+
+  def test_sample22
+    assert_output_pattern(/\Adigraph mainmap \{.+\}\n\Z/m, '22')
+  end
+
+  def test_sample23
+    assert_output_pattern(%r{\A<map.+</map>\n\Z}m, '23')
+  end
+
+  def test_sample27
+    assert_output_pattern(/\Adigraph G \{.*\}\n\Z/m, '27')
+  end
+
+  def test_sample38
+    assert_output_pattern(/\Adigraph G \{.*\}\n\Z/m, '38')
+  end
+
+  def test_sample40
+    assert_output_pattern(/\Adigraph G \{.*\}\n\Z/m, '40')
+  end
+
+  def test_sample41
+    assert_output_pattern(/\A.*\Z/m, '40')
+  end
+
+  def test_sample55
+    assert_output_pattern(/\Agraph G \{.*\}\n\Z/m, '55')
+  end
+
+  def test_sample62
+     assert_output_pattern(/\ANode.*\n\Z/m, '62')
+  end
+
+  def test_sample70
+    assert_output_pattern(/\Agraph G \{.*\}\n\Z/m, '70')
+  end
+
+  #
+  # for every sample file in the examples directory that matches the
+  # pattern ("sample01.rb, sample02.rb, etc) make a corresponding
+  # test method: test_sample01(), test_sample02(), etc.  To actually define
+  # this methods in this way instead of just iterating over the list of files
+  # will make it easier to use command-line options to isolate certain
+  # tests,
+  #   (for example:   ruby test/test_examples.rb --name '/sample0[1-5]/' )
+  # and to integrate better with certain kinds of test output and
+  # reporting tools.
+  #
+  # we will skip over any methods already defined
+  #
+
+  @last_image_path = nil
+  @number_to_path = {}
+  class << self
+    def make_sample_test_method path
+      fail("failed match: #{path}") unless
+        matches = %r{/(sample(\d\d))\.rb\Z}.match(path)
+      basename, number = matches.captures
+      number_to_path[number] = path
+      meth = "test_#{basename}"
+      return if method_defined?(meth)  # if we hand-write one
+      if Skips[number]
+        puts "skipping #{basename} - #{Skips[number]}"
+        return
+      end
+      define_method(meth){ assert_sample_file_has_no_output(path) }
+    end
+    attr_accessor :last_image_path, :number_to_path
+  end
+
+  samples = Dir[File.join(ExampleDir,'sample*.rb')].sort
+  samples.each {|path| make_sample_test_method(path) }
+
+
+private
+
+  def assert_output_pattern tgt_regexp, number
+    path = self.class.number_to_path[number]
+    setup_sample path
+    out, err = fake_popen2(path)
+    assert_equal "", err, "no errors"
+    assert_match tgt_regexp, out.gsub(/\r\n/, "\n"), "output for sample#{number} should match regexp"
+  end
+
+  def assert_sample_file_has_no_output path
+    setup_sample(path)
+    begin
+      out, err = fake_popen2(path)
+      assert_equal(0, out.length, "expecting empty output")
+      assert_equal(0, err.length, "expecting empty errorput")
+      msg = "maybe generated #{self.class.last_image_path}"
+      print "\n", msg
+    rescue Exception => e
+      assert(false, "got exception on #{File.basename(path)}: #{e.message}")
+      puts "out: ", out.inspect, "err:", err.inspect
+    end
+  end
+
+  def setup_sample path
+    unless File.directory? OutputDir
+      FileUtils.mkdir_p(OutputDir, :verbose => true)
+    end
+    ARGV[0] = nil if ARGV.any? # hack trigger searching for 'dot' executable
+    hack_output_path path
+  end
+
+  def hack_output_path path
+    # hack $0 to change where the output image is written to
+    fake_example_path = File.join(OutputDir, File.basename(path))
+    $program_name = fake_example_path.dup
+    alias $0 $program_name
+    self.class.last_image_path = "#{$0}.png"
+  end
+end

data/test/test_graph.rb

@@ -0,0 +1,115 @@
+require 'helper'
+
+class GraphVizTest < Test::Unit::TestCase
+  def setup
+    @graph = GraphViz::new( :G )
+  end
+
+  def test_graph
+    assert(@graph, 'Create graph faild.')
+
+    assert_block 'Set attribut for graph faild.' do
+      @graph['size'] = "10,10"
+    end
+
+    assert_equal( "\"10,10\"", @graph['size'].to_s, 'Get attribut for graph faild.' )
+
+    assert_equal( "G", @graph.name, "Wrong graph name." )
+  end
+
+  def test_node
+    n, m = nil, nil
+
+    assert_block 'Create node failed.' do
+      n = @graph.add_nodes( "n1" )
+    end
+
+    assert_block 'Get node failed.' do
+      m = @graph.get_node( "n1" )
+    end
+
+    assert_equal( m, n, "Node corrupted when get." )
+
+    assert_equal( @graph.node_count, 1, "Wrong number of nodes" )
+
+    assert_block 'Set attribut for node faild.' do
+      n['label'] = "Hello\n\"world\"\\l"
+    end
+
+    assert_equal( "\"Hello\\n\\\"world\\\"\\l\"", n['label'].to_s, 'Get attribut for node faild.' )
+  end
+
+  def test_search
+     g = GraphViz::new( "G" )
+     g.node["shape"] = "ellipse"
+     g.node["color"] = "black"
+
+     g["color"] = "black"
+
+     c0 = g.add_graph( "cluster0" )
+     c0["label"] = "process #1"
+     c0["style"] = "filled"
+     c0["color"] = "lightgrey"
+     a0 = c0.add_nodes( "a0", "style" => "filled", "color" => "white" )
+     a1 = c0.add_nodes( "a1", "style" => "filled", "color" => "white" )
+     a2 = c0.add_nodes( "a2", "style" => "filled", "color" => "white" )
+     a3 = c0.add_nodes( "a3", "style" => "filled", "color" => "white" )
+     c0.add_edges( a0, a1 )
+     c0.add_edges( a1, a2 )
+     c0.add_edges( a2, a3 )
+
+     c1 = g.add_graph( "cluster1", "label" => "process #2" )
+     b0 = c1.add_nodes( "b0", "style" => "filled", "color" => "blue" )
+     b1 = c1.add_nodes( "b1", "style" => "filled", "color" => "blue" )
+     b2 = c1.add_nodes( "b2", "style" => "filled", "color" => "blue" )
+     b3 = c1.add_nodes( "b3", "style" => "filled", "color" => "blue" )
+     c1.add_edges( b0, b1 )
+     c1.add_edges( b1, b2 )
+     c1.add_edges( b2, b3 )
+
+     start = g.add_nodes( "start", "shape" => "Mdiamond" )
+     endn  = g.add_nodes( "end",   "shape" => "Msquare" )
+
+     g.add_edges( start, a0 )
+     g.add_edges( start, b0 )
+     g.add_edges( a1, b3 )
+     g.add_edges( b2, a3 )
+     g.add_edges( a3, a0 )
+     g.add_edges( a3, endn )
+
+     assert g
+
+     assert_equal g.get_node("start"), start
+     assert_equal g.find_node("start"), start
+     assert_equal g.search_node("start"), start
+
+     assert_nil   g.get_node("a0")
+     assert_equal g.find_node("a0"), a0
+     assert_equal g.search_node("a0"), a0
+
+     assert_nil   c0.get_node("start")
+     assert_equal c0.find_node("start"), start
+     assert_nil   c0.search_node("start")
+
+     assert_equal c0.get_node("a0"), a0
+     assert_equal c0.find_node("a0"), a0
+     assert_equal c0.search_node("a0"), a0
+
+     assert_nil   c1.get_node("start")
+     assert_equal c1.find_node("start"), start
+     assert_nil   c1.search_node("start")
+
+     assert_nil   c1.get_node("a0")
+     assert_equal c1.find_node("a0"), a0
+     assert_nil   c1.search_node("a0")
+  end
+
+  def test_to_s
+    assert_nothing_raised 'to_s with edge with numeric label failed.' do
+      a = @graph.add_nodes('a')
+      b = @graph.add_nodes('b')
+      @graph.add_edges(a, b, :label => 5)
+      @graph.to_s
+    end
+  end
+end

data/test/test_search.rb

@@ -0,0 +1,29 @@
+require 'helper'
+
+class GraphVizSearch < Test::Unit::TestCase
+   def setup
+      @graph = GraphViz.graph(:G)
+      @graph.add_nodes(["A", "B", "C", "D", "E", "F", "G"])
+      @graph.add_edges("A", ["B", "C", "E"])
+      @graph.add_edges("B", ["D", "F"])
+      @graph.add_edges("C", "G")
+      @graph.add_edges("F", "E")
+      @theory = GraphViz::Theory.new(@graph)
+   end
+
+   def test_dfs
+      order = []
+      @theory.dfs("A") { |node|
+         order << node.id
+      }
+      assert_equal order, ["A", "B", "D", "F", "E", "C", "G"]
+   end
+
+   def test_bfs
+      order = []
+      @theory.bfs("A") { |node|
+         order << node.id
+      }
+      assert_equal order, ["A", "B", "C", "E", "D", "F", "G"]
+   end
+end