ajlisp 0.0.0

data/test/test_list.rb

@@ -0,0 +1,102 @@
+require 'ajlisp'
+require 'test/unit'
+
+module AjLisp
+
+class TestList < Test::Unit::TestCase
+    def test_initialize
+        list = List.new
+        assert_not_nil(list)
+    end
+    
+    def test_first_is_nil
+        list = List.new
+        assert_nil(list.first)
+    end
+    
+    def test_rest_is_nil
+        list = List.new
+        assert_nil(list.rest)
+    end
+    
+    def test_create_with_first
+        list = List.new("foo")
+        assert_equal("foo", list.first)
+        assert_nil(list.rest)
+    end
+    
+    def test_create_with_first_and_rest
+        rest = List.new("bar")
+        list = List.new("foo", rest)
+        assert_equal("foo", list.first)
+        assert_not_nil(list.rest)
+        assert_equal("bar", list.rest.first)
+        assert_nil(list.rest.rest)
+    end
+    
+    def test_create_from_array
+        list = List.make [1, "a", "foo"]
+        assert_not_nil list
+        assert_equal 1, list.first
+        assert_equal "a", list.rest.first
+        assert_equal "foo", list.rest.rest.first
+        assert_nil list.rest.rest.rest
+    end
+    
+    def test_create_from_nested_array
+        list = List.make [1, ["a", "b"], "foo"]
+        assert_not_nil list
+        assert_equal 1, list.first
+        
+        assert_equal "a", list.rest.first.first
+        assert_equal "b", list.rest.first.rest.first
+        assert_nil list.rest.first.rest.rest
+        
+        assert_equal "foo", list.rest.rest.first
+        assert_nil list.rest.rest.rest
+    end
+    
+    def test_create_from_array_with_symbols
+        list = List.make [1, :a, :foo]
+        assert_not_nil list
+        assert_equal 1, list.first
+        assert list.rest.first.is_a? AjLisp::NamedAtom
+        assert_equal :a, list.rest.first.name
+        assert list.rest.rest.first.is_a? AjLisp::NamedAtom
+        assert_equal :foo, list.rest.rest.first.name
+    end
+	
+	def test_simple_list_to_string
+		list = List.make [:a, :b]
+		assert_equal "(a b)", list.to_s
+	end
+	
+	def test_nested_list_to_string
+		list = List.make [:a, [:b, :c, [:d, :e]], :f]
+		assert_equal "(a (b c (d e)) f)", list.to_s
+	end
+	
+	def test_list_with_numbers_and_strings_to_string
+		list = List.make [:a, ["b", 2, [:d, :e]], :f]
+		assert_equal '(a ("b" 2 (d e)) f)', list.to_s
+	end
+    
+    def test_simple_list_is_equal_to_list
+        list = List.make [:a, :b]
+        list2 = List.make [:a, :b]
+        list3 = List.make [:a, :c]
+        assert list.isEqualTo(list2)
+        assert !list.isEqualTo(list3)
+        assert !list3.isEqualTo(list)
+        assert list.isEqualTo(list)
+        assert list2.isEqualTo(list)
+    end
+    
+    def test_empty_list
+        list = List.make []
+        
+        assert_nil list
+    end
+end
+
+end

data/test/test_load.rb

@@ -0,0 +1,74 @@
+require 'ajlisp'
+require 'test/unit'
+
+module AjLisp
+
+class TestEvaluateLoad < Test::Unit::TestCase
+  def test_evaluate_define123
+    result = loadFile("define123.lsp")
+		
+    assert_equal 3, result
+    assert_equal 1, AjLisp::context.getValue(:one)
+    assert_equal 2, AjLisp::context.getValue(:two)
+    assert_equal 3, AjLisp::context.getValue(:three)
+  end
+
+  def test_evaluate_dodefine123
+    result = loadFile("dodefine123.lsp")
+		
+    assert_equal 3, result
+    assert_equal 1, AjLisp::context.getValue(:one)
+    assert_equal 2, AjLisp::context.getValue(:two)
+    assert_equal 3, AjLisp::context.getValue(:three)
+  end
+	
+  def test_evaluate_mycons
+    result = loadFile("mycons.lsp")
+    
+    assert_not_nil result
+    assert result.is_a? List
+    assert_equal :a, result.first.name
+    assert_equal :b, result.rest.first.name
+    assert_nil result.rest.rest
+  end
+
+  def test_evaluate_append
+    loadFile("append.lsp")
+    
+    assert_equal "(1 2 3 4 5)", evaluateText("(append (list 1 2) (list 3 4 5))").to_s
+    assert_equal "(1 2)", evaluateText("(append (list 1 2) nil)").to_s
+    evaluateText("(define x '(b b))")
+    assert_equal "(b b)", evaluateText("(append x nil)").to_s
+    assert_equal "(b b b b)", evaluateText("(append x x)").to_s
+  end
+
+  def test_evaluate_mapfirst
+    loadFile("mapfirst.lsp")
+		
+    assert_equal "((1) (2) (3))", evaluateText("(mapfirst list (list 1 2 3))").to_s
+    assert_equal "(1 2 3)", evaluateText("(mapfirst first (quote ((1) (2) (3))))").to_s
+	end
+
+  def test_evaluate_mapcond
+    loadFile("mapcond.lsp")
+		
+    assert_equal "((2))", evaluateText("(mapcond list? (list 1 (list 2) 3))").to_s
+    assert_equal "(nil)", evaluateText("(mapcond nil? (list 1 nil 3))").to_s
+  end
+
+  def loadFile(filename)
+    fullname = File.expand_path(filename, File.dirname(__FILE__))
+    text = '(load "' + fullname + '")'
+    return evaluateText(text)
+  end
+
+  def evaluateText(text)
+    source = StringSource.new text
+    lexer = Lexer.new source
+    parser = Parser.new lexer
+    expr = parser.parseExpression
+    return AjLisp::evaluate AjLisp::context, expr
+  end
+end
+
+end

