convert to test case

test/test_complier.rb

@@ -1,7 +0,0 @@
-
-(puts("Usage: #{} SOURCE"); exit) if ARGV.empty?
-
-require_relative 'helper'
-require 'vm/compiler'
-
-Thnad::Compiler.new(ARGV.first).compile

test/test_nodes.rb

@@ -4,7 +4,7 @@ require_relative "helper"
 #testing that parsing strings that we know to be correct returns the nodes we expect
 # in a way the combination of test_parser and test_transform
 
-class NodesCase < MiniTest::Test
+class TestNodes < MiniTest::Test
 
   def setup
     @parser    = Parser::Parser.new

test/test_parser.rb

@@ -1,69 +1,68 @@
 require_relative 'helper'
 require 'minitest/spec'
 
-include Vm
+class ParserTest < MiniTest::Test
 
-describe Parser do
+  def setup
-  before do
     @parser = Parser::Parser.new
   end
 
-  it 'reads a number' do
+  def check
-    input    = '42 '
+    is = @parser.parse(@@input)
-    expected = {:number => '42'}
+    assert is
-
+    assert_equal @expected , is
-    @parser.number.parse(input).must_equal expected
+  end
+  def test_number
+    @input    = '42 '
+    @expected = {:number => '42'}
+    @parser = @parser.number
   end
 
-  it 'reads a name' do
+  def test_name
-    input    = 'foo '
+    @input    = 'foo '
-    expected = {:name => 'foo'}
+    @expected = {:name => 'foo'}
-
+    @parser = @parser.name
-    @parser.name.parse(input).must_equal expected
   end
 
-  it 'reads an argument list' do
+  def test_argument_list
-    input    = '(42, foo)'
+    @input    = '(42, foo)'
-    expected = {:args => [{:arg => {:number => '42'}},
+    @expected = {:args => [{:arg => {:number => '42'}},
                           {:arg => {:name   => 'foo'}}]}
-
+    @parser = @parser.args
-    @parser.args.parse(input).must_equal expected
   end
 
-  it 'reads a function call' do
+  def test_function_call
-    input = 'baz(42, foo)'
+    @input = 'baz(42, foo)'
-    expected = {:funcall => {:name => 'baz' },
+    @expected = {:funcall => {:name => 'baz' },
                 :args    => [{:arg => {:number => '42'}},
                              {:arg => {:name => 'foo'}}]}
 
-    @parser.funcall.parse(input).must_equal expected
+    @parser = @parser.funcall
   end
 
-  it 'reads a conditional' do
+  def test_conditional
-    input = <<HERE
+    @input = <<HERE
 if (0) {
   42
 } else {
   667
 }
 HERE
-
+    @expected = {:cond     => {:number => '0'},
-    expected = {:cond     => {:number => '0'},
                 :if_true  => {:body => {:number => '42'}},
                 :if_false => {:body => {:number => '667'}}}
-
+    @parser = @parser.cond
-    @parser.cond.parse(input).must_equal expected
   end
 
-  it 'reads a function definition' do
+  def test_function_definition
-    input    = <<HERE
+    @input    = <<HERE
 function foo(x) {
   5
 }
 HERE
-    expected = {:func   => {:name => 'foo'},
+    @expected = {:func   => {:name => 'foo'},
                 :params => {:param => {:name => 'x'}},
                 :body   => {:number => '5'}}
-    @parser.func.parse(input).must_equal expected
+    @parser = @parser.func
   end
 end