sdl4r 0.9.1 → 0.9.2

data/test/sdl4r/parser_test.rb

@@ -30,19 +30,6 @@ module SDL4R
 
   class ParserTest < Test::Unit::TestCase
 
-    # Called before every test method runs. Can be used
-    # to set up fixture information.
-    def setup
-      # Do nothing
-    end
-
-    # Called after every test method runs. Can be used to tear
-    # down fixture information.
-
-    def teardown
-      # Do nothing
-    end
-
     public
 
     def test_empty
@@ -217,11 +204,13 @@ EOF
       assert_equal(910.11, values[6])
       assert_equal(12.13, values[7])
       assert_equal(1415.16, values[8])
-      assert_equal(171.8, values[9])
-      assert_equal(1.920, values[10])
       if defined? Flt::DecNum
+        assert_equal(Flt::DecNum("171.8"), values[9])
+        assert_equal(Flt::DecNum("1.920"), values[10])
         assert_equal(Flt::DecNum("12345678901234567890"), values[11])
       else
+        assert_equal(171.8, values[9])
+        assert_equal(1.920, values[10])
         assert_equal(12345678901234567890, values[11])
       end
     end
@@ -240,6 +229,7 @@ EOF
       assert_equal(1, values.size)
       assert_equal(nil, values[0])
       assert_equal(nil, tag1.attribute("attr1"))
+      assert(tag1.has_attribute?("attr1"))
     end
 
     def test_comments
@@ -272,6 +262,90 @@ EOF
       assert_equal(890, root.child("tag10").value)
     end
 
+    def test_double_quote_strings
+      root = SDL4R::read(
+<<EOF
+tag1 "cheese and cherry jam"
+tag2 "cheese and \\
+      cherry jam"
+tag3 "cheese \\
+      and \\
+      cherry jam"
+tag4 "Did you say this soup was \\"good\\"?"
+tag5 "Even my dog wouldn't\\thave\\tit!"
+tag6 "\\"\\t\\r\\n\\\\"
+tag7 equation="is not x=y*z" color="blue \\
+                                    and yellow"
+EOF
+      )
+
+      assert_equal "cheese and cherry jam", root.child("tag1").value, "double-quote string"
+      assert_equal(
+        "cheese and cherry jam", root.child("tag2").value, "continued double-quote string")
+      assert_equal(
+        "cheese and cherry jam", root.child("tag3").value, "continued double-quote string")
+      assert_equal(
+        'Did you say this soup was "good"?', root.child("tag4").value, "escaped quotes")
+      assert_equal(
+        "Even my dog wouldn't\thave\tit!", root.child("tag5").value, "escaped tabs")
+      assert_equal "\"\t\r\n\\", root.child("tag6").value, "escaped white spaces"
+      assert_equal "is not x=y*z", root.child("tag7").attribute("equation")
+      assert_equal "blue and yellow", root.child("tag7").attribute("color")
+    end
+
+    def test_backquote_strings
+      root = SDL4R::read <<EOF
+winfile `c:\\directory\\myfile.xls`
+talk `I said "something"`
+xml `
+<product>
+   <shoes color="blue"/>
+</product>
+`
+regex `\\w+\\.suite\\(\\)`
+EOF
+
+      assert_equal "c:\\directory\\myfile.xls", root.child("winfile").value
+      assert_equal 'I said "something"', root.child("talk").value
+      assert_equal(
+        "\n<product>\n   <shoes color=\"blue\"/>\n</product>\n", root.child("xml").value)
+      assert_equal "\\w+\\.suite\\(\\)", root.child("regex").value
+    end
+
+    def test_sub_tags
+      root = SDL4R::read <<EOF
+wax {
+}
+steack {
+  bees {
+    monopoly {
+    }
+  }
+  goat_cheese
+  truck {
+    cathedral
+  }
+}
+peanut.butter
+EOF
+
+      expected = Tag.new("root") do
+        new_child("wax")
+        new_child("steack") do
+          new_child("bees") do
+            new_child("monopoly")
+          end
+          new_child("goat_cheese")
+          new_child("truck") do
+            new_child("cathedral")
+          end
+        end
+        new_child("peanut.butter")
+      end
+
+      assert_equal expected, root
+    end
+
     private
 
     # Creates and returns a DateTime where an unspecified +zone_offset+ means 'the local zone
@@ -282,13 +356,10 @@ EOF
     end
 
     def parse_one_tag1(text)
