Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

1512 lines (1366 sloc) 41.597 kb
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
Jump to Line
Something went wrong with that request. Please try again.