From d464704f111d211c1f1ff9ef23ef1d755054be00 Mon Sep 17 00:00:00 2001 From: shyouhei Date: Wed, 15 Aug 2007 19:08:43 +0000 Subject: add tag v1_8_5_54 git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/tags/v1_8_5_54@12952 b2dd03c8-39d4-4d8f-98ff-823fe69b080e --- ruby_1_8_5/test/xsd/test_xsd.rb | 1511 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 1511 insertions(+) create mode 100644 ruby_1_8_5/test/xsd/test_xsd.rb (limited to 'ruby_1_8_5/test/xsd/test_xsd.rb') diff --git a/ruby_1_8_5/test/xsd/test_xsd.rb b/ruby_1_8_5/test/xsd/test_xsd.rb new file mode 100644 index 0000000000..6302f3128b --- /dev/null +++ b/ruby_1_8_5/test/xsd/test_xsd.rb @@ -0,0 +1,1511 @@ +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) + assert_raises(XSD::ValueSpaceError) do + XSD::XSDString.new("\0") + end + assert_raises(XSD::ValueSpaceError) do + p XSD::XSDString.new("\xC0\xC0").to_s + end + end + + def test_XSDString_NONE + XSD::Charset.module_eval { @encoding_backup = @encoding; @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) + 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::Charset.module_eval { @encoding = @encoding_backup } + end + 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", + "P0DT3456H7890M1234.5678S", + "P1234Y5678M9012D", + "-P1234Y5678M9012DT3456H7890M1234.5678S", + "P5678M9012DT3456H7890M1234.5678S", + "-P1234Y9012DT3456H7890M1234.5678S", + "+P1234Y5678MT3456H7890M1234.5678S", + "P1234Y5678M9012DT7890M1234.5678S", + "-P1234Y5678M9012DT3456H1234.5678S", + "+P1234Y5678M9012DT3456H7890M", + "P123400000000000Y", + "-P567800000000000M", + "+P901200000000000D", + "P0DT345600000000000H", + "-P0DT789000000000000M", + "+P0DT123400000000000.000000000005678S", + "P1234YT1234.5678S", + "-P5678MT7890M", + "+P9012DT3456H", + ] + 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 -- cgit v1.2.3