vhdl_doctest 0.0.4 → 0.0.5

data/bin/vhdl_doctest

@@ -14,6 +14,6 @@ bin_file = Pathname.new(__FILE__).realpath
 $:.unshift File.expand_path("../../lib", bin_file)
 
 require "vhdl_doctest"
-test = VhdlDoctest::DUT.parse(ARGV[0]).test_file
+dut = VhdlDoctest::DUT.parse(ARGV[0])
 
-VhdlDoctest::TestRunner.new(STDOUT, ARGV[0], test).run
+VhdlDoctest::TestRunner.new(STDOUT, ARGV[0], dut.test_file, dut.dependencies).run

data/examples/alu_depending.vhd

@@ -0,0 +1,56 @@
+library IEEE;
+use IEEE.STD_LOGIC_1164.all;
+use IEEE.STD_LOGIC_ARITH.all;
+use IEEE.STD_LOGIC_UNSIGNED.all;
+
+-- DOCTEST DEPENDENCIES: test.vhd
+-- TEST
+-- a  |b   |control b|output|zero
+-- 18 |9   |000      |0     |1
+--    |    |001      |27    |0
+--    |    |010      |27    |0
+--    |    |110      |9     |0
+--    |    |111      |0     |1
+-- 18 |18  |111      |0     |1
+-- 18 |19  |         |1     |0
+-- 18 |100 |         |1     |0
+-- /TEST
+
+entity alu is
+
+  port (
+    a, b    : in  std_logic_vector(31 downto 0);
+    control : in  std_logic_vector(2 downto 0);
+    output  : out std_logic_vector(31 downto 0);
+    zero    : out std_logic);
+
+end alu;
+
+architecture behave of alu is
+
+  signal bb : std_logic_vector(31 downto 0);
+  signal c : std_logic;
+  signal o0, o1, o2, o3 : std_logic_vector(31 downto 0);
+
+  signal out_buf : std_logic_vector(31 downto 0);
+
+begin  -- behave
+
+  c <= control(2);
+
+  bb <= not b when control(2) = '1' else b;
+
+  o0 <= a and bb;
+  o1 <= a or b;
+  o2 <= a + bb + c;
+  o3 <= x"0000000" & "000" & o2(31);
+
+  out_buf <= o0 when control(1 downto 0) = "00" else
+             o1 when control(1 downto 0) = "01" else
+             o2 when control(1 downto 0) = "10" else
+             o3 when control(1 downto 0) = "11";
+
+  output <= out_buf;
+  zero <= '1' when out_buf = x"00000000" else '0';
+
+end behave;

data/lib/vhdl_doctest.rb

@@ -6,6 +6,7 @@ require "vhdl_doctest/test_file"
 require "vhdl_doctest/test_case"
 require "vhdl_doctest/dut"
 require "vhdl_doctest/test_parser"
+require "vhdl_doctest/result_formatter"
 
 module VhdlDoctest
   # Your code goes here...

data/lib/vhdl_doctest/dut.rb

@@ -1,46 +1,54 @@
 module VhdlDoctest
   class DUT
     def self.parse(path)
-      entity, ports, cases = DoctestParser.new(path).parse
-      new(entity, ports, cases)
+      new(File.read(path))
     end
 
     attr_accessor :entity, :ports, :cases
-    def initialize(entity, ports, cases)
-      @entity, @ports, @cases = entity, ports, cases
+    def initialize(vhdl)
+      @vhdl = vhdl
     end
 
     def test_file