-      root = Tag.new("root")
-      root.read(text)
+      root = SDL4R::read(text)
       tag1 = root.child("tag1")
       assert_not_nil(tag1, "tag1")
-
       assert_equal 1, root.child_count, "only 1 tag expected"
-
       return tag1
     end
   end

data/test/sdl4r/test.rb

@@ -22,7 +22,14 @@ end
 module SDL4R
 
   require 'fileutils'
+  require 'pathname'
   require 'date'
+  begin
+    # Try to use the Flt library, which defines DecNum
+    require "flt"
+  rescue LoadError
+    # Well, shouganai.
+  end
 
   require 'test/unit'
   require File.dirname(__FILE__) + '/../../lib/sdl4r/tag'
@@ -57,18 +64,31 @@ module SDL4R
     NAMESPACES = "Namespaces"
 
 
-    def initialize(test_method_name)
-      super(test_method_name)
-      @failures = 0
-      @assert_count = 0
-    end
-
     def assert_tags_equal(expected, actual, message)
       if expected != actual
         assert_equal(expected.to_s, actual.to_s, message)
       end
     end
 
+    # Returns a Pathname giving the location of the specified relative +filename+.
+    #
+    # +filename+:: path to a file relatively to this source file
+    #
+    def get_test_sdl_file_path(filename)
+      dir = File.dirname(__FILE__)
+      return Pathname.new(dir + '/' + filename)
+    end
+
+    @@root_basic_types = nil
+    @@root_structures = nil
+
+    def setup
+      super
+
+      @@root_basic_types ||= SDL4R::read(get_test_sdl_file_path("test_basic_types.sdl"))
+      @@root_structures ||= SDL4R::read(get_test_sdl_file_path("test_structures.sdl"))
+    end
+
     ######################################
     # Tag Tests
     ######################################
@@ -105,14 +125,16 @@ module SDL4R
         "attributes()")
     end
 
-    def get_file_as_string(filename)
-      data = ''
-      File.open(filename, "r") { |f|
-        f.each_line do |line|
-          data += line
-        end
-      }
-      return data
+    def test_tag_write_parse_basic_types
+      if not defined? Flt::DecNum
+        fail("this test fails without the Flt library")
+      end
+      
+      test_tag_write_parse @@root_basic_types
+    end
+
+    def test_tag_write_parse_structures
+      test_tag_write_parse @@root_structures
     end
 
     #
@@ -122,24 +144,22 @@ module SDL4R
 #      puts '========================================'
 #      puts root.to_s
 #      puts '========================================'
-#
-#      File.open("d:\\dev\\tmp\\root.sdl", "w") { |io| io.write(root.children_to_string) }
-#      File.open("d:\\dev\\tmp\\root_reparsed.sdl", "w") { |io| io.write(Tag.new("test").read(root.to_s).child("root").children_to_string) }
 
-      assert_tags_equal(
-        root,
-        Tag.new("test").read(root.to_s).child("root"),
-        "write/parse")
+      write_parse_root = Tag.new("test").read(root.to_s).child("root");
+
+#      File.open("d:\\dev\\tmp\\root.sdl", "w") { |io| io.write(root.to_string) }
+#      File.open("d:\\dev\\tmp\\root_reparsed.sdl", "w") { |io| io.write(write_parse_root.to_string) }
+
+      assert_tags_equal(root, write_parse_root, "write/parse")
     end
 
     ######################################
     # Basic Types Tests
     ######################################
 
-    #
-    # +root+: a Tag
-    #
-    def test_strings(root)
+    def test_strings
+      root = @@root_basic_types
+
       # Doing String tests...
       # Doing basic tests including new line handling...
       assert_equal(root.child("string1").value, "hello", STRING_DECLARATIONS)
@@ -157,17 +177,18 @@ module SDL4R
       assert_equal(root.child("string10").value, "escapes \"\\\n\t", STRING_DECLARATIONS)
 
       # Checking unicode strings...
-      assert_equal(root.child("japanese").value, "日本語", STRING_DECLARATIONS)
-      assert_equal(root.child("korean").value, "여보세요", STRING_DECLARATIONS)
-      assert_equal(root.child("russian").value, "здравствулте", STRING_DECLARATIONS)
+      assert_equal(root.child("japanese.hello").value, "日本語", STRING_DECLARATIONS)
+      assert_equal(root.child("korean.hello").value, "여보세요", STRING_DECLARATIONS)
+      assert_equal(root.child("russian.hello").value, "здравствулте", STRING_DECLARATIONS)
         
       # More new line tests...
       assert(root.child("xml").value.index("<text>Hi there!</text>") >= 0, STRING_DECLARATIONS)
       assert_equal(root.child("line_test").value, "\nnew line above and below\n", STRING_DECLARATIONS)
     end
 
