etapper 0.0.0

data/vendor/gems/soap4r-1.5.8.2/test/xsd/codegen/test_classdef.rb

@@ -0,0 +1,244 @@
+require 'test/unit'
+require 'xsd/codegen/classdef'
+
+
+module XSD; module CodeGen
+
+
+class TestClassDefCreator < Test::Unit::TestCase
+  include XSD::CodeGen
+  include GenSupport
+
+  def test_classdef_simple
+    c = ClassDef.new("Foo")
+    assert_equal(format(<<-EOD), c.dump)
+      class Foo
+      end
+    EOD
+  end
+
+  def test_classdef_complex
+    c = ClassDef.new("Foo::Bar::Baz", String)
+    assert_equal(format(<<-EOD), c.dump)
+      module Foo; module Bar
+
+      class Baz < String
+      end
+
+      end; end
+    EOD
+  end
+
+  def test_require
+    c = ClassDef.new("Foo")
+    c.def_require("foo/bar")
+    assert_equal(format(<<-EOD), c.dump)
+      require 'foo/bar'
+
+      class Foo
+      end
+    EOD
+  end
+
+  def test_comment
+    c = ClassDef.new("Foo")
+    c.def_require("foo/bar")
+    c.comment = <<-EOD
+      foo
+    EOD
+    assert_equal(format(<<-EOD), c.dump)
+      require 'foo/bar'
+
+      # foo
+      class Foo
+      end
+    EOD
+    c.comment = <<-EOD
+            foo
+
+              bar
+             baz
+
+    EOD
+    assert_equal(format(<<-EOD), c.dump)
+      require 'foo/bar'
+
+      # foo
+      # 
+      #   bar
+      #  baz
+      # 
+      class Foo
+      end
+    EOD
+  end
+
+  def test_emptymethod
+    c = ClassDef.new("Foo")
+    c.def_method('foo') do
+    end
+    c.def_method('bar') do
+      ''
+    end
+    assert_equal(format(<<-EOD), c.dump)
+      class Foo
+        def foo
+        end
+
+        def bar
+        end
+      end
+    EOD
+  end
+
+  def test_innermodule
+    c = ClassDef.new("Foo")
+    c.def_const("BAR", 1)
+    c.def_method('baz') { "Qux.new.quxx" }
+    c2 = ClassDef.new("Qux")
+    c2.def_method('quxx') { "Quxx::QUXXX" }
+    m3 = ModuleDef.new("Quxx")
+    m3.def_const("QUXXX", 2)
+    c.innermodule << c2 << m3
+    assert_equal(format(<<-EOD), c.dump)
+      class Foo
+        BAR = 1
+
+        class Qux
+          def quxx
+            Quxx::QUXXX
+          end
+        end
+
+        module Quxx
+          QUXXX = 2
+        end
+
+        def baz
+          Qux.new.quxx
+        end
+      end
+    EOD
+  end
+
+  def test_full
+    c = ClassDef.new("Foo::Bar::HobbitName", String)
+    c.def_require("foo/bar")
+    c.comment = <<-EOD
+        foo
+      bar
+        baz
+    EOD
+    c.def_const("FOO", 1)
+    c.def_classvar("@@foo", "var".dump)
+    c.def_classvar("baz", "1".dump)
+    c.def_attr("Foo", true, "foo")
+    c.def_attr("bar")
+    c.def_attr("baz", true)
+    c.def_attr("Foo2", true, "foo2")
+    c.def_attr("foo3", false, "foo3")
+    c.def_method("foo") do
+      <<-EOD
+        foo.bar = 1
+\tbaz.each do |ele|
+\t  ele
+        end
+      EOD
+    end
+    c.def_method("baz", "qux") do
+      <<-EOD
+        [1, 2, 3].each do |i|
+          p i
+        end
+      EOD
+    end
+
+    m = MethodDef.new("qux", "quxx", "quxxx") do
+      <<-EOD
+      p quxx + quxxx
+      EOD
+    end
+    m.comment = "hello world\n123"
+    c.add_method(m)
+    c.def_code <<-EOD
+      Foo.new
+      Bar.z
+    EOD
+    c.def_code <<-EOD
+      Foo.new
+      Bar.z
+    EOD
+    c.def_privatemethod("foo", "baz", "*arg", "&block")
+
+    assert_equal(format(<<-EOD), c.dump)
+    require 'foo/bar'
+
+    module Foo; module Bar
+
+    #   foo
+    # bar
+    #   baz
+    class HobbitName < String
+      @@foo = "var"
+      @@baz = "1"
+
+      FOO = 1
+
+      Foo.new
+      Bar.z
+
+      Foo.new
+      Bar.z
+
+      attr_accessor :bar
+      attr_accessor :baz
+      attr_reader :foo3
+
+      def Foo
+        @foo
+      end
+
+      def Foo=(value)
+        @foo = value
+      end
+
+      def Foo2
+        @foo2
+      end
+
+      def Foo2=(value)
+        @foo2 = value
+      end
+
+      def foo
+        foo.bar = 1
+        baz.each do |ele|
+          ele
+        end
+      end
+
+      def baz(qux)
+        [1, 2, 3].each do |i|
+          p i
+        end
+      end
+
+      # hello world
+      # 123
+      def qux(quxx, quxxx)
+        p quxx + quxxx
+      end
+
+    private
+
+      def foo(baz, *arg, &block)
+      end
+    end
+
+    end; end
+    EOD
+  end
+end
+
+
+end; end

data/vendor/gems/soap4r-1.5.8.2/test/xsd/noencoding.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="euc-jp"?>
+<schema xmlns="http://www.w3.org/2001/XMLSchema">
+  <!-- ������ -->
+</schema>

data/vendor/gems/soap4r-1.5.8.2/test/xsd/test_noencoding.rb

@@ -0,0 +1,32 @@
+require 'test/unit'
+require 'wsdl/xmlSchema/parser'
+
+
+module XSD
+
+
+class TestEmptyCharset < Test::Unit::TestCase
+  def setup
+    @file = File.join(File.dirname(File.expand_path(__FILE__)), 'noencoding.xml')
+  end
+
+  def test_wsdl
+    begin
+      xml = WSDL::XMLSchema::Parser.new.parse(File.open(@file) { |f| f.read })
+    rescue RuntimeError
+      if XSD::XMLParser.const_defined?("REXMLParser")
+	STDERR.puts("rexml cannot handle euc-jp without iconv/uconv.")
+	return
+      end
+      raise
+    rescue Errno::EINVAL
+      # unsupported encoding
+      return
+    end
+    assert_equal(WSDL::XMLSchema::Schema, xml.class)
+    assert_equal(0, xml.collect_elements.size)
+  end
+end
+
+
+end

data/vendor/gems/soap4r-1.5.8.2/test/xsd/test_ns.rb

@@ -0,0 +1,41 @@
+require 'test/unit'
+require 'soap/marshal'
+
+
+module XSD
+
+
+class TestNS < Test::Unit::TestCase
+  def test_xmllang
+    @file = File.join(File.dirname(File.expand_path(__FILE__)), 'xmllang.xml')
+    obj = SOAP::Marshal.load(File.open(@file) { |f| f.read })
+    assert_equal("12345", obj.partyDataLine.gln)
+    lang = obj.partyDataLine.__xmlattr[
+      XSD::QName.new(XSD::NS::Namespace, "lang")]
+    assert_equal("EN", lang)
+  end
+
+  def test_no_default_namespace
+    env = SOAP::Processor.unmarshal(NO_DEFAULT_NAMESPACE)
+    array = env.body.root_node["array"]
+    item = array["item"]
+    assert_equal("urn:ns", array.elename.namespace)
+    assert_equal(nil, item.elename.namespace)
+  end
+
+NO_DEFAULT_NAMESPACE = <<__XML__
+<?xml version="1.0" encoding="utf-8"?>
+<env:Envelope xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
+  <env:Body>
+    <response xmlns="urn:ns">
+      <array>
+        <item attr="1" xmlns=""/>
+      </array>
+    </response>
+  </env:Body>
+</env:Envelope>
+__XML__
+end
+
+
+end