-      TestFile.new(@entity, @ports, @cases)
-    end
-
-    class DoctestParser
-      def initialize(path)
-        @vhdl = File.read(path)
-      end
-
-      def parse
-        entity = @vhdl.match(/entity\s+(.*)\s+is/)[1]
-        ports = extract_ports
-        cases = TestParser.parse(ports, @vhdl)
-
-        [entity, ports, cases]
-      end
-
-      def extract_ports
-        return @ports if @ports
-        @ports = []
-        definitions = @vhdl.match(/entity.*is\s+port\s*\((.*?)\);\s*end/m)[1]
-        definitions.split("\n").each do |l|
-          names, attributes = l.strip.gsub(/;$/, '').split(":")
-          next unless attributes
-          destination, type = attributes.strip.split(' ', 2)
-          names.split(',').each do |name|
-            @ports << Port.new(name.strip, destination.to_sym, VhdlDoctest::Types.parse(type))
-          end
-        end
-        @ports
-      end
+      TestFile.new(entity, ports, cases)
+    end
+
+    def ports
+      @ports ||=
+        remove_comments(port_block).split(";").
+        # "enable, push : in std_logic"
+        map { |line| line.strip.split(':') }.
+        # ["enable, push", "in std_logic"]
+        select { |names, attrs| ! attrs.nil? }.
+        map { |names, attrs| [names.split(','), *attrs.strip.split(' ', 2)]  }.
+        # [["enable", " push"], in, std_logic]"
+        map { |names, destination, type|
+        names.map { |name| Port.new(name.strip, destination.to_sym, VhdlDoctest::Types.parse(type)) }
+      }.flatten
+    end
+
+    def port_block
+      @vhdl.match(/entity\s*(?<entity_name>[a-zA-Z_0-9]*)\s*is\s+port\s*\((?<ports>.*?)\);\s*end\s+\k<entity_name>\s*;/m)[:ports]
+    end
+
+    def remove_comments(vhdl)
+      vhdl.gsub(/--.*$/, '')
+    end
+
+    def entity
+      @vhdl.match(/entity\s+(.*)\s+is/)[1]
+    end
+
+    def cases
+      TestParser.new(@vhdl).parse(ports)
+    end
+
+    def dependencies
+      @vhdl.split("\n").
+        select { |line| line.include?('DOCTEST DEPENDENCIES') }.
+        map { |line| line.split(":")[1].split(",") }.
+        flatten.
+        map { |file| file.strip }
     end
   end
 end

data/lib/vhdl_doctest/result_formatter.rb

@@ -0,0 +1,49 @@
+module VhdlDoctest
+  class ResultFormatter
+    def initialize(output)
+      @output = output
+    end
+
+    # pretty print error message
+    def format
+      if compile_error?
+        "FAILED: Test did not run because of compilation error"
+      else
+        lines.reduce([]) do |formatted, l|
+          if l.match(/(FAILED: .*) expected to (.*), but (.*)/)
+            formatted << $1
+            formatted << "  expected: " + $2
+            formatted << "    actual: " + replace_binary($3)
+          end
+          formatted
+        end.join("\n")
+      end
+    end
+
+    def compile_error?
+      @output.include?("ghdl: compilation error")
+    end
+
+    def succeeded?
+      ! compile_error? && ! failed?
+    end
+
+    def failed?
+      @output.include?("FAILED")
+    end
+
+    def count_failure
+      lines.select{ |l| l.match(/FAILED/) }.count
+    end
+
+    # convert binary expression in a string to decimal
+    def replace_binary(str)
+      str.gsub(/[01]+/) { |bin| bin.to_i(2).to_s(10) }
+    end
+
+    private
+    def lines
+      @output.split("\n")
+    end
+  end
+end

data/lib/vhdl_doctest/test_parser.rb

@@ -1,43 +1,63 @@
 module VhdlDoctest
   class OutOfRangeSymbolError < RuntimeError
-    def initialize(port, radix, bad_value)
-      @port, @bad_value = port, bad_value
-
-      @radix = case radix
-               when 2;  'binary'
-               when 10; 'decimal'
-               when 16; 'hex'
-               end
+    def initialize(bad_value, allowed)
+      super("#{ bad_value } includes not allowed symbol(s): #{ allowed }")
     end
+  end
+
+  class TestParser
+    def initialize(vhdl)
+      @vhdl = vhdl
+      d = lambda do |x|
+        assert_in_range(("0".."9").to_a + %w{ - }, x)
+        x.to_i
+      end
+
+      h = lambda do |x|
+        assert_in_range(("0".."9").to_a + ("a".."f").to_a, x)
+        x.to_i(16)
+      end
 