-    def test_characters(root)
-      # Doing character tests...
+    def test_characters
+      root = @@root_basic_types
+
       assert_equal(root.child("char1").value, 'a', CHARACTER_DECLARATIONS)
       assert_equal(root.child("char2").value, 'A', CHARACTER_DECLARATIONS)
       assert_equal(root.child("char3").value, '\\', CHARACTER_DECLARATIONS)
@@ -175,16 +196,19 @@ module SDL4R
       assert_equal(root.child("char5").value, "\t", CHARACTER_DECLARATIONS)
       assert_equal(root.child("char6").value, '\'', CHARACTER_DECLARATIONS)
       assert_equal(root.child("char7").value, '"', CHARACTER_DECLARATIONS)
+    end
 
-      # Doing unicode character tests...
-      if RUBY_VERSION >= '1.9.0'
-        assert_equal(root.child("char8").value, "\u65e5", CHARACTER_DECLARATIONS)
-        assert_equal(root.child("char9").value, "\uc5ec", CHARACTER_DECLARATIONS)
-        assert_equal(root.child("char10").value, "\u0437", CHARACTER_DECLARATIONS)
-      end
+    def test_characters_unicode
+      root = @@root_basic_types
+
+      assert_equal(root.child("char8").value, "日", CHARACTER_DECLARATIONS) # \u65e5
+      assert_equal(root.child("char9").value, "여", CHARACTER_DECLARATIONS) # \uc5ec
+      assert_equal(root.child("char10").value, "з", CHARACTER_DECLARATIONS) # \u0437
     end
 
-    def test_numbers(root)
+    def test_numbers
+      root = @@root_basic_types
+
       # Testing ints...
       assert_equal(root.child("int1").value, 0, NUMBER_DECLARATIONS)
       assert_equal(root.child("int2").value, 5, NUMBER_DECLARATIONS)
@@ -216,25 +240,33 @@ module SDL4R
         root.child("decimal3").value, 234535.3453453453454345345341242343, NUMBER_DECLARATIONS);
     end
 
-    def test_booleans(root)
+    def test_booleans
+      root = @@root_basic_types
+
       assert_equal(root.child("light-on").value, true, BOOLEAN_DECLARATIONS)
       assert_equal(root.child("light-off").value, false, BOOLEAN_DECLARATIONS)
       assert_equal(root.child("light1").value, true, BOOLEAN_DECLARATIONS)
       assert_equal(root.child("light2").value, false, BOOLEAN_DECLARATIONS)
     end
 
-    def test_null(root)
+    def test_null
+      root = @@root_basic_types
+
       assert_equal(root.child("nothing").value, nil, NULL_DECLARATION);
     end
       
-    def test_dates(root)
+    def test_dates
+      root = @@root_basic_types
+
       assert_equal(root.child("date1").value, Date.civil(2005, 12, 31), DATE_DECLARATIONS)
       assert_equal(root.child("date2").value, Date.civil(1882, 5, 2), DATE_DECLARATIONS)
       assert_equal(root.child("date3").value, Date.civil(1882, 5, 2), DATE_DECLARATIONS)
       assert_equal(root.child("_way_back").value, Date.civil(582, 9, 16), DATE_DECLARATIONS)
     end
     
-    def test_time_spans(root)
+    def test_time_spans
+      root = @@root_basic_types
+
       assert_equal(
         root.child("time1").value, SdlTimeSpan.new(0,12,30,0,0), TIME_SPAN_DECLARATIONS)
       assert_equal(
@@ -269,7 +301,8 @@ module SDL4R
         root.child("time14").value, SdlTimeSpan.new(-5,-12,-30,-23,-123), TIME_SPAN_DECLARATIONS)
     end
 
-    def test_date_times(root)
+    def test_date_times
+      root = @@root_basic_types
       local_offset = DateTime.now.offset
 
       assert_equal(root.child("date_time1").value,
@@ -292,7 +325,9 @@ module SDL4R
           DateTime.civil(985,04,11,12,30,23123.to_r/1000,"PST"), DATE_TIME_DECLARATIONS)
     end
 
