From e8ed175fe02aecab21ce50e85e27fe79137d8c31 Mon Sep 17 00:00:00 2001 From: nahi Date: Mon, 20 Dec 2004 14:41:10 +0000 Subject: * added files: * lib/soap/mapping/wsdl*.rb * lib/wsdl/soap/element.rb * lib/wsdl/xmlSchema/simpleContent.rb * modified files: * lib/soap/* * lib/wsdl/* * lib/xsd/* * test/soap/* * test/wsdl/* * test/xsd/* * sample/soap/* * sample/sdl/* * summary * imported from the soap4r repository. Version: 1.5.3-ruby1.8.2 * added several XSD basetype support: nonPositiveInteger, negativeInteger, nonNegativeInteger, unsignedLong, unsignedInt, unsignedShort, unsignedByte, positiveInteger * HTTP client connection/send/receive timeout support. * HTTP client/server gzipped content encoding support. * improved WSDL schema definition support; still is far from complete, but is making step by step improovement. git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/branches/ruby_1_8@7617 b2dd03c8-39d4-4d8f-98ff-823fe69b080e --- test/soap/ssl/sslsvr.rb | 16 +- test/soap/ssl/test_ssl.rb | 13 +- test/soap/test_property.rb | 46 ++-- test/soap/test_streamhandler.rb | 8 +- test/wsdl/map/map.wsdl | 50 +++- test/wsdl/map/test_map.rb | 75 +++++- test/xsd/test_xsd.rb | 494 ++++++++++++++++++++++++++++++++++++++++ 7 files changed, 652 insertions(+), 50 deletions(-) (limited to 'test') diff --git a/test/soap/ssl/sslsvr.rb b/test/soap/ssl/sslsvr.rb index 281c1a1a51..52a8d6878f 100644 --- a/test/soap/ssl/sslsvr.rb +++ b/test/soap/ssl/sslsvr.rb @@ -47,10 +47,18 @@ if $0 == __FILE__ :SSLClientCA => cert('ca.cert'), :SSLCertName => nil ) - trap(:INT) do - $server.shutdown if $server + t = Thread.new { + Thread.current.abort_on_exception = true + $server.start + } + while $server.status != :Running + sleep 0.1 + unless t.alive? + t.join + raise + end end STDOUT.sync = true - STDOUT.puts $$ - $server.start + puts $$ + t.join end diff --git a/test/soap/ssl/test_ssl.rb b/test/soap/ssl/test_ssl.rb index 6678c775ac..82bb890d71 100644 --- a/test/soap/ssl/test_ssl.rb +++ b/test/soap/ssl/test_ssl.rb @@ -33,12 +33,8 @@ class TestSSL < Test::Unit::TestCase teardown_server end - def streamhandler - @client.instance_eval("@servant").instance_eval("@streamhandler").client - end - def test_options - cfg = streamhandler.ssl_config + cfg = @client.streamhandler.client.ssl_config assert_nil(cfg.client_cert) assert_nil(cfg.client_key) assert_nil(cfg.client_ca) @@ -192,11 +188,14 @@ private end def teardown_server - Process.kill('INT', @serverpid) + if @serverpid + Process.kill('KILL', @serverpid) + Process.waitpid(@serverpid) + end end def teardown_client - @client.reset_stream + @client.reset_stream if @client end def verify_callback(ok, cert) diff --git a/test/soap/test_property.rb b/test/soap/test_property.rb index 1cc826695f..7acd2c8437 100644 --- a/test/soap/test_property.rb +++ b/test/soap/test_property.rb @@ -6,6 +6,8 @@ module SOAP class TestProperty < Test::Unit::TestCase + FrozenError = (RUBY_VERSION >= "1.9.0") ? RuntimeError : TypeError + def setup @prop = ::SOAP::Property.new end @@ -67,7 +69,7 @@ __EOP__ prop["foo.bar"].lock prop.load("foo.bar.baz = 123") assert(hooked) - assert_raises(TypeError) do + assert_raises(FrozenError) do prop.load("foo.bar.qux = 123") end prop.load("foo.baz = 456") @@ -130,7 +132,7 @@ __EOP__ tag = Object.new tested = false @prop.add_hook("foo.bar") do |key, value| - assert_raise(TypeError) do + assert_raise(FrozenError) do key << "baz" end tested = true @@ -266,37 +268,37 @@ __EOP__ @prop.lock assert(@prop.locked?) assert_instance_of(::SOAP::Property, @prop["a"]) - assert_raises(TypeError) do + assert_raises(FrozenError) do @prop["b"] end # @prop["a"].lock - assert_raises(TypeError) do + assert_raises(FrozenError) do @prop["a"] end assert_instance_of(::SOAP::Property, @prop["a.b"]) # @prop["a.b"].lock - assert_raises(TypeError) do + assert_raises(FrozenError) do @prop["a.b"] end - assert_raises(TypeError) do + assert_raises(FrozenError) do @prop["a"] end # @prop["a.b.c.d"].lock assert_instance_of(::SOAP::Property, @prop["a.b.c"]) - assert_raises(TypeError) do + assert_raises(FrozenError) do @prop["a.b.c.d"] end assert_instance_of(::SOAP::Property, @prop["a.b.d"]) # branch["e"].lock assert_instance_of(::SOAP::Property, @prop["a.b.d"]) - assert_raises(TypeError) do + assert_raises(FrozenError) do @prop["a.b.d.e"] end - assert_raises(TypeError) do + assert_raises(FrozenError) do branch["e"] end end @@ -310,26 +312,26 @@ __EOP__ assert_equal(nil, @prop["a.a"]) assert_equal(1, @prop["a.b.c"]) assert_equal(false, @prop["b"]) - assert_raises(TypeError) do + assert_raises(FrozenError) do @prop["c"] end - assert_raises(TypeError) do + assert_raises(FrozenError) do @prop["c"] = 2 end - assert_raises(TypeError) do + assert_raises(FrozenError) do @prop["a.b.R"] end - assert_raises(TypeError) do + assert_raises(FrozenError) do @prop.add_hook do assert(false) end end - assert_raises(TypeError) do + assert_raises(FrozenError) do @prop.add_hook("c") do assert(false) end end - assert_raises(TypeError) do + assert_raises(FrozenError) do @prop.add_hook("a.c") do assert(false) end @@ -364,7 +366,7 @@ __EOP__ @prop["a.b.c"] = 5 assert(tested) assert_equal(5, @prop["a.b.c"]) - assert_raises(TypeError) do + assert_raises(FrozenError) do @prop["a.b.d"] = 5 end end @@ -383,28 +385,28 @@ __EOP__ assert_equal(branch, @prop[:a][:b][:d]) @prop.lock(true) # split error 1 - assert_raises(TypeError) do + assert_raises(FrozenError) do @prop["a.b"] end # split error 2 - assert_raises(TypeError) do + assert_raises(FrozenError) do @prop["a"] end @prop["a.b.c"] = 2 assert_equal(2, @prop["a.b.c"]) # replace error - assert_raises(TypeError) do + assert_raises(FrozenError) do @prop["a.b.c"] = ::SOAP::Property.new end # override error - assert_raises(TypeError) do + assert_raises(FrozenError) do @prop["a.b"] = 1 end # - assert_raises(TypeError) do + assert_raises(FrozenError) do @prop["a.b.d"] << 1 end - assert_raises(TypeError) do + assert_raises(FrozenError) do branch << 1 end branch.unlock(true) diff --git a/test/soap/test_streamhandler.rb b/test/soap/test_streamhandler.rb index e5b578d7a6..fa0080e9f1 100644 --- a/test/soap/test_streamhandler.rb +++ b/test/soap/test_streamhandler.rb @@ -143,7 +143,9 @@ __EOX__ def test_basic_auth unless Object.const_defined?('HTTPAccess2') - STDERR.puts("basic_auth is not supported under soap4r + net/http for now.") + # soap4r + net/http + basic_auth is not supported. + # use http-access2 instead. + assert(true) return end str = "" @@ -169,6 +171,10 @@ __EOX__ assert_nil(@client.do_server_proc) r, h = parse_req_header(str) assert_match(%r"POST http://localhost:17171/ HTTP/1.", r) + # illegal proxy uri + assert_raise(ArgumentError) do + @client.options["protocol.http.proxy"] = 'ftp://foo:8080' + end ensure if Object.const_defined?('HTTPAccess2') HTTPAccess2::Client::NO_PROXY_HOSTS.replace(backup) diff --git a/test/wsdl/map/map.wsdl b/test/wsdl/map/map.wsdl index 7b1a140827..e418a4cbbd 100644 --- a/test/wsdl/map/map.wsdl +++ b/test/wsdl/map/map.wsdl @@ -1,9 +1,9 @@ - - + + @@ -34,32 +34,58 @@ - + + + + + + + + + + + + + - + + namespace="urn:map"/> + + + + + + + + + + + namespace="urn:map"/> - - + + diff --git a/test/wsdl/map/test_map.rb b/test/wsdl/map/test_map.rb index b0f2fb5a53..bee3a75892 100644 --- a/test/wsdl/map/test_map.rb +++ b/test/wsdl/map/test_map.rb @@ -1,15 +1,75 @@ require 'test/unit' -require 'soap/processor' -require 'soap/mapping' -require 'soap/rpc/element' -require 'wsdl/importer' +require 'soap/rpc/httpserver' +require 'soap/wsdlDriver' module WSDL class TestMap < Test::Unit::TestCase + Port = 17171 + DIR = File.dirname(File.expand_path(__FILE__)) + + class Server < ::SOAP::RPC::HTTPServer + def on_init + add_method(self, 'map') + add_method(self, 'map2', 'arg') + end + + def map + {1 => "a", 2 => "b"} + end + + def map2(arg) + arg + end + end + def setup + setup_server + setup_client + end + + def setup_server + @server = Server.new( + :Port => Port, + :AccessLog => [], + :SOAPDefaultNamespace => "urn:map" + ) + @server.level = Logger::Severity::ERROR + @t = Thread.new { + Thread.current.abort_on_exception = true + @server.start + } + while @server.status != :Running + sleep 0.1 + unless @t.alive? + @t.join + raise + end + end + end + + def setup_client + wsdl = File.join(DIR, 'map.wsdl') + @client = ::SOAP::WSDLDriverFactory.new(wsdl).create_driver + @client.endpoint_url = "http://localhost:#{Port}/" + @client.generate_explicit_type = true + end + + def teardown + teardown_server + teardown_client + end + + def teardown_server + @server.shutdown + @t.kill + @t.join + end + + def teardown_client + @client.reset_stream end def test_by_wsdl @@ -31,6 +91,13 @@ class TestMap < Test::Unit::TestCase assert_equal(["b1"], map["b"]["b1"]) assert_equal(["b2"], map["b"]["b2"]) end + + def test_wsdldriver + assert_equal({1 => "a", 2 => "b"}, @client.map) + assert_equal({1 => 2}, @client.map2({1 => 2})) + assert_equal({1 => {2 => 3}}, @client.map2({1 => {2 => 3}})) + assert_equal({["a", 2] => {2 => 3}}, @client.map2({["a", 2] => {2 => 3}})) + end end diff --git a/test/xsd/test_xsd.rb b/test/xsd/test_xsd.rb index ce1b263625..1f594571fe 100644 --- a/test/xsd/test_xsd.rb +++ b/test/xsd/test_xsd.rb @@ -898,6 +898,99 @@ class TestXSD2 < Test::Unit::TestCase 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) @@ -1005,6 +1098,407 @@ class TestXSD2 < Test::Unit::TestCase 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 -- cgit v1.2.3