-    def to_s
-      "#@port expects #@radix, but received #@bad_value"
+      b = lambda do |x|
+        assert_in_range(%w{ 0 1 }, x)
+        x.to_i(2)
+      end
+      @decoders = { 'd' => d, 'h' => h, 'x' => h, 'b' => b }
     end
-  end
 
-  module TestParser
-    extend self
-    def parse(ports, vhdl)
-      names, vectors = extract_values(vhdl)
+    def parse(ports)
+      names, vectors = extract_values(@vhdl)
       defined_ports = names.map { |name| ports.find { |p| p.name == name } }
       vectors.map { |v| TestCase.new(Hash[defined_ports.zip(v)]) }
     end
 
+    # find decoder to decode given value
+    def decode(decoder, value)
+      if fun = @decoders[decoder || 'd']
+        fun.call(value)
+      else
+        raise "Cannot decode #{value} with decoder #{decoder}.  Unknown decoder."
+      end
+    end
+
+    # convert decoder definition string to lambda
+    # Example:
+    #     def f { |x| x.include?(".") ? [x.to_f].pack('f').unpack('I').first : x.to_i }
+    #     => #<Proc>
+    def def_to_lambda(def_string)
+      if def_string.match(/def\s+([[:alnum:]]*)\s+{([^}]*)}/)
+        [$1, eval("lambda { #{ $2 } }")]
+      end
+    end
+
+    def register_decoder(defs)
+      @decoders.merge! Hash[defs.map{ |d| def_to_lambda(d) }]
+    end
+
     private