-    def test_binaries(root)
+    def test_binaries
+      root = @@root_basic_types
+
       assert_equal(SDL4R::SdlBinary("hi"), root.child("hi").value, BINARY_DECLARATIONS)
       assert_equal(
         SDL4R::SdlBinary("hi"), root.child("hi").value, BINARY_DECLARATIONS)
@@ -314,11 +349,13 @@ module SDL4R
     # Structure Tests (values, attributes, children)
     ######################################
 
-    def test_empty_tag(root)
+    def test_empty_tag
+      root = @@root_structures
       assert_equal(root.child("empty_tag"), Tag.new("empty_tag"), EMPTY_TAG)
     end
 
-    def test_values(root)
+    def test_values
+      root = @@root_structures
       local_offset = DateTime.now.offset
 
       assert_equal(root.child("values1").values, ["hi"], VALUES)
@@ -364,15 +401,16 @@ module SDL4R
       assert_equal(root.child("values22").values, ["hi","ho","ho",5,"hi"], VALUES)
     end
       
-    def test_attributes(root)
+    def test_attributes
+      root = @@root_structures
+
       assert_equal(
         root.child("atts1").attributes, {"name" => "joe"}, ATTRIBUTES);
       assert_equal(root.child("atts2").attributes, {"size" => 5}, ATTRIBUTES);
       assert_equal(
         root.child("atts3").attributes, {"name" => "joe","size" => 5}, ATTRIBUTES);
       assert_equal(
-        root.child("atts4").attributes,
-        {"name"=>"joe","size"=>5,"smoker"=>false},
+        root.child("atts4").attributes, {"name"=>"joe","size"=>5,"smoker"=>false},
         ATTRIBUTES);
       assert_equal(
         root.child("atts5").attributes, {"name"=>"joe","smoker"=>false}, ATTRIBUTES);
@@ -388,7 +426,9 @@ module SDL4R
         root.child("atts9").attribute("key"), SDL4R::SdlBinary("mykey"), ATTRIBUTES)
     end
 
-    def test_values_and_attributes(root)
+    def test_values_and_attributes
+      root = @@root_structures
+
       assert_equal(root.child("valatts1").values, ["joe"], VALUES_AND_ATTRIBUTES)
       assert_equal(
         root.child("valatts1").attributes, {"size"=>5}, VALUES_AND_ATTRIBUTES)
@@ -443,13 +483,13 @@ module SDL4R
         VALUES_AND_ATTRIBUTES)
     end
 
-    def test_children(root)
+    def test_children
+      root = @@root_structures
       parent = root.child("parent")
 
       assert_equal(parent.children.size, 2, CHILDREN)
       assert_equal(parent.children[1].name, "daughter", CHILDREN)
 
-
       grandparent = root.child("grandparent")
 
       assert_equal(grandparent.children.size, 2, CHILDREN)
@@ -476,7 +516,8 @@ module SDL4R
       assert_equal([[1,2,3],[4,5,6]], matrix.children_values("content"), CHILDREN);
     end
 
-    def test_namespaces(root)
+    def test_namespaces
+      root = @@root_structures
       assert_equal(8, root.children(true, nil, "person").size, NAMESPACES);
 
       grandparent2 = root.child("grandparent3");
@@ -488,54 +529,5 @@ module SDL4R
         NAMESPACES);
     end
 
-    def get_test_sdl_file_path(filename)
-      dir = File.dirname(__FILE__)
-      return dir + '/' + filename
-    end
-
-    def test_basic_types
-      root = nil
-
-      # Reading test_basic_types.sdl
-      File.open(get_test_sdl_file_path("test_basic_types.sdl")) do |io|
-        root = Tag.new("root")
-        root.read(io)
-      end
-
-      test_tag_write_parse(root)
-      test_strings(root)
-      test_characters(root)
-      test_numbers(root)
-      test_booleans(root)
-      test_null(root)
-      test_dates(root)
-      test_time_spans(root)
-      test_date_times(root)
-      test_binaries(root)
-    end
-
-    def test_structures
-      root = nil
-
-      # Reading test_structures.sdl
-      File.open(get_test_sdl_file_path("test_structures.sdl")) do |io|
-        root = Tag.new("root")
-        root.read(io)
-      end
-
-      test_tag_write_parse(root)
-      test_empty_tag(root)
-      test_values(root)
-      test_attributes(root)
-      test_values_and_attributes(root)
-      test_children(root)
-      test_namespaces(root)
-    end
-
-    def report_error(test_name, error)
-      @failures += 1
-      puts "!! Failure: #{test_name} - #{error}"
-    end
-
   end
 end