data/vendor/gems/soap4r-1.5.8.2/test/xsd/test_xmlschemaparser.rb

@@ -0,0 +1,22 @@
+require 'test/unit'
+require 'wsdl/xmlSchema/parser'
+
+
+module XSD
+
+
+class TestXMLSchemaParser < Test::Unit::TestCase
+  def setup
+    @file = File.join(File.dirname(File.expand_path(__FILE__)), 'xmlschema.xml')
+  end
+
+  def test_wsdl
+    @wsdl = WSDL::XMLSchema::Parser.new.parse(File.open(@file) { |f| f.read })
+    assert_equal(WSDL::XMLSchema::Schema, @wsdl.class)
+    assert_equal(1, @wsdl.collect_elements.size)
+  end
+end
+
+
+
+end

data/vendor/gems/soap4r-1.5.8.2/test/xsd/test_xsd.rb

@@ -0,0 +1,1638 @@
+require 'test/unit'
+require 'xsd/datatypes'
+
+
+module XSD
+
+
+class TestXSD < Test::Unit::TestCase
+  NegativeZero = (-1.0 / (1.0 / 0.0))
+
+  def setup
+  end
+
+  def teardown
+  end
+
+  def assert_parsed_result(klass, str)
+    o = klass.new(str)
+    assert_equal(str, o.to_s)
+  end
+
+  def test_NSDBase
+    o = XSD::NSDBase.new
+    assert_equal(nil, o.type)
+  end
+
+  def test_XSDBase
+    o = XSD::XSDAnySimpleType.new
+    assert_equal(nil, o.data)
+    assert_equal(true, o.is_nil)
+    assert_equal('', o.to_s)
+  end
+
+  def test_XSDNil
+    o = XSD::XSDNil.new
+    assert_equal(XSD::Namespace, o.type.namespace)
+    assert_equal(XSD::NilLiteral, o.type.name)
+    assert_equal(nil, o.data)
+    assert_equal(true, o.is_nil)
+
+    o = XSD::XSDNil.new(nil)
+    assert_equal(true, o.is_nil)
+    assert_equal(nil, o.data)
+    assert_equal("", o.to_s)
+    o = XSD::XSDNil.new('var')
+    assert_equal(false, o.is_nil)
+    assert_equal('var', o.data)
+    assert_equal('var', o.to_s)
+  end
+
+  def test_XSDString_UTF8
+    o = XSD::XSDString.new
+    assert_equal(XSD::Namespace, o.type.namespace)
+    assert_equal(XSD::StringLiteral, o.type.name)
+    assert_equal(nil, o.data)
+    assert_equal(true, o.is_nil)
+
+    str = "abc"
+    assert_equal(str, XSD::XSDString.new(str).data)
+    assert_equal(str, XSD::XSDString.new(str).to_s)
+    back = XSD::XSDString.strict_ces_validation
+    XSD::XSDString.strict_ces_validation = true
+    begin
+      assert_raises(XSD::ValueSpaceError) do
+        XSD::XSDString.new("\0")
+      end
+      assert_raises(XSD::ValueSpaceError) do
+        p XSD::XSDString.new("\xC0\xC0").to_s
+      end
+    ensure
+      XSD::XSDString.strict_ces_validation = back
+    end
+  end
+
+  def test_XSDString_NONE
+    XSD::Charset.module_eval { @encoding_backup = @internal_encoding; @internal_encoding = "NONE" }
+    begin
+      o = XSD::XSDString.new
+      assert_equal(XSD::Namespace, o.type.namespace)
+      assert_equal(XSD::StringLiteral, o.type.name)
+      assert_equal(nil, o.data)
+      assert_equal(true, o.is_nil)
+
+      str = "abc"
+      assert_equal(str, XSD::XSDString.new(str).data)
+      assert_equal(str, XSD::XSDString.new(str).to_s)
+      back = XSD::XSDString.strict_ces_validation
+      XSD::XSDString.strict_ces_validation = true
+      begin
+        assert_raises(XSD::ValueSpaceError) do
+          XSD::XSDString.new("\0")
+        end
+        assert_raises(XSD::ValueSpaceError) do
+          XSD::XSDString.new("\xC0\xC0").to_s
+        end
+      ensure
+        XSD::XSDString.strict_ces_validation = back
+      end
+    ensure
+      XSD::Charset.module_eval { @internal_encoding = @encoding_backup }
+    end
+  end
+
+  def test_XSDNormalizedString
+    XSD::Charset.module_eval { @encoding_backup = @internal_encoding; @internal_encoding = "NONE" }
+    begin
+      o = XSD::XSDNormalizedString.new
+      assert_equal(XSD::Namespace, o.type.namespace)
+      assert_equal(XSD::NormalizedStringLiteral, o.type.name)
+      assert_equal(nil, o.data)
+      assert_equal(true, o.is_nil)
+
+      str = "abc"
+      assert_equal(str, XSD::XSDNormalizedString.new(str).data)
+      assert_equal(str, XSD::XSDNormalizedString.new(str).to_s)
+      back = XSD::XSDString.strict_ces_validation
+      XSD::XSDString.strict_ces_validation = true
+      begin
+        assert_raises(XSD::ValueSpaceError) do
+          XSD::XSDNormalizedString.new("\0")
+        end
+        assert_raises(XSD::ValueSpaceError) do
+          XSD::XSDNormalizedString.new("\xC0\xC0").to_s
+        end
+        assert_raises(XSD::ValueSpaceError) do
+          XSD::XSDNormalizedString.new("a\tb").to_s
+        end
+        assert_raises(XSD::ValueSpaceError) do
+          XSD::XSDNormalizedString.new("a\r").to_s
+        end
+        assert_raises(XSD::ValueSpaceError) do
+          XSD::XSDNormalizedString.new("\nb").to_s
+        end
+      ensure
+        XSD::XSDString.strict_ces_validation = back
+      end
+    ensure
+      XSD::Charset.module_eval { @internal_encoding = @encoding_backup }
+    end
+  end
+
+  def test_XSDToken
+    XSD::Charset.module_eval { @encoding_backup = @internal_encoding; @internal_encoding = "NONE" }
+    begin
+      o = XSD::XSDToken.new
+      assert_equal(XSD::Namespace, o.type.namespace)
+      assert_equal(XSD::TokenLiteral, o.type.name)
+      assert_equal(nil, o.data)
+      assert_equal(true, o.is_nil)
+
+      str = "abc"
+      assert_equal(str, XSD::XSDToken.new(str).data)
+      assert_equal(str, XSD::XSDToken.new(str).to_s)
+      back = XSD::XSDString.strict_ces_validation
+      XSD::XSDString.strict_ces_validation = true
+      begin
+        assert_raises(XSD::ValueSpaceError) do
+          XSD::XSDToken.new("\0")
+        end
+        assert_raises(XSD::ValueSpaceError) do
+          XSD::XSDToken.new("\xC0\xC0").to_s
+        end
+        assert_raises(XSD::ValueSpaceError) do
+          XSD::XSDToken.new("a\tb").to_s
+        end
+        assert_raises(XSD::ValueSpaceError) do
+          XSD::XSDToken.new("a\r").to_s
+        end
+        assert_raises(XSD::ValueSpaceError) do
+          XSD::XSDToken.new("\nb").to_s
+        end
+        assert_raises(XSD::ValueSpaceError) do
+          XSD::XSDToken.new(" a").to_s
+        end
+        assert_raises(XSD::ValueSpaceError) do
+          XSD::XSDToken.new("b ").to_s
+        end
+        assert_raises(XSD::ValueSpaceError) do
+          XSD::XSDToken.new("a  b").to_s
+        end
+        assert_equal("a b", XSD::XSDToken.new("a b").data)
+      ensure
+        XSD::XSDString.strict_ces_validation = back
+      end
+    ensure
+      XSD::Charset.module_eval { @internal_encoding = @encoding_backup }
+    end
+  end
+
+  def test_XSDLanguage
+    o = XSD::XSDLanguage.new
+    assert_equal(XSD::Namespace, o.type.namespace)
+    assert_equal(XSD::LanguageLiteral, o.type.name)
+    assert_equal(nil, o.data)
+    assert_equal(true, o.is_nil)
+
+    str = "ja"
+    assert_equal(str, XSD::XSDLanguage.new(str).data)
+    assert_equal(str, XSD::XSDLanguage.new(str).to_s)
+    str = "ja-jp"
+    assert_equal(str, XSD::XSDLanguage.new(str).data)
+    assert_equal(str, XSD::XSDLanguage.new(str).to_s)
+    assert_raises(XSD::ValueSpaceError) do
+      XSD::XSDLanguage.new("ja-jp-")
+    end
+    assert_raises(XSD::ValueSpaceError) do
+      XSD::XSDLanguage.new("-ja-")
+    end
+    assert_raises(XSD::ValueSpaceError) do
+      XSD::XSDLanguage.new("ja-")
+    end
+    assert_raises(XSD::ValueSpaceError) do
+      XSD::XSDLanguage.new("a1-01")
+    end
+    assert_equal("aA-01", XSD::XSDLanguage.new("aA-01").to_s)
+  end
+
+  def test_XSDBoolean
+    o = XSD::XSDBoolean.new
+    assert_equal(XSD::Namespace, o.type.namespace)
+    assert_equal(XSD::BooleanLiteral, o.type.name)
+    assert_equal(nil, o.data)
+    assert_equal(true, o.is_nil)
+
+    targets = [
+      ["true", true],
+      ["1", true],
+      ["false", false],
+      ["0", false],
+    ]
+    targets.each do |data, expected|
+      assert_equal(expected, XSD::XSDBoolean.new(data).data)
+      assert_equal(expected.to_s, XSD::XSDBoolean.new(data).to_s)
+    end
+
+    assert_raises(XSD::ValueSpaceError) do
+      XSD::XSDBoolean.new("nil").to_s
+    end
+  end
+
+  def test_XSDDecimal
+    o = XSD::XSDDecimal.new
+    assert_equal(XSD::Namespace, o.type.namespace)
+    assert_equal(XSD::DecimalLiteral, o.type.name)
+    assert_equal(nil, o.data)
+    assert_equal(true, o.is_nil)
+
+    targets = [
+      0,
+      1000000000,
+      -9999999999,
+      12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890,
+      12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890,
+      -1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789,
+    ]
+    targets.each do |dec|
+      assert_equal(dec.to_s, XSD::XSDDecimal.new(dec).data)
+    end
+
+    targets = [
+      "0",
+      "0.00000001",
+      "1000000000",
+      "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890",
+      "-12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123.45678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789",
+    ]
+    targets.each do |str|
+      assert_equal(str, XSD::XSDDecimal.new(str).to_s)
+    end
+
+    targets = [
+      ["-0", "0"],
+      ["+0", "0"],
+      ["0.0", "0"],
+      ["-0.0", "0"],
+      ["+0.0", "0"],
+      ["0.", "0"],
+      [".0", "0"],
+      [
+	"+0.12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890",
+	"0.1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789"
+     ],
+      [
+	".0000012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890",
+	"0.000001234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789"
+     ],
+      [
+	"-12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890.",
+	"-12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
+     ],
+    ]
+    targets.each do |data, expected|
+      assert_equal(expected, XSD::XSDDecimal.new(data).to_s)
+    end
+
+    targets = [
+      "0.000000000000a",
+      "00a.0000000000001",
+      "+-5",
+    ]
+    targets.each do |d|
+      assert_raises(XSD::ValueSpaceError) do
+	XSD::XSDDecimal.new(d)
+      end
+    end
+  end
+
+  def test_XSDFloat
+    o = XSD::XSDFloat.new
+    assert_equal(XSD::Namespace, o.type.namespace)
+    assert_equal(XSD::FloatLiteral, o.type.name)
+    assert_equal(nil, o.data)
+    assert_equal(true, o.is_nil)
+
+    targets = [
+      3.14159265358979,
+      12.34e36,
+      1.402e-45,
+      -1.402e-45,
+    ]
+    targets.each do |f|
+      assert_equal(f, XSD::XSDFloat.new(f).data)
+    end
+
+    targets = [
+      "+3.141592654",
+      "+1.234e+37",
+      "+1.402e-45",
+      "-1.402e-45",
+    ]
+    targets.each do |f|
+      assert_equal(f, XSD::XSDFloat.new(f).to_s)
+    end
+
+    targets = [
+      [3, "+3"], 	# should be 3.0?
+      [-2, "-2"],	# ditto
+      [3.14159265358979, "+3.141592654"],
+      [12.34e36, "+1.234e+37"],
+      [1.402e-45, "+1.402e-45"],
+      [-1.402e-45, "-1.402e-45"],
+      ["1.402e", "+1.402"],
+      ["12.34E36", "+1.234e+37"],
+      ["1.402E-45", "+1.402e-45"],
+      ["-1.402E-45", "-1.402e-45"],
+      ["1.402E", "+1.402"],
+    ]
+    targets.each do |f, str|
+      assert_equal(str, XSD::XSDFloat.new(f).to_s)
+    end
+
+    assert_equal("+0", XSD::XSDFloat.new(+0.0).to_s)
+    assert_equal("-0", XSD::XSDFloat.new(NegativeZero).to_s)
+    assert(XSD::XSDFloat.new(0.0/0.0).data.nan?)
+    assert_equal("INF", XSD::XSDFloat.new(1.0/0.0).to_s)
+    assert_equal(1, XSD::XSDFloat.new(1.0/0.0).data.infinite?)
+    assert_equal("-INF", XSD::XSDFloat.new(-1.0/0.0).to_s)
+    assert_equal(-1, XSD::XSDFloat.new(-1.0/0.0).data.infinite?)
+
+    targets = [
+      "0.000000000000a",
+      "00a.0000000000001",
+      "+-5",
+      "5_0",
+    ]
+    targets.each do |d|
+      assert_raises(XSD::ValueSpaceError) do
+	XSD::XSDFloat.new(d)
+      end
+    end
+  end
+
+  def test_XSDDouble
+    o = XSD::XSDDouble.new
+    assert_equal(XSD::Namespace, o.type.namespace)
+    assert_equal(XSD::DoubleLiteral, o.type.name)
+    assert_equal(nil, o.data)
+    assert_equal(true, o.is_nil)
+
+    targets = [
+      3.14159265358979,
+      12.34e36,
+      1.402e-45,
+      -1.402e-45,
+    ]
+    targets.each do |f|
+      assert_equal(f, XSD::XSDDouble.new(f).data)
+    end
+
+    targets = [
+      "+3.14159265358979",
+      "+1.234e+37",
+      "+1.402e-45",
+      "-1.402e-45",
+    ]
+    targets.each do |f|
+      assert_equal(f, XSD::XSDDouble.new(f).to_s)
+    end
+
+    targets = [
+      [3, "+3"],	# should be 3.0?
+      [-2, "-2"],	# ditto.
+      [3.14159265358979, "+3.14159265358979"],
+      [12.34e36, "+1.234e+37"],
+      [1.402e-45, "+1.402e-45"],
+      [-1.402e-45, "-1.402e-45"],
+      ["1.402e", "+1.402"],
+      ["12.34E36", "+1.234e+37"],
+      ["1.402E-45", "+1.402e-45"],
+      ["-1.402E-45", "-1.402e-45"],
+      ["1.402E", "+1.402"],
+    ]
+    targets.each do |f, str|
+      assert_equal(str, XSD::XSDDouble.new(f).to_s)
+    end
+
+    assert_equal("+0", XSD::XSDFloat.new(+0.0).to_s)
+    assert_equal("-0", XSD::XSDFloat.new(NegativeZero).to_s)
+    assert_equal("NaN", XSD::XSDDouble.new(0.0/0.0).to_s)
+    assert(XSD::XSDDouble.new(0.0/0.0).data.nan?)
+    assert_equal("INF", XSD::XSDDouble.new(1.0/0.0).to_s)
+    assert_equal(1, XSD::XSDDouble.new(1.0/0.0).data.infinite?)
+    assert_equal("-INF", XSD::XSDDouble.new(-1.0/0.0).to_s)
+    assert_equal(-1, XSD::XSDDouble.new(-1.0/0.0).data.infinite?)
+
+    targets = [
+      "0.000000000000a",
+      "00a.0000000000001",
+      "+-5",
+    ]
+    targets.each do |d|
+      assert_raises(XSD::ValueSpaceError) do
+	XSD::XSDDouble.new(d)
+      end
+    end
+  end
+
+  def test_XSDDuration
+    o = XSD::XSDDuration.new
+    assert_equal(XSD::Namespace, o.type.namespace)
+    assert_equal(XSD::DurationLiteral, o.type.name)
+    assert_equal(nil, o.data)
+    assert_equal(true, o.is_nil)
+
+    targets = [
+      "P1Y2M3DT4H5M6S",
+      "P1234Y5678M9012DT3456H7890M1234.5678S",
+      "PT3456H7890M1234.5678S",
+      "P1234Y5678M9012D",
+      "-P1234Y5678M9012DT3456H7890M1234.5678S",
+      "P5678M9012DT3456H7890M1234.5678S",
+      "-P1234Y9012DT3456H7890M1234.5678S",
+      "+P1234Y5678MT3456H7890M1234.5678S",
+      "P1234Y5678M9012DT7890M1234.5678S",
+      "-P1234Y5678M9012DT3456H1234.5678S",
+      "+P1234Y5678M9012DT3456H7890M",
+      "P123400000000000Y",
+      "-P567800000000000M",
+      "+P901200000000000D",
+      "PT345600000000000H",
+      "-PT789000000000000M",
+      "+PT123400000000000.000000000005678S",
+      "P1234YT1234.5678S",
+      "-P5678MT7890M",
+      "+P9012DT3456H",
+      "PT5S",
+    ]
+    targets.each do |str|
+      assert_parsed_result(XSD::XSDDuration, str)
+    end
+
+    targets = [
+      ["P0Y0M0DT0H0M0S",
+        "P0D"],
+      ["-P0DT0S",
+        "-P0D"],
+      ["P01234Y5678M9012DT3456H7890M1234.5678S",
+        "P1234Y5678M9012DT3456H7890M1234.5678S"],
+      ["P1234Y005678M9012DT3456H7890M1234.5678S",
+        "P1234Y5678M9012DT3456H7890M1234.5678S"],
+      ["P1234Y5678M0009012DT3456H7890M1234.5678S",
+        "P1234Y5678M9012DT3456H7890M1234.5678S"],
+      ["P1234Y5678M9012DT00003456H7890M1234.5678S",
+        "P1234Y5678M9012DT3456H7890M1234.5678S"],
+      ["P1234Y5678M9012DT3456H000007890M1234.5678S",
+        "P1234Y5678M9012DT3456H7890M1234.5678S"],
+      ["P1234Y5678M9012DT3456H7890M0000001234.5678S",
+        "P1234Y5678M9012DT3456H7890M1234.5678S"],
+    ]
+    targets.each do |data, expected|
+      assert_equal(expected, XSD::XSDDuration.new(data).to_s)
+    end
+  end
+
+  def test_XSDDateTime
+    o = XSD::XSDDateTime.new
+    assert_equal(XSD::Namespace, o.type.namespace)
+    assert_equal(XSD::DateTimeLiteral, o.type.name)
+    assert_equal(nil, o.data)
+    assert_equal(true, o.is_nil)
+
+    targets = [
+      "2002-05-18T16:52:20Z",
+      "0001-01-01T00:00:00Z",
+      "9999-12-31T23:59:59Z",
+      "19999-12-31T23:59:59Z",
+      "2002-12-31T23:59:59.999Z",
+      "2002-12-31T23:59:59.001Z",
+      "2002-12-31T23:59:59.99999999999999999999Z",
+      "2002-12-31T23:59:59.00000000000000000001Z",
+      "2002-12-31T23:59:59+09:00",
+      "2002-12-31T23:59:59+00:01",
+      "2002-12-31T23:59:59-00:01",
+      "2002-12-31T23:59:59-23:59",
+      "2002-12-31T23:59:59.00000000000000000001+13:30",
+      "2002-12-31T23:59:59.5137Z",
+      "2002-12-31T23:59:59.51375Z",	# 411/800
+      "2002-12-31T23:59:59.51375+12:34",
+      "-2002-05-18T16:52:20Z",
+      "-4713-01-01T12:00:00Z",
+      "-2002-12-31T23:59:59+00:01",
+      "-0001-12-31T23:59:59.00000000000000000001+13:30",
+    ]
+    targets.each do |str|
+      assert_parsed_result(XSD::XSDDateTime, str)
+    end
+
+    targets = [
+      ["2002-12-31T23:59:59.00",
+	"2002-12-31T23:59:59Z"],
+      ["2002-12-31T23:59:59+00:00",
+	"2002-12-31T23:59:59Z"],
+      ["2002-12-31T23:59:59-00:00",
+	"2002-12-31T23:59:59Z"],
+      ["-2002-12-31T23:59:59.00",
+	"-2002-12-31T23:59:59Z"],
+      ["-2002-12-31T23:59:59+00:00",
+	"-2002-12-31T23:59:59Z"],
+      ["-2002-12-31T23:59:59-00:00",
+	"-2002-12-31T23:59:59Z"],
+    ]
+    targets.each do |data, expected|
+      assert_equal(expected, XSD::XSDDateTime.new(data).to_s)
+      d = DateTime.parse(data)
+      d >>= 12 if d.year < 0    # XSDDateTime.year(-1) == DateTime.year(0)
+      assert_equal(expected, XSD::XSDDateTime.new(d).to_s)
+    end
+
+    targets = [
+      "0000-05-18T16:52:20Z",
+      "05-18T16:52:20Z",
+      "2002-05T16:52:20Z",
+      "2002-05-18T16:52Z",
+      "",
+    ]
+    targets.each do |d|
+      assert_raises(XSD::ValueSpaceError, d.to_s) do
+	XSD::XSDDateTime.new(d)
+      end
+    end
+  end
+
+  def test_XSDTime
+    o = XSD::XSDTime.new
+    assert_equal(XSD::Namespace, o.type.namespace)
+    assert_equal(XSD::TimeLiteral, o.type.name)
+    assert_equal(nil, o.data)
+    assert_equal(true, o.is_nil)
+
+    targets = [
+      "16:52:20Z",
+      "00:00:00Z",
+      "23:59:59Z",
+      "23:59:59.999Z",
+      "23:59:59.001Z",
+      "23:59:59.99999999999999999999Z",
+      "23:59:59.00000000000000000001Z",
+      "23:59:59+09:00",
+      "23:59:59+00:01",
+      "23:59:59-00:01",
+      "23:59:59-23:59",
+      "23:59:59.00000000000000000001+13:30",
+      "23:59:59.51345Z",
+      "23:59:59.51345+12:34",
+      "23:59:59+00:01",
+    ]
+    targets.each do |str|
+      assert_parsed_result(XSD::XSDTime, str)
+    end
+
+    targets = [
+      ["23:59:59.00",
+	"23:59:59Z"],
+      ["23:59:59+00:00",
+	"23:59:59Z"],
+      ["23:59:59-00:00",
+	"23:59:59Z"],
+    ]
+    targets.each do |data, expected|
+      assert_equal(expected, XSD::XSDTime.new(data).to_s)
+    end
+  end
+
+  def test_XSDDate
+    o = XSD::XSDDate.new
+    assert_equal(XSD::Namespace, o.type.namespace)
+    assert_equal(XSD::DateLiteral, o.type.name)
+    assert_equal(nil, o.data)
+    assert_equal(true, o.is_nil)
+
+    targets = [
+      "2002-05-18Z",
+      "0001-01-01Z",
+      "9999-12-31Z",
+      "19999-12-31Z",
+      "2002-12-31+09:00",
+      "2002-12-31+00:01",
+      "2002-12-31-00:01",
+      "2002-12-31-23:59",
+      "2002-12-31+13:30",
+      "-2002-05-18Z",
+      "-19999-12-31Z",
+      "-2002-12-31+00:01",
+      "-0001-12-31+13:30",
+    ]
+    targets.each do |str|
+      assert_parsed_result(XSD::XSDDate, str)
+    end
+
+    targets = [
+      ["2002-12-31",
+	"2002-12-31Z"],
+      ["2002-12-31+00:00",
+	"2002-12-31Z"],
+      ["2002-12-31-00:00",
+	"2002-12-31Z"],
+      ["-2002-12-31",
+	"-2002-12-31Z"],
+      ["-2002-12-31+00:00",
+	"-2002-12-31Z"],
+      ["-2002-12-31-00:00",
+	"-2002-12-31Z"],
+    ]
+    targets.each do |data, expected|
+      assert_equal(expected, XSD::XSDDate.new(data).to_s)
+      d = Date.parse(data)
+      d >>= 12 if d.year < 0    # XSDDate.year(-1) == Date.year(0)
+      assert_equal(expected, XSD::XSDDate.new(d).to_s)
+    end
+  end
+end
+
+class TestXSD2 < Test::Unit::TestCase
+  def setup
+    # Nothing to do.
+  end
+
+  def teardown
+    # Nothing to do.
+  end
+
+  def assert_parsed_result(klass, str)
+    o = klass.new(str)
+    assert_equal(str, o.to_s)
+  end
+
+  def test_XSDGYearMonth
+    o = XSD::XSDGYearMonth.new
+    assert_equal(XSD::Namespace, o.type.namespace)
+    assert_equal(XSD::GYearMonthLiteral, o.type.name)
+    assert_equal(nil, o.data)
+    assert_equal(true, o.is_nil)
+
+    targets = [
+      "2002-05Z",
+      "0001-01Z",
+      "9999-12Z",
+      "19999-12Z",
+      "2002-12+09:00",
+      "2002-12+00:01",
+      "2002-12-00:01",
+      "2002-12-23:59",
+      "2002-12+13:30",
+      "-2002-05Z",
+      "-19999-12Z",
+      "-2002-12+00:01",
+      "-0001-12+13:30",
+    ]
+    targets.each do |str|
+      assert_parsed_result(XSD::XSDGYearMonth, str)
+    end
+
+    targets = [
+      ["2002-12",
+	"2002-12Z"],
+      ["2002-12+00:00",
+	"2002-12Z"],
+      ["2002-12-00:00",
+	"2002-12Z"],
+      ["-2002-12",
+	"-2002-12Z"],
+      ["-2002-12+00:00",
+	"-2002-12Z"],
+      ["-2002-12-00:00",
+	"-2002-12Z"],
+    ]
+    targets.each do |data, expected|
+      assert_equal(expected, XSD::XSDGYearMonth.new(data).to_s)
+    end
+  end
+
+  def test_XSDGYear
+    o = XSD::XSDGYear.new
+    assert_equal(XSD::Namespace, o.type.namespace)
+    assert_equal(XSD::GYearLiteral, o.type.name)
+    assert_equal(nil, o.data)
+    assert_equal(true, o.is_nil)
+
+    targets = [
+      "2002Z",
+      "0001Z",
+      "9999Z",
+      "19999Z",
+      "2002+09:00",
+      "2002+00:01",
+      "2002-00:01",
+      "2002-23:59",
+      "2002+13:30",
+      "-2002Z",
+      "-19999Z",
+      "-2002+00:01",
+      "-0001+13:30",
+    ]
+    targets.each do |str|
+      assert_parsed_result(XSD::XSDGYear, str)
+    end
+
+    targets = [
+      ["2002",
+	"2002Z"],
+      ["2002+00:00",
+	"2002Z"],
+      ["2002-00:00",
+	"2002Z"],
+      ["-2002",
+	"-2002Z"],
+      ["-2002+00:00",
+	"-2002Z"],
+      ["-2002-00:00",
+	"-2002Z"],
+    ]
+    targets.each do |data, expected|
+      assert_equal(expected, XSD::XSDGYear.new(data).to_s)
+    end
+  end
+
+  def test_XSDGMonthDay
+    o = XSD::XSDGMonthDay.new
+    assert_equal(XSD::Namespace, o.type.namespace)
+    assert_equal(XSD::GMonthDayLiteral, o.type.name)
+    assert_equal(nil, o.data)
+    assert_equal(true, o.is_nil)
+
+    targets = [
+      "--05-18Z",
+      "--01-01Z",
+      "--12-31Z",
+      "--12-31+09:00",
+      "--12-31+00:01",
+      "--12-31-00:01",
+      "--12-31-23:59",
+      "--12-31+13:30",
+    ]
+    targets.each do |str|
+      assert_parsed_result(XSD::XSDGMonthDay, str)
+    end
+
+    targets = [
+      ["--12-31",
+	"--12-31Z"],
+      ["--12-31+00:00",
+	"--12-31Z"],
+      ["--12-31-00:00",
+	"--12-31Z"],
+    ]
+    targets.each do |data, expected|
+      assert_equal(expected, XSD::XSDGMonthDay.new(data).to_s)
+    end
+  end
+
+  def test_XSDGDay
+    o = XSD::XSDGDay.new
+    assert_equal(XSD::Namespace, o.type.namespace)
+    assert_equal(XSD::GDayLiteral, o.type.name)
+    assert_equal(nil, o.data)
+    assert_equal(true, o.is_nil)
+
+    targets = [
+      "---18Z",
+      "---01Z",
+      "---31Z",
+      "---31+09:00",
+      "---31+00:01",
+      "---31-00:01",
+      "---31-23:59",
+      "---31+13:30",
+    ]
+    targets.each do |str|
+      assert_parsed_result(XSD::XSDGDay, str)
+    end
+
+    targets = [
+      ["---31",
+	"---31Z"],
+      ["---31+00:00",
+	"---31Z"],
+      ["---31-00:00",
+	"---31Z"],
+    ]
+    targets.each do |data, expected|
+      assert_equal(expected, XSD::XSDGDay.new(data).to_s)
+    end
+  end
+
+  def test_XSDGMonth
+    o = XSD::XSDGMonth.new
+    assert_equal(XSD::Namespace, o.type.namespace)
+    assert_equal(XSD::GMonthLiteral, o.type.name)
+    assert_equal(nil, o.data)
+    assert_equal(true, o.is_nil)
+
+    targets = [
+      "--05Z",
+      "--01Z",
+      "--12Z",
+      "--12+09:00",
+      "--12+00:01",
+      "--12-00:01",
+      "--12-23:59",
+      "--12+13:30",
+    ]
+    targets.each do |str|
+      assert_parsed_result(XSD::XSDGMonth, str)
+    end
+
+    targets = [
+      ["--12",
+	"--12Z"],
+      ["--12+00:00",
+	"--12Z"],
+      ["--12-00:00",
+	"--12Z"],
+    ]
+    targets.each do |data, expected|
+      assert_equal(expected, XSD::XSDGMonth.new(data).to_s)
+    end
+  end
+
+  def test_XSDHexBinary
+    o = XSD::XSDHexBinary.new
+    assert_equal(XSD::Namespace, o.type.namespace)
+    assert_equal(XSD::HexBinaryLiteral, o.type.name)
+    assert_equal(nil, o.data)
+    assert_equal(true, o.is_nil)
+
+    targets = [
+      "abcdef",
+      "\xe3\x81\xaa\xe3\x81\xb2",
+      %Q(\0),
+      "",
+    ]
+    targets.each do |str|
+      assert_equal(str, XSD::XSDHexBinary.new(str).string)
+      assert_equal(str.unpack("H*")[0 ].tr('a-f', 'A-F'),
+	XSD::XSDHexBinary.new(str).data)
+      o = XSD::XSDHexBinary.new
+      o.set_encoded(str.unpack("H*")[0 ].tr('a-f', 'A-F'))
+      assert_equal(str, o.string)
+      o.set_encoded(str.unpack("H*")[0 ].tr('A-F', 'a-f'))
+      assert_equal(str, o.string)
+    end
+
+    targets = [
+      "0FG7",
+      "0fg7",
+    ]
+    targets.each do |d|
+      assert_raises(XSD::ValueSpaceError, d.to_s) do
+	o = XSD::XSDHexBinary.new
+	o.set_encoded(d)
+	p o.string
+      end
+    end
+  end
+
+  def test_XSDBase64Binary
+    o = XSD::XSDBase64Binary.new
+    assert_equal(XSD::Namespace, o.type.namespace)
+    assert_equal(XSD::Base64BinaryLiteral, o.type.name)
+    assert_equal(nil, o.data)
+    assert_equal(true, o.is_nil)
+
+    targets = [
+      "abcdef",
+      "\xe3\x81\xaa\xe3\x81\xb2",
+      %Q(\0),
+      "",
+    ]
+    targets.each do |str|
+      assert_equal(str, XSD::XSDBase64Binary.new(str).string)
+      assert_equal([str ].pack("m").chomp, XSD::XSDBase64Binary.new(str).data)
+      o = XSD::XSDBase64Binary.new
+      o.set_encoded([str ].pack("m").chomp)
+      assert_equal(str, o.string)
+    end
+
+    targets = [
+      "-",
+      "*",
+    ]
+    targets.each do |d|
+      assert_raises(XSD::ValueSpaceError, d.to_s) do
+	o = XSD::XSDBase64Binary.new
+	o.set_encoded(d)
+	p o.string
+      end
+    end
+  end
+
+  def test_XSDAnyURI
+    o = XSD::XSDAnyURI.new
+    assert_equal(XSD::Namespace, o.type.namespace)
+    assert_equal(XSD::AnyURILiteral, o.type.name)
+    assert_equal(nil, o.data)
+    assert_equal(true, o.is_nil)
+
+    # Too few tests here I know.  Believe uri module. :)
+    targets = [
+      "foo",
+      "http://foo",
+      "http://foo/bar/baz",
+      "http://foo/bar#baz",
+      "http://foo/bar%20%20?a+b",
+      "HTTP://FOO/BAR%20%20?A+B",
+    ]
+    targets.each do |str|
+      assert_parsed_result(XSD::XSDAnyURI, str)
+    end
+  end
+
+  def test_XSDQName
+    o = XSD::XSDQName.new
+    assert_equal(XSD::Namespace, o.type.namespace)
+    assert_equal(XSD::QNameLiteral, o.type.name)
+    assert_equal(nil, o.data)
+    assert_equal(true, o.is_nil)
+
+    # More strict test is needed but current implementation allows all non-':'
+    # chars like ' ', C0 or C1...
+    targets = [
+      "foo",
+      "foo:bar",
+      "a:b",
+    ]
+    targets.each do |str|
+      assert_parsed_result(XSD::XSDQName, str)
+    end
+  end
+
+
+  ###
+  ## Derived types
+  #
+
+  def test_XSDInteger
+    o = XSD::XSDInteger.new
+    assert_equal(XSD::Namespace, o.type.namespace)
+    assert_equal(XSD::IntegerLiteral, o.type.name)
+    assert_equal(nil, o.data)
+    assert_equal(true, o.is_nil)
+
+    targets = [
+      0,
+      1000000000,
+      -9999999999,
+      12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890,
+      12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890,
+      -1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789,
+    ]
+    targets.each do |int|
+      assert_equal(int, XSD::XSDInteger.new(int).data)
+    end
+
+    targets = [
+      "0",
+      "1000000000",
+      "-9999999999",
+      "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890",
+      "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890",
+      "-1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789",
+    ]
+    targets.each do |str|
+      assert_equal(str, XSD::XSDInteger.new(str).to_s)
+    end
+
+    targets = [
+      ["-0", "0"],
+      ["+0", "0"],
+      ["000123", "123"],
+      ["-000123", "-123"],
+      [
+	"+12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890",
+	"12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
+     ],
+    ]
+    targets.each do |data, expected|
+      assert_equal(expected, XSD::XSDInteger.new(data).to_s)
+    end
+
+    targets = [
+      "0.0",
+      "-5.2",
+      "0.000000000000a",
+      "+-5",
+      "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890."
+    ]
+    targets.each do |d|
+      assert_raises(XSD::ValueSpaceError) do
+	XSD::XSDInteger.new(d)
+      end
+    end
+  end
+
+  def test_XSDNonPositiveInteger
+    o = XSD::XSDNonPositiveInteger.new
+    assert_equal(XSD::Namespace, o.type.namespace)
+    assert_equal(XSD::NonPositiveIntegerLiteral, o.type.name)
+    assert_equal(nil, o.data)
+    assert_equal(true, o.is_nil)
+
+    targets = [
+      0,
+      -9999999999,
+      -1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789,
+    ]
+    targets.each do |int|
+      assert_equal(int, XSD::XSDNonPositiveInteger.new(int).data)
+    end
+
+    targets = [
+      "0",
+      "-9999999999",
+      "-1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789",
+    ]
+    targets.each do |str|
+      assert_equal(str, XSD::XSDNonPositiveInteger.new(str).to_s)
+    end
+
+    targets = [
+      ["-0", "0"],
+      ["-000123", "-123"],
+    ]
+    targets.each do |data, expected|
+      assert_equal(expected, XSD::XSDNonPositiveInteger.new(data).to_s)
+    end
+
+    targets = [
+      "0.0",
+      "-5.2",
+      "0.000000000000a",
+      "+-5",
+      "-12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890."
+    ]
+    targets.each do |d|
+      assert_raises(XSD::ValueSpaceError) do
+	XSD::XSDNonPositiveInteger.new(d)
+      end
+    end
+  end
+
+  def test_XSDNegativeInteger
+    o = XSD::XSDNegativeInteger.new
+    assert_equal(XSD::Namespace, o.type.namespace)
+    assert_equal(XSD::NegativeIntegerLiteral, o.type.name)
+    assert_equal(nil, o.data)
+    assert_equal(true, o.is_nil)
+
+    targets = [
+      -1,
+      -9999999999,
+      -1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789,
+    ]
+    targets.each do |int|
+      assert_equal(int, XSD::XSDNegativeInteger.new(int).data)
+    end
+
+    targets = [
+      "-1",
+      "-9999999999",
+      "-1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789",
+    ]
+    targets.each do |str|
+      assert_equal(str, XSD::XSDNegativeInteger.new(str).to_s)
+    end
+
+    targets = [
+      ["-000123", "-123"],
+    ]
+    targets.each do |data, expected|
+      assert_equal(expected, XSD::XSDNegativeInteger.new(data).to_s)
+    end
+
+    targets = [
+      "-0.0",
+      "-5.2",
+      "-0.000000000000a",
+      "+-5",
+      "-12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890."
+    ]
+    targets.each do |d|
+      assert_raises(XSD::ValueSpaceError) do
+	XSD::XSDNegativeInteger.new(d)
+      end
+    end
+  end
+
+  def test_XSDLong
+    o = XSD::XSDLong.new
+    assert_equal(XSD::Namespace, o.type.namespace)
+    assert_equal(XSD::LongLiteral, o.type.name)
+    assert_equal(nil, o.data)
+    assert_equal(true, o.is_nil)
+
+    targets = [
+      0,
+      123,
+      -123,
+      9223372036854775807,
+      -9223372036854775808,
+    ]
+    targets.each do |lng|
+      assert_equal(lng, XSD::XSDLong.new(lng).data)
+    end
+
+    targets = [
+      "0",
+      "123",
+      "-123",
+      "9223372036854775807",
+      "-9223372036854775808",
+    ]
+    targets.each do |str|
+      assert_equal(str, XSD::XSDLong.new(str).to_s)
+    end
+
+    targets = [
+      ["-0", "0"],
+      ["+0", "0"],
+      ["000123", "123"],
+      ["-000123", "-123"],
+    ]
+    targets.each do |data, expected|
+      assert_equal(expected, XSD::XSDLong.new(data).to_s)
+    end
+
+    targets = [
+      9223372036854775808,
+      -9223372036854775809,
+      "0.0",
+      "-5.2",
+      "0.000000000000a",
+      "+-5",
+    ]
+    targets.each do |d|
+      assert_raises(XSD::ValueSpaceError) do
+	XSD::XSDLong.new(d)
+      end
+    end
+  end
+
+  def test_XSDInt
+    o = XSD::XSDInt.new
+    assert_equal(XSD::Namespace, o.type.namespace)
+    assert_equal(XSD::IntLiteral, o.type.name)
+    assert_equal(nil, o.data)
+    assert_equal(true, o.is_nil)
+
+    targets = [
+      0,
+      123,
+      -123,
+      2147483647,
+      -2147483648,
+    ]
+    targets.each do |lng|
+      assert_equal(lng, XSD::XSDInt.new(lng).data)
+    end
+
+    targets = [
+      "0",
+      "123",
+      "-123",
+      "2147483647",
+      "-2147483648",
+    ]
+    targets.each do |str|
+      assert_equal(str, XSD::XSDInt.new(str).to_s)
+    end
+
+    targets = [
+      ["-0", "0"],
+      ["+0", "0"],
+      ["000123", "123"],
+      ["-000123", "-123"],
+    ]
+    targets.each do |data, expected|
+      assert_equal(expected, XSD::XSDInt.new(data).to_s)
+    end
+
+    targets = [
+      2147483648,
+      -2147483649,
+      "0.0",
+      "-5.2",
+      "0.000000000000a",
+      "+-5",
+    ]
+    targets.each do |d|
+      assert_raises(XSD::ValueSpaceError) do
+	XSD::XSDInt.new(d)
+      end
+    end
+  end
+
+  def test_XSDShort
+    o = XSD::XSDShort.new
+    assert_equal(XSD::Namespace, o.type.namespace)
+    assert_equal(XSD::ShortLiteral, o.type.name)
+    assert_equal(nil, o.data)
+    assert_equal(true, o.is_nil)
+
+    targets = [
+      0,
+      123,
+      -123,
+      32767,
+      -32768,
+    ]
+    targets.each do |lng|
+      assert_equal(lng, XSD::XSDShort.new(lng).data)
+    end
+
+    targets = [
+      "0",
+      "123",
+      "-123",
+      "32767",
+      "-32768",
+    ]
+    targets.each do |str|
+      assert_equal(str, XSD::XSDShort.new(str).to_s)
+    end
+
+    targets = [
+      ["-0", "0"],
+      ["+0", "0"],
+      ["000123", "123"],
+      ["-000123", "-123"],
+    ]
+    targets.each do |data, expected|
+      assert_equal(expected, XSD::XSDShort.new(data).to_s)
+    end
+
+    targets = [
+      32768,
+      -32769,
+      "0.0",
+      "-5.2",
+      "0.000000000000a",
+      "+-5",
+    ]
+    targets.each do |d|
+      assert_raises(XSD::ValueSpaceError) do
+	XSD::XSDShort.new(d)
+      end
+    end
+  end
+
+  def test_XSDByte
+    o = XSD::XSDByte.new
+    assert_equal(XSD::Namespace, o.type.namespace)
+    assert_equal(XSD::ByteLiteral, o.type.name)
+    assert_equal(nil, o.data)
+    assert_equal(true, o.is_nil)
+
+    targets = [
+      0,
+      123,
+      -123,
+      127,
+      -128,
+    ]
+    targets.each do |lng|
+      assert_equal(lng, XSD::XSDByte.new(lng).data)
+    end
+
+    targets = [
+      "0",
+      "123",
+      "-123",
+      "127",
+      "-128",
+    ]
+    targets.each do |str|
+      assert_equal(str, XSD::XSDByte.new(str).to_s)
+    end
+
+    targets = [
+      ["-0", "0"],
+      ["+0", "0"],
+      ["000123", "123"],
+      ["-000123", "-123"],
+    ]
+    targets.each do |data, expected|
+      assert_equal(expected, XSD::XSDByte.new(data).to_s)
+    end
+
+    targets = [
+      128,
+      -129,
+      "0.0",
+      "-5.2",
+      "0.000000000000a",
+      "+-5",
+    ]
+    targets.each do |d|
+      assert_raises(XSD::ValueSpaceError) do
+	XSD::XSDByte.new(d)
+      end
+    end
+  end
+
+  def test_XSDNonNegativeInteger
+    o = XSD::XSDNonNegativeInteger.new
+    assert_equal(XSD::Namespace, o.type.namespace)
+    assert_equal(XSD::NonNegativeIntegerLiteral, o.type.name)
+    assert_equal(nil, o.data)
+    assert_equal(true, o.is_nil)
+
+    targets = [
+      0,
+      1000000000,
+      12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890,
+    ]
+    targets.each do |int|
+      assert_equal(int, XSD::XSDNonNegativeInteger.new(int).data)
+    end
+
+    targets = [
+      "0",
+      "1000000000",
+      "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890",
+    ]
+    targets.each do |str|
+      assert_equal(str, XSD::XSDNonNegativeInteger.new(str).to_s)
+    end
+
+    targets = [
+      ["-0", "0"],
+      ["+0", "0"],
+      ["000123", "123"],
+      [
+	"+12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890",
+	"12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
+     ],
+    ]
+    targets.each do |data, expected|
+      assert_equal(expected, XSD::XSDNonNegativeInteger.new(data).to_s)
+    end
+
+    targets = [
+      "0.0",
+      "0.000000000000a",
+      "+-5",
+      "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890."
+    ]
+    targets.each do |d|
+      assert_raises(XSD::ValueSpaceError) do
+	XSD::XSDNonNegativeInteger.new(d)
+      end
+    end
+  end
+
+  def test_XSDUnsignedLong
+    o = XSD::XSDUnsignedLong.new
+    assert_equal(XSD::Namespace, o.type.namespace)
+    assert_equal(XSD::UnsignedLongLiteral, o.type.name)
+    assert_equal(nil, o.data)
+    assert_equal(true, o.is_nil)
+
+    targets = [
+      0,
+      1000000000,
+      18446744073709551615,
+    ]
+    targets.each do |int|
+      assert_equal(int, XSD::XSDUnsignedLong.new(int).data)
+    end
+
+    targets = [
+      "0",
+      "1000000000",
+      "18446744073709551615",
+    ]
+    targets.each do |str|
+      assert_equal(str, XSD::XSDUnsignedLong.new(str).to_s)
+    end
+
+    targets = [
+      ["-0", "0"],
+      ["+0", "0"],
+      ["000123", "123"],
+      ["+18446744073709551615", "18446744073709551615"],
+    ]
+    targets.each do |data, expected|
+      assert_equal(expected, XSD::XSDUnsignedLong.new(data).to_s)
+    end
+
+    targets = [
+      "0.0",
+      "0.000000000000a",
+      "+-5",
+      "18446744073709551615."
+    ]
+    targets.each do |d|
+      assert_raises(XSD::ValueSpaceError) do
+	XSD::XSDUnsignedLong.new(d)
+      end
+    end
+  end
+
+  def test_XSDUnsignedInt
+    o = XSD::XSDUnsignedInt.new
+    assert_equal(XSD::Namespace, o.type.namespace)
+    assert_equal(XSD::UnsignedIntLiteral, o.type.name)
+    assert_equal(nil, o.data)
+    assert_equal(true, o.is_nil)
+
+    targets = [
+      0,
+      1000000000,
+      4294967295,
+    ]
+    targets.each do |int|
+      assert_equal(int, XSD::XSDUnsignedInt.new(int).data)
+    end
+
+    targets = [
+      "0",
+      "1000000000",
+      "4294967295",
+    ]
+    targets.each do |str|
+      assert_equal(str, XSD::XSDUnsignedInt.new(str).to_s)
+    end
+
+    targets = [
+      ["-0", "0"],
+      ["+0", "0"],
+      ["000123", "123"],
+      ["+4294967295", "4294967295"],
+    ]
+    targets.each do |data, expected|
+      assert_equal(expected, XSD::XSDUnsignedInt.new(data).to_s)
+    end
+
+    targets = [
+      "0.0",
+      "0.000000000000a",
+      "+-5",
+      "4294967295."
+    ]
+    targets.each do |d|
+      assert_raises(XSD::ValueSpaceError) do
+	XSD::XSDUnsignedInt.new(d)
+      end
+    end
+  end
+
+  def test_XSDUnsignedShort
+    o = XSD::XSDUnsignedShort.new
+    assert_equal(XSD::Namespace, o.type.namespace)
+    assert_equal(XSD::UnsignedShortLiteral, o.type.name)
+    assert_equal(nil, o.data)
+    assert_equal(true, o.is_nil)
+
+    targets = [
+      0,
+      10000,
+      65535,
+    ]
+    targets.each do |int|
+      assert_equal(int, XSD::XSDUnsignedShort.new(int).data)
+    end
+
+    targets = [
+      "0",
+      "1000",
+      "65535",
+    ]
+    targets.each do |str|
+      assert_equal(str, XSD::XSDUnsignedShort.new(str).to_s)
+    end
+
+    targets = [
+      ["-0", "0"],
+      ["+0", "0"],
+      ["000123", "123"],
+      ["+65535", "65535"],
+    ]
+    targets.each do |data, expected|
+      assert_equal(expected, XSD::XSDUnsignedShort.new(data).to_s)
+    end
+
+    targets = [
+      "0.0",
+      "0.000000000000a",
+      "+-5",
+      "65535."
+    ]
+    targets.each do |d|
+      assert_raises(XSD::ValueSpaceError) do
+	XSD::XSDUnsignedShort.new(d)
+      end
+    end
+  end
+
+  def test_XSDUnsignedByte
+    o = XSD::XSDUnsignedByte.new
+    assert_equal(XSD::Namespace, o.type.namespace)
+    assert_equal(XSD::UnsignedByteLiteral, o.type.name)
+    assert_equal(nil, o.data)
+    assert_equal(true, o.is_nil)
+
+    targets = [
+      0,
+      10,
+      255,
+    ]
+    targets.each do |int|
+      assert_equal(int, XSD::XSDUnsignedByte.new(int).data)
+    end
+
+    targets = [
+      "0",
+      "10",
+      "255",
+    ]
+    targets.each do |str|
+      assert_equal(str, XSD::XSDUnsignedByte.new(str).to_s)
+    end
+
+    targets = [
+      ["-0", "0"],
+      ["+0", "0"],
+      ["000123", "123"],
+      ["+255", "255"],
+    ]
+    targets.each do |data, expected|
+      assert_equal(expected, XSD::XSDUnsignedByte.new(data).to_s)
+    end
+
+    targets = [
+      "0.0",
+      "0.000000000000a",
+      "+-5",
+      "255."
+    ]
+    targets.each do |d|
+      assert_raises(XSD::ValueSpaceError) do
+	XSD::XSDUnsignedByte.new(d)
+      end
+    end
+  end
+
+  def test_XSDPositiveInteger
+    o = XSD::XSDPositiveInteger.new
+    assert_equal(XSD::Namespace, o.type.namespace)
+    assert_equal(XSD::PositiveIntegerLiteral, o.type.name)
+    assert_equal(nil, o.data)
+    assert_equal(true, o.is_nil)
+
+    targets = [
+      1,
+      1000000000,
+      12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890,
+    ]
+    targets.each do |int|
+      assert_equal(int, XSD::XSDPositiveInteger.new(int).data)
+    end
+
+    targets = [
+      "1",
+      "1000000000",
+      "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890",
+    ]
+    targets.each do |str|
+      assert_equal(str, XSD::XSDPositiveInteger.new(str).to_s)
+    end
+
+    targets = [
+      ["+1", "1"],
+      ["000123", "123"],
+      [
+	"+12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890",
+	"12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
+     ],
+    ]
+    targets.each do |data, expected|
+      assert_equal(expected, XSD::XSDPositiveInteger.new(data).to_s)
+    end
+
+    targets = [
+      "1.0",
+      "1.000000000000a",
+      "+-5",
+      "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890."
+    ]
+    targets.each do |d|
+      assert_raises(XSD::ValueSpaceError) do
+	XSD::XSDPositiveInteger.new(d)
+      end
+    end
+  end
+end
+
+
+end