-    def assert_in_range(port_name, radix, string)
-      symbols = case radix
-                when 2
-                  %w{ 0 1 }
-                when 10
-                  ("0".."9").to_a + %w{ - }
-                when 16
-                  ("0".."9").to_a + ("a".."f").to_a
-                else
-                  []
-                end
-
-      unless string.split(//).all? { |s| symbols.include? s }
-        raise OutOfRangeSymbolError.new(port_name, radix, string)
+    def assert_in_range(allowed, string)
+      unless string.split(//).all? { |s| allowed.include? s }
+        raise OutOfRangeSymbolError.new(string, allowed)
       end
     end
 
@@ -51,66 +71,79 @@ module VhdlDoctest
       line.split("|").map(&:strip)
     end
 
-    def test_definitions(vhdl)
+    def test_block(vhdl)
       lines = vhdl.match(/-- TEST\n(.*)-- \/TEST/m)[1].
-        gsub(/\#.*$/, '').     # remove comments
-        gsub(/--\s*\n/m, '').  # remove blank lines
+        gsub(/\#.*$/, '').        # remove comments
+        gsub(/^---*[ \t]*/, '').  # remove VHDL comments
+        gsub(/^\s*\n/m, '').      # remove blank lines
         split("\n")
-      lines.partition { |l| l.include? 'alias' }
+    end
+
+    def test_definition(vhdl)
+      empty = { aliases: [], decoders: [], cases: [] }
+      test_block(vhdl).reduce(empty) do |m, l|
+        case l
+        when /^alias/; m[:aliases]  << l
+        when /^def/;   m[:decoders] << l
+        else;          m[:cases]    << l
+        end
+        m
+      end
     rescue
       raise "Test definition not found"
     end
 
-    def radix(attr)
-      if attr
-        case attr[-1]
-        when 'b';      2
-        when 'h', 'x'; 16
+    def replace_aliases(aliases, case_table)
+      pairs = aliases.map { |l| l.match(/alias\s+([^ \t]*)\s+([^ \t]*)\s*$/)[1..2] }
+      pairs.sort_by! { |k,v| -k.length }  # use longer alias first
+      case_table.each { |l| pairs.each { |p| l.gsub!(p[0], p[1]) } }
+      case_table
+    end
+
+    def remove_invalid_lines(body, idx)
+      body.select do |l|
+        if l.empty?
+          false
+        elsif ! l[idx]
+          warn l.join(" | ") + " does not have enough columns"
+          false
+        else
+          true
         end
-      else
-        10
       end
     end
 
-    def replace_aliases(defs, table)
-      pairs = defs.map { |l| l.match(/alias\s+(.*)\s+(.*)$/)[1..2] }
-      table.each { |l| pairs.each { |p| l.gsub!(p[0], p[1]) } }
-      table
+    # fill empty cells inheriting the above value
+    # decode string into :dont_care or integer
+    # destructively change body
+    def normalize_testcases(body, idx, decoder)
+      prev = ''
+      body.each do |l|
+        if l[idx].empty?
+          l[idx] = prev
+        else
+          if l[idx].strip.match(/^-+$/)
+            l[idx] = :dont_care
+          else
+            l[idx] = decode(decoder, l[idx])
+          end
+          prev = l[idx]
+        end
+      end
     end
 
     def extract_values(vhdl)
-      table = replace_aliases(*test_definitions(vhdl))
-      header, *body = table.map { |l| extract_fields remove_comment l }
+      definition = test_definition(vhdl)
+      register_decoder(definition[:decoders])
+      table = replace_aliases(definition[:aliases], definition[:cases])
+      header, *body = table.map { |l| extract_fields l }
       port_names = []
 
       header.each_with_index do |h, idx|
-        port_name, attr = h.split(' ', 2)
+        port_name, decoder_name = h.split(' ', 2)
         port_names << port_name
-        prev = ''
-        radix = radix(attr)
-        body.select! do |l|
-          if l.empty?
-            false
-          elsif ! l[idx]
-            warn l.join(" | ") + " does not have enough columns"
-            false
-          else
-            true
-          end
-        end
-        body.each do |l|
-          if l[idx].empty?
-            l[idx] = prev
-          else
-            if l[idx].strip.match(/^-+$/)
-              l[idx] = :dont_care
-            else
-              assert_in_range(port_name, radix, l[idx])
-              l[idx] = l[idx].to_i(radix)
-            end
-            prev = l[idx]
-          end
-        end
+        body = remove_invalid_lines(body, idx)
+        normalize_testcases(body, idx, decoder_name)
       end
       [port_names, body]
     end

data/lib/vhdl_doctest/test_runner.rb

@@ -1,9 +1,13 @@
 module VhdlDoctest
   class TestRunner
-    def initialize(out, dut_path, test_file)
+    def initialize(out, dut_path, test_file, dependencies = [])
       @out = out
       @dut_path = File.expand_path(dut_path)
       @test_file = test_file
+      @dependencies = dependencies
+
+      require 'tmpdir'
+      @dir = Dir.mktmpdir
     end
 
     def run
@@ -12,26 +16,32 @@ module VhdlDoctest
       report_result
     end
 
-    private
     def create_files
-      require 'tmpdir'
-      @dir = Dir.mktmpdir
       @test_file.create(@dir)
+      create_runner_script
     end
 
-    def run_test
-      @result = ""
+    def dependencies
+      dut_dir = File.dirname(@dut_path)
+      @dependencies.map { |path| File.expand_path(path, dut_dir) }
+    end
 
-      sh = File.join(@dir, "run.sh")
-      File.open(sh, 'w') do |f|
+    def create_runner_script
+      @sh = File.join(@dir, "run.sh")
+      File.open(@sh, 'w') do |f|
         f << "#!/bin/sh -e\n\n"
         f << "cd #{@dir}\n"
-        f << "ghdl -a --ieee=synopsys -fexplicit --warn-default-binding --warn-binding --warn-library --warn-body --warn-specs --warn-unused #{@dut_path} #{@test_file.path}\n"
+        f << "ghdl -a --ieee=synopsys -fexplicit --warn-default-binding --warn-binding --warn-library --warn-body --warn-specs --warn-unused #{dependencies.join(" ")} #{@dut_path} #{@test_file.path}\n"
         f << "ghdl -e -Plibs/unisim --ieee=synopsys -fexplicit #{@test_file.test_name}\n"
         f << "ghdl -r #{@test_file.test_name} --vcd=out.vcd --stop-time=10ms\n"
       end
+    end
 
-      IO.popen("sh #{sh} 2>&1") do |f|
+    private
+    def run_test
+      @result = ""
+
+      IO.popen("sh #{@sh} 2>&1") do |f|
         output = f.read
         @result << output
         @out << output
@@ -39,8 +49,12 @@ module VhdlDoctest
     end
 
     def report_result
-      failures = @result.split("\n").select { |l| l.include?('FAILED') }
-      @out << "\n#{@test_file.cases.size} examples, #{failures.size} failures\n"
+      formatter = ResultFormatter.new(@result)
+      @out << "\n\n\n"
+      @out << formatter.format
+      unless formatter.compile_error?
+        @out << "\n#{@test_file.cases.size} examples, #{formatter.count_failure} failures\n"
+      end
       @out << "\nTest directory: #{@dir}\n"
     end
   end

data/lib/vhdl_doctest/types/std_logic_vector.rb

@@ -9,7 +9,7 @@ module VhdlDoctest::Types
     end
 
     def format(v)
-      '"' + v.to_s(2).rjust(@length, '0')+ '"'
+      '"' + (2**@length + v).to_s(2)[-@length.. -1]+ '"'
     end
 
     def self.parse(str)

data/lib/vhdl_doctest/version.rb

@@ -1,3 +1,3 @@
 module VhdlDoctest
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

data/spec/dut_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
 module VhdlDoctest
-  sample_vhdl = 'examples/alu.vhd'
   describe DUT do
+    let(:sample_vhdl) { 'examples/alu.vhd' }
     subject { DUT.parse(sample_vhdl) }
 
     its(:entity) { should == "alu" }
@@ -11,11 +11,35 @@ module VhdlDoctest
 
     its('test_file.test_name') { should == 'testbench_alu' }
     its(:test_file) { should have(8).cases }
-  end
 
-  describe DUT::DoctestParser do
+    describe 'dependencies' do
+      subject(:dut) { DUT.new(vhdl) }
+
+      context 'actual file' do
+        let(:vhdl) { File.read('examples/alu_depending.vhd') }
+        its(:dependencies) { should == ['test.vhd'] }
+      end
+
+      context 'multi files' do
+        let(:vhdl) { %q{
+-- DOCTEST DEPENDENCIES: test.vhd, another.vhd
+} }
+
+        its(:dependencies) { should == ['test.vhd', 'another.vhd'] }
+      end
+
+      context 'multi definition lines' do
+        let(:vhdl) { %q{
+-- DOCTEST DEPENDENCIES: test.vhd
+-- DOCTEST DEPENDENCIES: another.vhd
+} }
+
+        its(:dependencies) { should == ['test.vhd', 'another.vhd'] }
+      end
+    end
+
     describe 'ports' do
-      subject { described_class.new(sample_vhdl).extract_ports }
+      subject(:ports) { DUT.parse(sample_vhdl).ports }
 
       it { should have(5).items }
       its('first.port_definition') { should == "a : in std_logic_vector(31 downto 0)" }

data/spec/result_formatter_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+module VhdlDoctest
+  describe ResultFormatter do
+    let(:dut_file) { "examples/alu.vhd/" }
+    subject(:formatted_result) { described_class.new(output) }
+
+    context "test did not run" do
+      let(:output) { %q{
+/tmp/main_decoder.vhd:193:27: ')' expected at end of interface list
+/tmp/main_decoder.vhd:193:29: missing ";" at end of port clause
+/tmp/main_decoder.vhd:193:29: 'end' is expected instead of 'out'
+ghdl: compilation error
+error: cannot find entity or configuration testbench_main_decoder
+ghdl: compilation error
+ghdl: file 'testbench_main_decoder' does not exists
+ghdl: Please elaborate your design.
+}}
+
+      it { should be_compile_error }
+      it { should_not be_succeeded }
+      its(:format) { should match /FAIL/ }
+      its(:format) { should match /Test did not run/ }
+    end
+
+    context "test run, but one case failed" do
+      let(:output) { %q{/tmp/d20120910-14672-k0mvgz/testbench_main_decoder.vhd:587:1:@790ns:(assertion warning): FAILED: op = 44, rx_done = 0, stage = 1 expected to next_stage = 2, bus_to_reg = 0, alu_src = 0, pc_src = 0, reg_dst = 1, alu_control = 0, mem_write = 0, send_enable = 0, reg_write = 0, rx_enable = 0, but next_stage = 0010, bus_to_reg = 0, alu_src = 1, pc_src = 000, reg_dst = 0, alu_control = 0000, mem_write = 0, send_enable = 0, reg_write = 0, rx_enable = 0} }
+
+      it { should_not be_compile_error  }
+      it { should_not be_succeeded }
+      it "should pretty print the result" do
+        subject.format.should include %q{
+FAILED: op = 44, rx_done = 0, stage = 1
+  expected: next_stage = 2, bus_to_reg = 0, alu_src = 0, pc_src = 0, reg_dst = 1, alu_control = 0, mem_write = 0, send_enable = 0, reg_write = 0, rx_enable = 0
+    actual: next_stage = 2, bus_to_reg = 0, alu_src = 1, pc_src = 0, reg_dst = 0, alu_control = 0, mem_write = 0, send_enable = 0, reg_write = 0, rx_enable = 0
+}.strip
+      end
+      its(:count_failure) { should == 1 }
+    end
+
+    context "test succeeded, output nothing" do
+      let(:output) { "" }
+
+      it { should be_succeeded }
+    end
+
+    describe '#replace_binary' do
+      def replace_binary(str)
+        ResultFormatter.new('').replace_binary(str)
+      end
+
+      specify do
+        expect(replace_binary('next_stage = 0010')).to eq('next_stage = 2')
+      end
+
+      specify do
+        expect(replace_binary('next_stage = 0010, alu_control = 0000')).
+          to eq('next_stage = 2, alu_control = 0')
+      end
+    end
+  end
+end

data/spec/test_parser_spec.rb

@@ -25,7 +25,7 @@ module VhdlDoctest
         Port.new("output",  :out, Types::StdLogicVector.new(32)),
         Port.new("zero",    :out, Types::StdLogic.new)
       ]}
-    subject(:cases) { TestParser.parse(ports, input) }
+    subject(:cases) { TestParser.new(input).parse(ports) }
 
     describe 'header only' do
       let(:input) { %q{
@@ -83,7 +83,7 @@ module VhdlDoctest
 -- /TEST
 }}
 
-      it { expect{ cases }.to raise_error(OutOfRangeSymbolError, /control.*binary.*012/) }
+      it { expect{ cases }.to raise_error(OutOfRangeSymbolError) }
     end
 
     describe 'dont care in assertion' do
@@ -164,6 +164,21 @@ module VhdlDoctest
       specify { cases.last.should assert(zero: 0) }
     end
 
+    describe 'use a longer alias first' do
+      let(:input) { %q{
+-- TEST
+-- alias FOO 1
+-- alias FOOBAR 0
+-- a   | b   | control | zero
+-- 10  | -10 | 2       | FOO
+-- 10  | 10  | 2       | FOOBAR
+-- /TEST
+}}
+
+      specify { cases.first.should assert(zero: 1) }
+      specify { cases.last.should assert(zero: 0) }
+    end
+
     describe 'not enough fields' do
       let(:input) { %q{
 -- TEST
@@ -175,5 +190,38 @@ module VhdlDoctest
 
       specify { cases.should  have(1).item }
     end
+
+    describe 'custom field style' do
+      let(:input) { %q{
+-- TEST
+-- def f { |x| x.include?(".") ? [x.to_f].pack('f').unpack('I').first : x.to_i }
+-- a   f | b | control | zero
+--    10 | 1 | 0       | 0
+--  10.0 | 0 | 0       | 0
+-- /TEST
+}}
+
+      its(:first) { should set(a: 10) }
+      its(:last) { should set(a: 1092616192) }
+    end
+
+    describe '#decode' do
+      def decode(*args)
+        described_class.new(nil).decode(*args)
+      end
+      describe 'd' do
+        specify { decode('d', '10').should == 10 }
+        specify { decode('d', '-10').should == -10 }
+        specify { expect{ decode('d', 'hoge') }.to raise_error(OutOfRangeSymbolError) }
+      end
+    end
+
+    describe 'create lambda from def' do
+      it 'should define lambda with given name' do
+        name, proc = described_class.new(nil).def_to_lambda("def f { |x| x }")
+        name.should == 'f'
+        proc.call(3).should == 3
+      end
+    end
   end
 end

data/spec/test_runner_spec.rb

@@ -4,31 +4,54 @@ module VhdlDoctest
   describe TestRunner do
     let(:dut_file) { "examples/alu.vhd/" }
     describe "#run" do
+      let(:out) { StringIO.new }
+      subject { out.rewind; out.read }
+      before { described_class.new(out, dut_file, file).run }
+
       context "3 successful examples" do
-        let(:out) { StringIO.new }
         let(:file) { test_file([[18, 9, 0, 0, 1], [18, 18, 7, 0, 1], [18, 19, 7, 1, 0]]) }
-        subject { out.rewind; out.read }
-        before { described_class.new(out, dut_file, file).run }
 
         it { should match "3 examples, 0 failures" }
       end
 
       context "1 successful examples" do
-        let(:out) { StringIO.new }
         let(:file) { test_file([[18, 9, 0, 0, 1]]) }
-        subject { out.rewind; out.read }
-        before { described_class.new(out, dut_file, file).run }
 
         it { should match "1 examples, 0 failures" }
       end
 
       context "1 failing examples" do
-        let(:out) { StringIO.new }
         let(:file) { test_file([[18, 9, 0, 0, 0]]) }
-        subject { out.rewind; out.read }
-        before { described_class.new(out, dut_file, file).run }
 
         it { should match "1 examples, 1 failures" }
+        it { should match "actual:" }
+      end
+
+      context "stimuli including minus" do
+        let(:file) { test_file([[18, -9, 2, 9, 0]]) }
+
+        it { should match "1 examples, 0 failures" }
+      end
+
+      context "result including minus" do
+        let(:file) { test_file([[-18, -9, 2, -27, 0]]) }
+
+        it { should match "1 examples, 0 failures" }
+      end
+    end
+
+    describe '#create_runner_script' do
+      context 'a dependent module comparator.vhd is specified' do
+        before do
+          dir = nil
+          test_file = double(TestFile, path: '/test_file/path/test.vhd', test_name: 'test')
+          test_file.stub(:create) { |d| dir = d }
+          runner = described_class.new(nil, "/path/to/dut.vhd", test_file, %w{ ./comparator.vhd })
+          runner.create_files
+          @sh = File.join(dir, 'run.sh')
+        end
+        subject { File.read(@sh) }
+        it { should include '/path/to/comparator.vhd' }
       end
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vhdl_doctest
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-09 00:00:00.000000000 Z
+date: 2012-09-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -59,9 +59,11 @@ files:
 - Rakefile
 - bin/vhdl_doctest
 - examples/alu.vhd
+- examples/alu_depending.vhd
 - lib/vhdl_doctest.rb
 - lib/vhdl_doctest/dut.rb
 - lib/vhdl_doctest/port.rb
+- lib/vhdl_doctest/result_formatter.rb
 - lib/vhdl_doctest/test_case.rb
 - lib/vhdl_doctest/test_file.rb
 - lib/vhdl_doctest/test_parser.rb
@@ -72,6 +74,7 @@ files:
 - lib/vhdl_doctest/version.rb
 - spec/dut_spec.rb
 - spec/port_spec.rb
+- spec/result_formatter_spec.rb
 - spec/spec_helper.rb
 - spec/test_parser_spec.rb
 - spec/test_runner_spec.rb
@@ -91,7 +94,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -47820915
+      hash: 765515069
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -100,7 +103,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -47820915
+      hash: 765515069
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24
@@ -110,6 +113,7 @@ summary: Run parameterized test for VHDL written in doctest-like format.
 test_files:
 - spec/dut_spec.rb
 - spec/port_spec.rb
+- spec/result_formatter_spec.rb
 - spec/spec_helper.rb
 - spec/test_parser_spec.rb
 - spec/test_runner_spec.rb