data/test/test_named_atom.rb

@@ -0,0 +1,33 @@
+
+require 'ajlisp'
+require 'test/unit'
+
+class TestNamedAtom < Test::Unit::TestCase
+	def test_initialize
+		atom = AjLisp::NamedAtom.new("a")
+		assert_equal(:a, atom.name)
+	end
+	
+	def test_evaluate_in_context
+		atom = AjLisp::NamedAtom.new("foo")
+		context = AjLisp::Context.new
+		context.setValue(:foo, "bar")
+		assert_equal("bar", atom.evaluate(context))
+	end 
+	
+	def test_atom_to_string
+		atom = AjLisp::NamedAtom.new("foo")
+		assert_equal "foo", atom.to_s
+	end
+    
+    def test_atom_is_equal
+        atom = AjLisp::NamedAtom.new("foo")
+        atom2 = AjLisp::NamedAtom.new("foo")
+        atom3 = AjLisp::NamedAtom.new("bar")
+        
+        assert atom.isEqualTo(atom2)
+        assert atom2.isEqualTo(atom)
+        assert !atom.isEqualTo(atom3)
+        assert !atom3.isEqualTo(atom)
+    end
+end

data/test/test_parser.rb

@@ -0,0 +1,252 @@
+require 'ajlisp'
+require 'test/unit'
+
+module AjLisp
+
+	class TestParser < Test::Unit::TestCase
+		def test_parse_atom		
+			source = StringSource.new "atom"
+			lexer = Lexer.new source
+			parser = Parser.new lexer
+			
+			expr = parser.parseExpression
+			
+			assert_not_nil expr
+			assert expr.is_a? NamedAtom
+			assert_equal :atom, expr.name
+			
+			assert_nil parser.parseExpression
+		end
+
+		def test_parse_add_atom		
+			source = StringSource.new "+"
+			lexer = Lexer.new source
+			parser = Parser.new lexer
+			
+			expr = parser.parseExpression
+			
+			assert_not_nil expr
+			assert expr.is_a? NamedAtom
+			assert_equal :+, expr.name
+			
+			assert_nil parser.parseExpression
+		end
+
+		def test_parse_integer
+			source = StringSource.new "123"
+			lexer = Lexer.new source
+			parser = Parser.new lexer
+			
+			expr = parser.parseExpression
+			
+			assert_not_nil expr
+			assert expr.is_a? Fixnum
+			assert_equal 123, expr
+			
+			assert_nil parser.parseExpression
+		end
+
+		def test_parse_string
+			source = StringSource.new '"foo"'
+			lexer = Lexer.new source
+			parser = Parser.new lexer
+			
+			expr = parser.parseExpression
+			
+			assert_not_nil expr
+			assert expr.is_a? String
+			assert_equal "foo", expr
+			
+			assert_nil parser.parseExpression
+		end
+
+		def test_parse_simple_list
+			source = StringSource.new "(foo bar)"
+			lexer = Lexer.new source
+			parser = Parser.new lexer
+			
+			expr = parser.parseExpression
+			
+			assert_not_nil expr
+			assert expr.is_a? List
+			assert_equal :foo, expr.first.name
+			assert_equal :bar, expr.rest.first.name
+			assert_nil expr.rest.rest
+			
+			assert_nil parser.parseExpression
+		end
+
+		def test_parse_add_list
+			source = StringSource.new "(+ 1 2)"
+			lexer = Lexer.new source
+			parser = Parser.new lexer
+			
+			expr = parser.parseExpression
+			
+			assert_not_nil expr
+			assert expr.is_a? List
+			assert_equal :+, expr.first.name
+			assert_equal 1, expr.rest.first
+			assert_equal 2, expr.rest.rest.first
+			assert_nil expr.rest.rest.rest
+			
+			assert_nil parser.parseExpression
+		end
+
+		def test_parse_list_with_list
+			source = StringSource.new "(cons (a b))"
+			lexer = Lexer.new source
+			parser = Parser.new lexer
+			
+			expr = parser.parseExpression
+			
+			assert_not_nil expr
+			assert expr.is_a? List
+			assert_equal :cons, expr.first.name
+			assert expr.rest.is_a? List
+			
+			assert_nil parser.parseExpression
+		end
+
+		def test_parse_list_with_two_lists
+			source = StringSource.new "(cons (quote a) (quote (a b)))"
+			lexer = Lexer.new source
+			parser = Parser.new lexer
+			
+			expr = parser.parseExpression
+			
+			assert_not_nil expr
+			assert expr.is_a? List
+			assert_equal :cons, expr.first.name
+			assert expr.rest.is_a? List
+			assert expr.rest.first.is_a? List
+			assert expr.rest.rest.first.is_a? List
+			
+			assert_nil parser.parseExpression
+		end
+
+		def test_parse_verb_atom		
+			source = StringSource.new ".do"
+			lexer = Lexer.new source
+			parser = Parser.new lexer
+			
+			expr = parser.parseExpression
+			
+			assert_not_nil expr
+			assert expr.is_a? DotVerbAtom
+			assert_equal ".do".intern, expr.name
+			
+			assert_nil parser.parseExpression
+		end
+
+		def test_parse_constant_atom		
+			source = StringSource.new "@String"
+			lexer = Lexer.new source
+			parser = Parser.new lexer
+			
+			expr = parser.parseExpression
+			
+			assert_not_nil expr
+			assert expr.is_a? AtConstantAtom
+			assert_equal :@String, expr.name
+			assert_equal "String", expr.constant
+			
+			assert_nil parser.parseExpression
+		end
+
+		def test_parse_quoted_atom
+			source = StringSource.new "'a"
+			lexer = Lexer.new source
+			parser = Parser.new lexer
+			
+			expr = parser.parseExpression
+			
+			assert_not_nil expr
+			assert expr.is_a? List
+			assert_equal :quote, expr.first.name
+	        assert_equal :a, expr.rest.first.name
+			
+			assert_nil parser.parseExpression
+		end
+
+		def test_parse_quoted_list
+			source = StringSource.new "'(a b)"
+			lexer = Lexer.new source
+			parser = Parser.new lexer
+			
+			expr = parser.parseExpression
+			
+			assert_not_nil expr
+			assert expr.is_a? List
+			assert_equal :quote, expr.first.name
+	        assert_equal :a, expr.rest.first.first.name
+	        assert_equal :b, expr.rest.first.rest.first.name
+			
+			assert_nil parser.parseExpression
+		end
+
+		def test_parse_backquoted_list
+			source = StringSource.new "`(a b)"
+			lexer = Lexer.new source
+			parser = Parser.new lexer
+			
+			expr = parser.parseExpression
+			
+			assert_not_nil expr
+			assert expr.is_a? List
+			assert_equal :backquote, expr.first.name
+	        assert_equal :a, expr.rest.first.first.name
+	        assert_equal :b, expr.rest.first.rest.first.name
+			
+			assert_nil parser.parseExpression
+		end
+	    
+		def test_parse_backquoted_atom
+			source = StringSource.new "`a"
+			lexer = Lexer.new source
+			parser = Parser.new lexer
+			
+			expr = parser.parseExpression
+			
+			assert_not_nil expr
+			assert expr.is_a? List
+			assert_equal :backquote, expr.first.name
+	        assert_equal :a, expr.rest.first.name
+	        assert_nil expr.rest.rest
+			
+			assert_nil parser.parseExpression
+		end
+	    
+		def test_parse_unquoted_list
+			source = StringSource.new ",(a b)"
+			lexer = Lexer.new source
+			parser = Parser.new lexer
+			
+			expr = parser.parseExpression
+			
+			assert_not_nil expr
+			assert expr.is_a? List
+			assert_equal :unquote, expr.first.name
+	        assert_equal :a, expr.rest.first.first.name
+	        assert_equal :b, expr.rest.first.rest.first.name
+			
+			assert_nil parser.parseExpression
+		end
+        
+	    def test_parse_empty_list
+			source = StringSource.new "()"
+			lexer = Lexer.new source
+			parser = Parser.new lexer
+			
+			expr = parser.parseExpression
+			
+			assert_not_nil expr
+			assert expr.is_a? List
+			assert expr.is_a? EmptyList
+			
+			assert_nil parser.parseExpression
+	    end
+	end
+
+end
+