sdl4r 0.9.1

data/test/sdl4r/parser_test.rb

@@ -0,0 +1,295 @@
+# Simple Declarative Language (SDL) for Ruby
+# Copyright 2005 Ikayzo, inc.
+#
+# This program is free software. You can distribute or modify it under the
+# terms of the GNU Lesser General Public License version 2.1 as published by
+# the Free Software Foundation.
+#
+# This program is distributed AS IS and WITHOUT WARRANTY. OF ANY KIND,
+# INCLUDING MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
+# See the GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program; if not, contact the Free Software Foundation, Inc.,
+# 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+
+module SDL4R
+  
+  require 'test/unit'
+
+  begin
+    # Try to use the Flt library, which defines DecNum
+    require "flt"
+  rescue LoadError
+    # Well, shouganai.
+  end
+  
+  require File.dirname(__FILE__) + '/../../lib/sdl4r/tag'
+  require File.dirname(__FILE__) + '/../../lib/sdl4r/sdl_binary'
+
+  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
+      root = Tag.new("root")
+      root.read("")
+      root.children(false) { fail("no child expected") }
+    end
+
+    def test_one_tag_alone
+      # Tag without namespace
+      tag1 = parse_one_tag1("tag1")
+      assert_equal("tag1", tag1.name, "name" )
+      assert_equal("", tag1.namespace, "namespace" )
+
+      assert_equal(0, tag1.values.size, "values")
+      assert_equal(0, tag1.attributes.size, "attributes")
+
+      # Tag with namespace
+      tag1 = parse_one_tag1("ns1:tag1")
+      assert_equal("tag1", tag1.name, "name" )
+      assert_equal("ns1", tag1.namespace, "namespace" )
+    end
+
+    def test_tag_with_one_value
+      tag1 = parse_one_tag1("tag1 1")
+      assert_not_nil(tag1, "tag1")
+      assert_equal(1, tag1.value, "value")
+    end
+
+    def test_tag_with_two_values
+      tag1 = parse_one_tag1("tag1 1 \"abc\"")
+      assert_not_nil(tag1, "tag1")
+      values = tag1.values
+      assert_equal(1, values[0], "1st value")
+      assert_equal("abc", values[1], "2nd value")
+    end
+
+    def test_tag_with_double_quote_string_values
+      tag1 = parse_one_tag1("tag1 \"abc\" \"d\\\ne\\\nf\" \"g\\\n  \t hi\"")
+      assert_not_nil(tag1, "tag1")
+      values = tag1.values
+      assert_equal("abc", values[0], "values[0]")
+      assert_equal("def", values[1], "values[1]")
+      assert_equal("ghi", values[2], "values[2]")
+    end
+
+    def test_tag_with_back_quote_string_values
+      tag1 = parse_one_tag1(
+        "tag1 `abc` \"d`e`f\" `g\"h\"i` `j\\k+l` `m\\\nn\\\r\n \t o\r`")
+      assert_not_nil(tag1, "tag1")
+      values = tag1.values
+      assert_equal("abc", values[0], "values[0]")
+      assert_equal("d`e`f", values[1], "values[1]")
+      assert_equal("g\"h\"i", values[2], "values[2]")
+      assert_equal("j\\k+l", values[3], "values[3]")
+      assert_equal("m\\\nn\\\n \t o\n", values[4], "values[4]")
+    end
+
+    def test_tag_with_base64_values
+      tag1 = parse_one_tag1(
+        <<EOF
+tag1 [V2VsY29tZSB0byB0aGUgY3J1ZWwgd29ybGQu] [
+    SG9wZSB5
+    b3UnbGwg
+    ZmluZCB5
+    b3VyIHdh
+    eS4=
+]
+EOF
+        )
+      assert_not_nil(tag1, "tag1")
+      values = tag1.values
+      assert_equal(SDL4R::SdlBinary("Welcome to the cruel world."), values[0], "values[0]")
+      assert_equal(SDL4R::SdlBinary("Hope you'll find your way."), values[1], "values[1]")
+    end
+
+    def test_tag_with_one_attribute
+      tag1 = parse_one_tag1("tag1 attr1=99")
+      assert_not_nil(tag1, "tag1")
+
+      values = tag1.values
+      assert(values.empty?, "value count")
+
+      attributes = tag1.attributes
+      assert_equal(1, attributes.size, "attribute count")
+      assert_equal(99, attributes["attr1"], "attr1")
+    end
+
+    def test_tag_with_attributes
+      tag1 = parse_one_tag1(
+        "tag1 attr1=\"99\" ns:attr2=[QmVhdXR5IGlzIG5vdCBlbm91Z2gu]")
+      assert_not_nil(tag1, "tag1")
+
+      attributes = tag1.attributes
+      assert_equal(2, attributes.size, "attribute count")
+      assert_equal("99", attributes["attr1"], "attr1")
+      assert_equal(SDL4R::SdlBinary("Beauty is not enough."), attributes["ns:attr2"], "attr2")
+    end
+    
+    def test_date
+      tag1 = parse_one_tag1("tag1 2005/12/05")
+      date = tag1.value
+      assert_equal(Date.civil(2005, 12, 5), date, "date value")
+    end
+
+    def test_time
+      tag1 = parse_one_tag1(
+        "tag1 time=12:23:56 short_time=00:12:32.423" +
+        " long_time=30d:15:23:04.023 before=-00:02:30")
+      assert_equal(
+        SdlTimeSpan.new(0, 12, 23, 56),
+        tag1.attribute("time"),
+        "time");
+      assert_equal(
+        SdlTimeSpan.new(0, 0, 12, 32, 423),
+        tag1.attribute("short_time"),
+        "short_time");
+      assert_equal(
+        SdlTimeSpan.new(30, 15, 23, 4, 23),
+        tag1.attribute("long_time"),
+        "long_time");
+      assert_equal(
+        SdlTimeSpan.new(0, 0, -2, -30),
+        tag1.attribute("before"),
+        "before");
+    end
+
+    def test_date_time
+      tag1 = parse_one_tag1(
+        "tag1 date1=2008/06/01 12:34" +
+        " date2=1999/12/31 23:59:58" +
+        " date3=2000/05/01 12:01:35.997" +
+        " date4=2015/12/05 14:12:23.345-JST" +
+        " date5=1414/05/12 03:00:01.107-UTC-04" +
+        " date6=1807/11/11 22:28:13.888-GMT-08:30")
+      assert_equal(
+        local_civil_date(2008, 6, 1, 12, 34),
+        tag1.attribute("date1"),
+        "date1");
+      assert_equal(
+        local_civil_date(1999, 12, 31, 23, 59, 58),
+        tag1.attribute("date2"),
+        "date2");
+      assert_equal(
+        local_civil_date(2000, 5, 1, 12, 1, Rational(35997, 1000)),
+        tag1.attribute("date3"),
+        "date3");
+      assert_equal(
+        local_civil_date(2015, 12, 5, 14, 12, Rational(23345, 1000), Rational(9, 24)),
+        tag1.attribute("date4"),
+        "date4");
+      assert_equal(
+        local_civil_date(1414, 5, 12, 3, 0, Rational(1107, 1000), Rational(-4, 24)),
+        tag1.attribute("date5"),
+        "date5");
+      assert_equal(
+        local_civil_date(1807, 11, 11, 22, 28, Rational(13888, 1000), Rational(-85, 240)),
+        tag1.attribute("date6"),
+        "date6");
+    end
+
+    def test_numbers
+      tag1 = parse_one_tag1(
+        "tag1 123 3000000000 456l 789L 123.45f 67.8F 910.11 12.13d 1415.16D 171.8BD 1.920bd 12345678901234567890BD")
+      values = tag1.values
+      assert_equal(123, values[0])
+      assert_equal(3000000000, values[1])
+      assert_equal(456, values[2])
+      assert_equal(789, values[3])
+      assert_equal(123.45, values[4])
+      assert_equal(67.8, values[5])
+      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("12345678901234567890"), values[11])
+      else
+        assert_equal(12345678901234567890, values[11])
+      end
+    end
+
+    def test_booleans
+      tag1 = parse_one_tag1("tag1 b1=true b2=false b3=on b4=off")
+      assert_equal(true, tag1.attribute("b1"))
+      assert_equal(false, tag1.attribute("b2"))
+      assert_equal(true, tag1.attribute("b3"))
+      assert_equal(false, tag1.attribute("b4"))
+    end
+
+    def test_null
+      tag1 = parse_one_tag1("tag1 null attr1=null")
+      values = tag1.values
+      assert_equal(1, values.size)
+      assert_equal(nil, values[0])
+      assert_equal(nil, tag1.attribute("attr1"))
+    end
+
+    def test_comments
+      root = Tag.new("root")
+      root.read(
+              <<EOF
+tag1 123
+#tag2 456
+tag3 789
+--tag4 012
+tag5 345
+//tag6 678
+tag7 901
+/*tag8 234
+tag9 567*/
+tag10 890
+EOF
+      )
+      children = root.children
+      assert_equal(5, children.size, "children count")
+      assert_equal(123, root.child("tag1").value)
+      assert_nil(root.child("tag2"))
+      assert_equal(789, root.child("tag3").value)
+      assert_nil(root.child("tag4"))
+      assert_equal(345, root.child("tag5").value)
+      assert_nil(root.child("tag6"))
+      assert_equal(901, root.child("tag7").value)
+      assert_nil(root.child("tag8"))
+      assert_nil(root.child("tag9"))
+      assert_equal(890, root.child("tag10").value)
+    end
+
+    private
+
+    # Creates and returns a DateTime where an unspecified +zone_offset+ means 'the local zone
+    # offset' (contrarily to DateTime#civil())
+    def local_civil_date(year, month, day, hour = 0, min = 0, sec = 0, zone_offset = nil)
+      zone_offset = Rational(Time.now.utc_offset,  24 * 60 * 60) if zone_offset.nil?
+      return DateTime.civil(year, month, day, hour, min, sec, zone_offset)
+    end
+
+    def parse_one_tag1(text)
+      root = Tag.new("root")
+      root.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
+end

data/test/sdl4r/test.rb

@@ -0,0 +1,541 @@
+# Simple Declarative Language (SDL) for Ruby
+# Copyright 2005 Ikayzo, inc.
+#
+# This program is free software. You can distribute or modify it under the
+# terms of the GNU Lesser General Public License version 2.1 as published by
+# the Free Software Foundation.
+#
+# This program is distributed AS IS and WITHOUT WARRANTY. OF ANY KIND,
+# INCLUDING MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
+# See the GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program; if not, contact the Free Software Foundation, Inc.,
+# 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+
+if RUBY_VERSION < '1.9.0'
+  $KCODE = 'u'
+  require 'jcode'
+end
+
+module SDL4R
+
+  require 'fileutils'
+  require 'date'
+
+  require 'test/unit'
+  require File.dirname(__FILE__) + '/../../lib/sdl4r/tag'
+
+  # SDL unit tests.
+  #
+  # @author Daniel Leuck
+  #
+  class Test < Test::Unit::TestCase
+    
+    # Tag datastructure tests
+    TAG = "Tag"
+    TAG_WRITE_PARSE = "Tag Write Parse"
+
+    # Basic Types Tests
+    STRING_DECLARATIONS = "String Declarations"
+    CHARACTER_DECLARATIONS = "Character Declarations"
+    NUMBER_DECLARATIONS = "Number Declarations"
+    BOOLEAN_DECLARATIONS = "Boolean Declarations"
+    NULL_DECLARATION = "Null Declaration"
+    DATE_DECLARATIONS = "Date Declarations"
+    TIME_SPAN_DECLARATIONS = "Time Span Declarations"
+    DATE_TIME_DECLARATIONS = "Date Time Declarations"
+    BINARY_DECLARATIONS = "Binary Declarations";
+
+    # Structure Tests
+    EMPTY_TAG = "Empty Tag"
+    VALUES = "Values"
+    ATTRIBUTES = "Attributes"
+    VALUES_AND_ATTRIBUTES = "Values and Attributes"
+    CHILDREN = "Children"
+    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
+
+    ######################################
+    # Tag Tests
+    ######################################
+    def test_tag
+      # Test to make sure Tag ignores the order in which attributes are
+      # added.
+      t1 = Tag.new("test")
+      t1.set_attribute("foo", "bar")
+      t1.set_attribute("john", "doe")
+
+      t2 = Tag.new("test")
+      t2.set_attribute("john", "doe")
+      t2.set_attribute("foo", "bar")
+
+      assert_tags_equal(t1, t2, TAG)
+
+      # Making sure tags with different structures return false from .equals
+      t2.value = "item"
+      assert_not_equal(t1, t2, TAG)
+
+      t2.remove_value("item")
+      t2.set_attribute("another", "attribute")
+      assert_not_equal(t1, t2, TAG)
+
+      # Checking attributes namespaces
+      t2.set_attribute("name", "bill")
+      t2.set_attribute("smoker", true, "private")
+      t2.set_attribute("hobby", "hiking", "public")
+      t2.set_attribute("nickname", "tubby", "private")
+
+      assert_equal(
+        t2.attributes("private"),
+        { "smoker" => true, "nickname" => "tubby" },
+        "attributes()")
+    end
+
+    def get_file_as_string(filename)
+      data = ''
+      File.open(filename, "r") { |f|
+        f.each_line do |line|
+          data += line
+        end
+      }
+      return data
+    end
+
+    #
+    # Does a to_s/parse test on the specified Tag (+root+)
+    #
+    def test_tag_write_parse(root)
+#      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")
+    end
+
+    ######################################
+    # Basic Types Tests
+    ######################################
+
+    #
+    # +root+: a Tag
+    #
+    def test_strings(root)
+      # Doing String tests...
+      # Doing basic tests including new line handling...
+      assert_equal(root.child("string1").value, "hello", STRING_DECLARATIONS)
+      assert_equal(root.child("string2").value, "hi", STRING_DECLARATIONS)
+      assert_equal(root.child("string3").value, "aloha", STRING_DECLARATIONS)
+      assert_equal(root.child("string4").value, "hi there", STRING_DECLARATIONS)
+      assert_equal(root.child("string5").value, "hi there joe", STRING_DECLARATIONS)
+      assert_equal(root.child("string6").value, "line1\nline2", STRING_DECLARATIONS)
+      assert_equal(root.child("string7").value, "line1\nline2", STRING_DECLARATIONS)
+      assert_equal(root.child("string8").value, "line1\nline2\nline3", STRING_DECLARATIONS)
+      assert_equal(
+        root.child("string9").value,
+        "Anything should go in this line without escapes \\ \\\\ \\n " +
+        "\\t \" \"\" ' ''", STRING_DECLARATIONS)
+      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)
+        
+      # 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...
+      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)
+      assert_equal(root.child("char4").value, "\n", CHARACTER_DECLARATIONS)
+      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)
+
+      # 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
+    end
+
+    def test_numbers(root)
+      # Testing ints...
+      assert_equal(root.child("int1").value, 0, NUMBER_DECLARATIONS)
+      assert_equal(root.child("int2").value, 5, NUMBER_DECLARATIONS)
+      assert_equal(root.child("int3").value, -100, NUMBER_DECLARATIONS)
+      assert_equal(root.child("int4").value, 234253532, NUMBER_DECLARATIONS)
+
+      # Testing longs...
+      assert_equal(root.child("long1").value, 0, NUMBER_DECLARATIONS)
+      assert_equal(root.child("long2").value, 5, NUMBER_DECLARATIONS)
+      assert_equal(root.child("long3").value, 5, NUMBER_DECLARATIONS)
+      assert_equal(root.child("long4").value, 3904857398753453453, NUMBER_DECLARATIONS)
+
+      # Testing floats...
+      assert_equal(root.child("float1").value, 1, NUMBER_DECLARATIONS)
+      assert_equal(root.child("float2").value, 0.23, NUMBER_DECLARATIONS)
+      assert_equal(root.child("float3").value, -0.34, NUMBER_DECLARATIONS)
+
+      # Testing doubles..."
+      assert_equal(root.child("double1").value, 2, NUMBER_DECLARATIONS)
+      assert_equal(root.child("double2").value, -0.234, NUMBER_DECLARATIONS)
+      assert_equal(root.child("double3").value, 2.34, NUMBER_DECLARATIONS)
+
+      # Testing decimals (BigDouble in Java)...
+      assert_equal(
+        root.child("decimal1").value, 0, NUMBER_DECLARATIONS);
+      assert_equal(
+        root.child("decimal2").value, 11.111111, NUMBER_DECLARATIONS);
+      assert_equal(
+        root.child("decimal3").value, 234535.3453453453454345345341242343, NUMBER_DECLARATIONS);
+    end
+
+    def test_booleans(root)
+      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)
+      assert_equal(root.child("nothing").value, nil, NULL_DECLARATION);
+    end
+      
+    def test_dates(root)
+      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)
+      assert_equal(
+        root.child("time1").value, SdlTimeSpan.new(0,12,30,0,0), TIME_SPAN_DECLARATIONS)
+      assert_equal(
+        root.child("time2").value, SdlTimeSpan.new(0,24,0,0,0), TIME_SPAN_DECLARATIONS)
+      assert_equal(
+        root.child("time3").value, SdlTimeSpan.new(0,1,0,0,0), TIME_SPAN_DECLARATIONS)
+      assert_equal(
+        root.child("time4").value, SdlTimeSpan.new(0,1,0,0,0), TIME_SPAN_DECLARATIONS)
+      assert_equal(
+        root.child("time5").value, SdlTimeSpan.new(0,12,30,2,0), TIME_SPAN_DECLARATIONS)
+      assert_equal(
+        root.child("time6").value, SdlTimeSpan.new(0,12,30,23,0), TIME_SPAN_DECLARATIONS)
+      assert_equal(
+        root.child("time7").value, SdlTimeSpan.new(0,12,30,23,100), TIME_SPAN_DECLARATIONS)
+      assert_equal(
+        root.child("time8").value, SdlTimeSpan.new(0,12,30,23,120), TIME_SPAN_DECLARATIONS)
+      assert_equal(
+        root.child("time9").value, SdlTimeSpan.new(0,12,30,23,123), TIME_SPAN_DECLARATIONS)
+
+      # Checking time spans with days...
+      assert_equal(
+        root.child("time10").value, SdlTimeSpan.new(34,12,30,23,100), TIME_SPAN_DECLARATIONS)
+      assert_equal(
+        root.child("time11").value, SdlTimeSpan.new(1,12,30,0,0), TIME_SPAN_DECLARATIONS)
+      assert_equal(
+        root.child("time12").value, SdlTimeSpan.new(5,12,30,23,123), TIME_SPAN_DECLARATIONS)
+
+      # Checking negative time spans...
+      assert_equal(
+        root.child("time13").value, SdlTimeSpan.new(0,-12,-30,-23,-123), TIME_SPAN_DECLARATIONS)
+      assert_equal(
+        root.child("time14").value, SdlTimeSpan.new(-5,-12,-30,-23,-123), TIME_SPAN_DECLARATIONS)
+    end
+
+    def test_date_times(root)
+      local_offset = DateTime.now.offset
+
+      assert_equal(root.child("date_time1").value,
+          DateTime.civil(2005,12,31,12,30,0, local_offset), DATE_TIME_DECLARATIONS)
+      assert_equal(root.child("date_time2").value,
+          DateTime.civil(1882,5,2,12,30,0, local_offset), DATE_TIME_DECLARATIONS)
+      assert_equal(root.child("date_time3").value,
+          DateTime.civil(2005,12,31,1,0,0, local_offset), DATE_TIME_DECLARATIONS)
+      assert_equal(root.child("date_time4").value,
+          DateTime.civil(1882,5,2,1,0,0, local_offset), DATE_TIME_DECLARATIONS)
+      assert_equal(root.child("date_time5").value,
+          DateTime.civil(2005,12,31,12,30,2312.to_r/100, local_offset), DATE_TIME_DECLARATIONS)
+      assert_equal(root.child("date_time6").value,
+          DateTime.civil(1882,5,2,12,30,23123.to_r/1000, local_offset), DATE_TIME_DECLARATIONS)
+
+      # Checking timezones...
+      assert_equal(root.child("date_time7").value,
+          DateTime.civil(1882,5,2,12,30,23123.to_r/1000,"JST"), DATE_TIME_DECLARATIONS)
+      assert_equal(root.child("date_time8").value,
+          DateTime.civil(985,04,11,12,30,23123.to_r/1000,"PST"), DATE_TIME_DECLARATIONS)
+    end
+
+    def test_binaries(root)
+      assert_equal(SDL4R::SdlBinary("hi"), root.child("hi").value, BINARY_DECLARATIONS)
+      assert_equal(
+        SDL4R::SdlBinary("hi"), root.child("hi").value, BINARY_DECLARATIONS)
+      assert_equal(
+        SdlBinary.decode64(
+          "iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAKnRFWHRDcmVhdGlvbiBUaW1l" +
+          "AERpIDQgTXJ6IDIwMDMgMDA6MjQ6MDQgKzAxMDDdSQ6OAAAAB3RJTUUH0wMEAAcllPlrJgAA" +
+          "AAlwSFlzAAAK8AAACvABQqw0mAAAAARnQU1BAACxjwv8YQUAAADQSURBVHjaY2CgEDCCyZn/" +
+          "3YHkDhL1ejCkM+5kgXJ2zDQmXueShwwMh9+ALWSEGcCQfhZIvHlDnAk8PAwMHBxgJtyAa7bX" +
+          "UdT8/cvA8Ps3hP7zB4FBYn/+vGbweqyJaoCmpiaKASDFv35BNMBoZMzwGKKOidJYoNgAuBdm" +
+          "naXQgHRKDfgagxD89w8S+iAaFICwGIHFAgjrHUczAByySAaAMEgDLBphhv7/D8EYLgDZhAxA" +
+          "mkAKYYbAMMwwDAOQXYDuDXRXgDC6AR7SW8jITNQAACjZgdj4VjlqAAAAAElFTkSuQmCC"
+        ),
+        root.child("png").value,
+        BINARY_DECLARATIONS)
+    end
+
+    ######################################
+    # Structure Tests (values, attributes, children)
+    ######################################
+
+    def test_empty_tag(root)
+      assert_equal(root.child("empty_tag"), Tag.new("empty_tag"), EMPTY_TAG)
+    end
+
+    def test_values(root)
+      local_offset = DateTime.now.offset
+
+      assert_equal(root.child("values1").values, ["hi"], VALUES)
+      assert_equal(root.child("values2").values, ["hi","ho"], VALUES)
+      assert_equal(root.child("values3").values, [1, "ho"], VALUES)
+      assert_equal(root.child("values4").values, ["hi",5], VALUES)
+      assert_equal(root.child("values5").values, [1,2], VALUES)
+      assert_equal(root.child("values6").values, [1,2,3], VALUES)
+      assert_equal(
+        root.child("values7").values,
+        [nil,"foo",false,Date.civil(1980,12,5)],
+        VALUES)
+      assert_equal(
+        root.child("values8").values,
+        [nil, "foo", false, DateTime.civil(1980,12,5,12,30,0,local_offset),
+          "there", SdlTimeSpan.new(0,15,23,12,234)],
+        VALUES)
+      assert_equal(
+        root.child("values9").values,
+        [nil, "foo", false, DateTime.civil(1980,12,5,12,30,0,local_offset),
+          "there", DateTime.civil(1989,8,12,15,23,12234.to_r/1000,"JST")],
+        VALUES)
+      assert_equal(
+        root.child("values10").values,
+        [nil, "foo", false, DateTime.civil(1980,12,5,12,30,0,local_offset),
+          "there", SdlTimeSpan.new(0,15,23,12,234), "more stuff"],
+        VALUES)
+      assert_equal(
+        root.child("values11").values,
+        [nil, "foo", false, DateTime.civil(1980,12,5,12,30,0,local_offset),
+          "there", SdlTimeSpan.new(123,15,23,12,234), "more stuff here"],
+         VALUES)
+      assert_equal(root.child("values12").values, [1,3], VALUES)
+      assert_equal(root.child("values13").values, [1,3], VALUES)
+      assert_equal(root.child("values14").values, [1,3], VALUES)
+      assert_equal(root.child("values15").values, [1,2,4,5,6], VALUES)
+      assert_equal(root.child("values16").values, [1,2,5], VALUES)
+      assert_equal(root.child("values17").values, [1,2,5], VALUES)
+      assert_equal(root.child("values18").values, [1,2,7], VALUES)
+      assert_equal(root.child("values19").values, [1,3,5,7], VALUES)
+      assert_equal(root.child("values20").values, [1,3,5], VALUES)
+      assert_equal(root.child("values21").values, [1,3,5], VALUES)
+      assert_equal(root.child("values22").values, ["hi","ho","ho",5,"hi"], VALUES)
+    end
+      
+    def test_attributes(root)
+      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},
+        ATTRIBUTES);
+      assert_equal(
+        root.child("atts5").attributes, {"name"=>"joe","smoker"=>false}, ATTRIBUTES);
+      assert_equal(
+        root.child("atts6").attributes, {"name"=>"joe","smoker"=>false}, ATTRIBUTES);
+      assert_equal(root.child("atts7").attributes, {"name"=>"joe"}, ATTRIBUTES);
+      assert_equal(
+        root.child("atts8").attributes,
+        {"name"=>"joe","size"=>5,"smoker"=>false,
+          "text"=>"hi","birthday"=>Date.civil(1972,5,23)},
+        ATTRIBUTES);
+      assert_equal(
+        root.child("atts9").attribute("key"), SDL4R::SdlBinary("mykey"), ATTRIBUTES)
+    end
+
+    def test_values_and_attributes(root)
+      assert_equal(root.child("valatts1").values, ["joe"], VALUES_AND_ATTRIBUTES)
+      assert_equal(
+        root.child("valatts1").attributes, {"size"=>5}, VALUES_AND_ATTRIBUTES)
+
+      assert_equal(root.child("valatts2").values, ["joe"], VALUES_AND_ATTRIBUTES)
+      assert_equal(root.child("valatts2").attributes, {"size"=>5}, VALUES_AND_ATTRIBUTES)
+
+      assert_equal(root.child("valatts3").values, ["joe"], VALUES_AND_ATTRIBUTES)
+      assert_equal(root.child("valatts3").attributes, {"size"=>5}, VALUES_AND_ATTRIBUTES)
+
+      assert_equal(root.child("valatts4").values, ["joe"], VALUES_AND_ATTRIBUTES)
+      assert_equal(
+        root.child("valatts4").attributes,
+        {"size"=>5, "weight"=>160, "hat"=>"big"},
+        VALUES_AND_ATTRIBUTES)
+
+      assert_equal(
+        root.child("valatts5").values, ["joe", "is a\n nice guy"], VALUES_AND_ATTRIBUTES)
+      assert_equal(
+        root.child("valatts5").attributes,
+        {"size"=>5, "smoker"=>false},
+        VALUES_AND_ATTRIBUTES);
+
+      assert_equal(
+        root.child("valatts6").values, ["joe", "is a\n nice guy"], VALUES_AND_ATTRIBUTES)
+      assert_equal(
+        root.child("valatts6").attributes,
+        {"size"=>5, "house"=>"big and\n blue"},
+        VALUES_AND_ATTRIBUTES)
+
+      #####
+
+      assert_equal(
+        root.child("valatts7").values, ["joe", "is a\n nice guy"], VALUES_AND_ATTRIBUTES)
+      assert_equal(
+        root.child("valatts7").attributes,
+        {"size"=>5, "smoker"=>false},
+        VALUES_AND_ATTRIBUTES)
+
+      assert_equal(
+        root.child("valatts8").values, ["joe", "is a\n nice guy"], VALUES_AND_ATTRIBUTES)
+      assert_equal(
+        root.child("valatts8").attributes,
+        {"size"=>5, "smoker"=>false},
+        VALUES_AND_ATTRIBUTES);
+
+      assert_equal(
+        root.child("valatts9").values,["joe", "is a\n nice guy"], VALUES_AND_ATTRIBUTES)
+      assert_equal(
+        root.child("valatts9").attributes,
+        {"size"=>5, "smoker"=>false},
+        VALUES_AND_ATTRIBUTES)
+    end
+
+    def test_children(root)
+      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)
+      # recursive fetch of children
+      assert_equal(grandparent.children(true).size, 6, CHILDREN)
+      assert_equal(grandparent.children(true, "son").size, 2, CHILDREN)
+
+      grandparent2 = root.child("grandparent2")
+      assert_equal(grandparent2.children(true, "child").size, 5, CHILDREN)
+      assert_equal(
+        grandparent2.child("daughter", true).attribute("birthday"),
+        Date.civil(1976,04,18),
+        CHILDREN)
+
+      files = root.child("files")
+
+      assert_equal(
+        ["c:/file1.txt", "c:/file2.txt", "c:/folder"],
+        files.children_values("content"),
+        CHILDREN)
+
+      matrix = root.child("matrix")
+
+      assert_equal([[1,2,3],[4,5,6]], matrix.children_values("content"), CHILDREN);
+    end
+
+    def test_namespaces(root)
+      assert_equal(8, root.children(true, nil, "person").size, NAMESPACES);
+
+      grandparent2 = root.child("grandparent3");
+
+      # get only the attributes for Akiko in the public namespace
+      assert_equal(
+        grandparent2.child("daughter", true).attributes("public"),
+        {"name"=>"Akiko", "birthday"=>Date.civil(1976,04,18)},
+        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