← Back to branch summary

~ubuntu-branches/ubuntu/trusty/ruby1.9/trusty

« back to all changes in this revision

Viewing changes to test/xsd/test_xsd.rb

  • Committer: Bazaar Package Importer
  • Author(s): Stephan Hermann
  • Date: 2008-01-24 11:42:29 UTC
  • mfrom: (1.1.9 upstream)
  • Revision ID: james.westby@ubuntu.com-20080124114229-jw2f87rdxlq6gp11
Tags: 1.9.0.0-2ubuntu1
* Merge from debian unstable, remaining changes:
  - Robustify check for target_os, fixing build failure on lpia.

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/xsd/test_xsd.rb
1
 
require 'test/unit'
2
 
require 'xsd/datatypes'
3
 
 
4
 
 
5
 
module XSD
6
 
 
7
 
 
8
 
class TestXSD < Test::Unit::TestCase
9
 
  NegativeZero = (-1.0 / (1.0 / 0.0))
10
 
 
11
 
  def setup
12
 
  end
13
 
 
14
 
  def teardown
15
 
  end
16
 
 
17
 
  def assert_parsed_result(klass, str)
18
 
    o = klass.new(str)
19
 
    assert_equal(str, o.to_s)
20
 
  end
21
 
 
22
 
  def test_NSDBase
23
 
    o = XSD::NSDBase.new
24
 
    assert_equal(nil, o.type)
25
 
  end
26
 
 
27
 
  def test_XSDBase
28
 
    o = XSD::XSDAnySimpleType.new
29
 
    assert_equal(nil, o.data)
30
 
    assert_equal(true, o.is_nil)
31
 
    assert_equal('', o.to_s)
32
 
  end
33
 
 
34
 
  def test_XSDNil
35
 
    o = XSD::XSDNil.new
36
 
    assert_equal(XSD::Namespace, o.type.namespace)
37
 
    assert_equal(XSD::NilLiteral, o.type.name)
38
 
    assert_equal(nil, o.data)
39
 
    assert_equal(true, o.is_nil)
40
 
 
41
 
    o = XSD::XSDNil.new(nil)
42
 
    assert_equal(true, o.is_nil)
43
 
    assert_equal(nil, o.data)
44
 
    assert_equal("", o.to_s)
45
 
    o = XSD::XSDNil.new('var')
46
 
    assert_equal(false, o.is_nil)
47
 
    assert_equal('var', o.data)
48
 
    assert_equal('var', o.to_s)
49
 
  end
50
 
 
51
 
  def test_XSDString_UTF8
52
 
    o = XSD::XSDString.new
53
 
    assert_equal(XSD::Namespace, o.type.namespace)
54
 
    assert_equal(XSD::StringLiteral, o.type.name)
55
 
    assert_equal(nil, o.data)
56
 
    assert_equal(true, o.is_nil)
57
 
 
58
 
    str = "abc"
59
 
    assert_equal(str, XSD::XSDString.new(str).data)
60
 
    assert_equal(str, XSD::XSDString.new(str).to_s)
61
 
    assert_raises(XSD::ValueSpaceError) do
62
 
      XSD::XSDString.new("\0")
63
 
    end
64
 
    assert_raises(XSD::ValueSpaceError) do
65
 
      p XSD::XSDString.new("\xC0\xC0").to_s
66
 
    end
67
 
  end
68
 
 
69
 
  def test_XSDString_NONE
70
 
    XSD::Charset.module_eval { @encoding_backup = @encoding; @encoding = "NONE" }
71
 
    begin
72
 
      o = XSD::XSDString.new
73
 
      assert_equal(XSD::Namespace, o.type.namespace)
74
 
      assert_equal(XSD::StringLiteral, o.type.name)
75
 
      assert_equal(nil, o.data)
76
 
      assert_equal(true, o.is_nil)
77
 
 
78
 
      str = "abc"
79
 
      assert_equal(str, XSD::XSDString.new(str).data)
80
 
      assert_equal(str, XSD::XSDString.new(str).to_s)
81
 
      assert_raises(XSD::ValueSpaceError) do
82
 
        XSD::XSDString.new("\0")
83
 
      end
84
 
      assert_raises(XSD::ValueSpaceError) do
85
 
        p XSD::XSDString.new("\xC0\xC0").to_s
86
 
      end
87
 
    ensure
88
 
      XSD::Charset.module_eval { @encoding = @encoding_backup }
89
 
    end
90
 
  end
91
 
 
92
 
  def test_XSDBoolean
93
 
    o = XSD::XSDBoolean.new
94
 
    assert_equal(XSD::Namespace, o.type.namespace)
95
 
    assert_equal(XSD::BooleanLiteral, o.type.name)
96
 
    assert_equal(nil, o.data)
97
 
    assert_equal(true, o.is_nil)
98
 
 
99
 
    targets = [
100
 
      ["true", true],
101
 
      ["1", true],
102
 
      ["false", false],
103
 
      ["0", false],
104
 
    ]
105
 
    targets.each do |data, expected|
106
 
      assert_equal(expected, XSD::XSDBoolean.new(data).data)
107
 
      assert_equal(expected.to_s, XSD::XSDBoolean.new(data).to_s)
108
 
    end
109
 
 
110
 
    assert_raises(XSD::ValueSpaceError) do
111
 
      XSD::XSDBoolean.new("nil").to_s
112
 
    end
113
 
  end
114
 
 
115
 
  def test_XSDDecimal
116
 
    o = XSD::XSDDecimal.new
117
 
    assert_equal(XSD::Namespace, o.type.namespace)
118
 
    assert_equal(XSD::DecimalLiteral, o.type.name)
119
 
    assert_equal(nil, o.data)
120
 
    assert_equal(true, o.is_nil)
121
 
 
122
 
    targets = [
123
 
      0,
124
 
      1000000000,
125
 
      -9999999999,
126
 
      12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890,
127
 
      12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890,
128
 
      -1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789,
129
 
    ]
130
 
    targets.each do |dec|
131
 
      assert_equal(dec.to_s, XSD::XSDDecimal.new(dec).data)
132
 
    end
133
 
 
134
 
    targets = [
135
 
      "0",
136
 
      "0.00000001",
137
 
      "1000000000",
138
 
      "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890",
139
 
      "-12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123.45678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789",
140
 
    ]
141
 
    targets.each do |str|
142
 
      assert_equal(str, XSD::XSDDecimal.new(str).to_s)
143
 
    end
144
 
 
145
 
    targets = [
146
 
      ["-0", "0"],
147
 
      ["+0", "0"],
148
 
      ["0.0", "0"],
149
 
      ["-0.0", "0"],
150
 
      ["+0.0", "0"],
151
 
      ["0.", "0"],
152
 
      [".0", "0"],
153
 
      [
154
 
        "+0.12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890",
155
 
        "0.1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789"
156
 
     ],
157
 
      [
158
 
        ".0000012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890",
159
 
        "0.000001234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789"
160
 
     ],
161
 
      [
162
 
        "-12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890.",
163
 
        "-12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
164
 
     ],
165
 
    ]
166
 
    targets.each do |data, expected|
167
 
      assert_equal(expected, XSD::XSDDecimal.new(data).to_s)
168
 
    end
169
 
 
170
 
    targets = [
171
 
      "0.000000000000a",
172
 
      "00a.0000000000001",
173
 
      "+-5",
174
 
    ]
175
 
    targets.each do |d|
176
 
      assert_raises(XSD::ValueSpaceError) do
177
 
        XSD::XSDDecimal.new(d)
178
 
      end
179
 
    end
180
 
  end
181
 
 
182
 
  def test_XSDFloat
183
 
    o = XSD::XSDFloat.new
184
 
    assert_equal(XSD::Namespace, o.type.namespace)
185
 
    assert_equal(XSD::FloatLiteral, o.type.name)
186
 
    assert_equal(nil, o.data)
187
 
    assert_equal(true, o.is_nil)
188
 
 
189
 
    targets = [
190
 
      3.14159265358979,
191
 
      12.34e36,
192
 
      1.402e-45,
193
 
      -1.402e-45,
194
 
    ]
195
 
    targets.each do |f|
196
 
      assert_equal(f, XSD::XSDFloat.new(f).data)
197
 
    end
198
 
 
199
 
    targets = [
200
 
      "+3.141592654",
201
 
      "+1.234e+37",
202
 
      "+1.402e-45",
203
 
      "-1.402e-45",
204
 
    ]
205
 
    targets.each do |f|
206
 
      assert_equal(f, XSD::XSDFloat.new(f).to_s)
207
 
    end
208
 
 
209
 
    targets = [
210
 
      [3, "+3"],        # should be 3.0?
211
 
      [-2, "-2"],       # ditto
212
 
      [3.14159265358979, "+3.141592654"],
213
 
      [12.34e36, "+1.234e+37"],
214
 
      [1.402e-45, "+1.402e-45"],
215
 
      [-1.402e-45, "-1.402e-45"],
216
 
      ["1.402e", "+1.402"],
217
 
      ["12.34E36", "+1.234e+37"],
218
 
      ["1.402E-45", "+1.402e-45"],
219
 
      ["-1.402E-45", "-1.402e-45"],
220
 
      ["1.402E", "+1.402"],
221
 
    ]
222
 
    targets.each do |f, str|
223
 
      assert_equal(str, XSD::XSDFloat.new(f).to_s)
224
 
    end
225
 
 
226
 
    assert_equal("+0", XSD::XSDFloat.new(+0.0).to_s)
227
 
    assert_equal("-0", XSD::XSDFloat.new(NegativeZero).to_s)
228
 
    assert(XSD::XSDFloat.new(0.0/0.0).data.nan?)
229
 
    assert_equal("INF", XSD::XSDFloat.new(1.0/0.0).to_s)
230
 
    assert_equal(1, XSD::XSDFloat.new(1.0/0.0).data.infinite?)
231
 
    assert_equal("-INF", XSD::XSDFloat.new(-1.0/0.0).to_s)
232
 
    assert_equal(-1, XSD::XSDFloat.new(-1.0/0.0).data.infinite?)
233
 
 
234
 
    targets = [
235
 
      "0.000000000000a",
236
 
      "00a.0000000000001",
237
 
      "+-5",
238
 
      "5_0",
239
 
    ]
240
 
    targets.each do |d|
241
 
      assert_raises(XSD::ValueSpaceError) do
242
 
        XSD::XSDFloat.new(d)
243
 
      end
244
 
    end
245
 
  end
246
 
 
247
 
  def test_XSDDouble
248
 
    o = XSD::XSDDouble.new
249
 
    assert_equal(XSD::Namespace, o.type.namespace)
250
 
    assert_equal(XSD::DoubleLiteral, o.type.name)
251
 
    assert_equal(nil, o.data)
252
 
    assert_equal(true, o.is_nil)
253
 
 
254
 
    targets = [
255
 
      3.14159265358979,
256
 
      12.34e36,
257
 
      1.402e-45,
258
 
      -1.402e-45,
259
 
    ]
260
 
    targets.each do |f|
261
 
      assert_equal(f, XSD::XSDDouble.new(f).data)
262
 
    end
263
 
 
264
 
    targets = [
265
 
      "+3.14159265358979",
266
 
      "+1.234e+37",
267
 
      "+1.402e-45",
268
 
      "-1.402e-45",
269
 
    ]
270
 
    targets.each do |f|
271
 
      assert_equal(f, XSD::XSDDouble.new(f).to_s)
272
 
    end
273
 
 
274
 
    targets = [
275
 
      [3, "+3"],        # should be 3.0?
276
 
      [-2, "-2"],       # ditto.
277
 
      [3.14159265358979, "+3.14159265358979"],
278
 
      [12.34e36, "+1.234e+37"],
279
 
      [1.402e-45, "+1.402e-45"],
280
 
      [-1.402e-45, "-1.402e-45"],
281
 
      ["1.402e", "+1.402"],
282
 
      ["12.34E36", "+1.234e+37"],
283
 
      ["1.402E-45", "+1.402e-45"],
284
 
      ["-1.402E-45", "-1.402e-45"],
285
 
      ["1.402E", "+1.402"],
286
 
    ]
287
 
    targets.each do |f, str|
288
 
      assert_equal(str, XSD::XSDDouble.new(f).to_s)
289
 
    end
290
 
 
291
 
    assert_equal("+0", XSD::XSDFloat.new(+0.0).to_s)
292
 
    assert_equal("-0", XSD::XSDFloat.new(NegativeZero).to_s)
293
 
    assert_equal("NaN", XSD::XSDDouble.new(0.0/0.0).to_s)
294
 
    assert(XSD::XSDDouble.new(0.0/0.0).data.nan?)
295
 
    assert_equal("INF", XSD::XSDDouble.new(1.0/0.0).to_s)
296
 
    assert_equal(1, XSD::XSDDouble.new(1.0/0.0).data.infinite?)
297
 
    assert_equal("-INF", XSD::XSDDouble.new(-1.0/0.0).to_s)
298
 
    assert_equal(-1, XSD::XSDDouble.new(-1.0/0.0).data.infinite?)
299
 
 
300
 
    targets = [
301
 
      "0.000000000000a",
302
 
      "00a.0000000000001",
303
 
      "+-5",
304
 
    ]
305
 
    targets.each do |d|
306
 
      assert_raises(XSD::ValueSpaceError) do
307
 
        XSD::XSDDouble.new(d)
308
 
      end
309
 
    end
310
 
  end
311
 
 
312
 
  def test_XSDDuration
313
 
    o = XSD::XSDDuration.new
314
 
    assert_equal(XSD::Namespace, o.type.namespace)
315
 
    assert_equal(XSD::DurationLiteral, o.type.name)
316
 
    assert_equal(nil, o.data)
317
 
    assert_equal(true, o.is_nil)
318
 
 
319
 
    targets = [
320
 
      "P1Y2M3DT4H5M6S",
321
 
      "P1234Y5678M9012DT3456H7890M1234.5678S",
322
 
      "P0DT3456H7890M1234.5678S",
323
 
      "P1234Y5678M9012D",
324
 
      "-P1234Y5678M9012DT3456H7890M1234.5678S",
325
 
      "P5678M9012DT3456H7890M1234.5678S",
326
 
      "-P1234Y9012DT3456H7890M1234.5678S",
327
 
      "+P1234Y5678MT3456H7890M1234.5678S",
328
 
      "P1234Y5678M9012DT7890M1234.5678S",
329
 
      "-P1234Y5678M9012DT3456H1234.5678S",
330
 
      "+P1234Y5678M9012DT3456H7890M",
331
 
      "P123400000000000Y",
332
 
      "-P567800000000000M",
333
 
      "+P901200000000000D",
334
 
      "P0DT345600000000000H",
335
 
      "-P0DT789000000000000M",
336
 
      "+P0DT123400000000000.000000000005678S",
337
 
      "P1234YT1234.5678S",
338
 
      "-P5678MT7890M",
339
 
      "+P9012DT3456H",
340
 
    ]
341
 
    targets.each do |str|
342
 
      assert_parsed_result(XSD::XSDDuration, str)
343
 
    end
344
 
 
345
 
    targets = [
346
 
      ["P0Y0M0DT0H0M0S",
347
 
        "P0D"],
348
 
      ["-P0DT0S",
349
 
        "-P0D"],
350
 
      ["P01234Y5678M9012DT3456H7890M1234.5678S",
351
 
        "P1234Y5678M9012DT3456H7890M1234.5678S"],
352
 
      ["P1234Y005678M9012DT3456H7890M1234.5678S",
353
 
        "P1234Y5678M9012DT3456H7890M1234.5678S"],
354
 
      ["P1234Y5678M0009012DT3456H7890M1234.5678S",
355
 
        "P1234Y5678M9012DT3456H7890M1234.5678S"],
356
 
      ["P1234Y5678M9012DT00003456H7890M1234.5678S",
357
 
        "P1234Y5678M9012DT3456H7890M1234.5678S"],
358
 
      ["P1234Y5678M9012DT3456H000007890M1234.5678S",
359
 
        "P1234Y5678M9012DT3456H7890M1234.5678S"],
360
 
      ["P1234Y5678M9012DT3456H7890M0000001234.5678S",
361
 
        "P1234Y5678M9012DT3456H7890M1234.5678S"],
362
 
    ]
363
 
    targets.each do |data, expected|
364
 
      assert_equal(expected, XSD::XSDDuration.new(data).to_s)
365
 
    end
366
 
  end
367
 
 
368
 
  def test_XSDDateTime
369
 
    o = XSD::XSDDateTime.new
370
 
    assert_equal(XSD::Namespace, o.type.namespace)
371
 
    assert_equal(XSD::DateTimeLiteral, o.type.name)
372
 
    assert_equal(nil, o.data)
373
 
    assert_equal(true, o.is_nil)
374
 
 
375
 
    targets = [
376
 
      "2002-05-18T16:52:20Z",
377
 
      "0001-01-01T00:00:00Z",
378
 
      "9999-12-31T23:59:59Z",
379
 
      "19999-12-31T23:59:59Z",
380
 
      "2002-12-31T23:59:59.999Z",
381
 
      "2002-12-31T23:59:59.001Z",
382
 
      "2002-12-31T23:59:59.99999999999999999999Z",
383
 
      "2002-12-31T23:59:59.00000000000000000001Z",
384
 
      "2002-12-31T23:59:59+09:00",
385
 
      "2002-12-31T23:59:59+00:01",
386
 
      "2002-12-31T23:59:59-00:01",
387
 
      "2002-12-31T23:59:59-23:59",
388
 
      "2002-12-31T23:59:59.00000000000000000001+13:30",
389
 
      "2002-12-31T23:59:59.5137Z",
390
 
      "2002-12-31T23:59:59.51375Z",     # 411/800
391
 
      "2002-12-31T23:59:59.51375+12:34",
392
 
      "-2002-05-18T16:52:20Z",
393
 
      "-4713-01-01T12:00:00Z",
394
 
      "-2002-12-31T23:59:59+00:01",
395
 
      "-0001-12-31T23:59:59.00000000000000000001+13:30",
396
 
    ]
397
 
    targets.each do |str|
398
 
      assert_parsed_result(XSD::XSDDateTime, str)
399
 
    end
400
 
 
401
 
    targets = [
402
 
      ["2002-12-31T23:59:59.00",
403
 
        "2002-12-31T23:59:59Z"],
404
 
      ["2002-12-31T23:59:59+00:00",
405
 
        "2002-12-31T23:59:59Z"],
406
 
      ["2002-12-31T23:59:59-00:00",
407
 
        "2002-12-31T23:59:59Z"],
408
 
      ["-2002-12-31T23:59:59.00",
409
 
        "-2002-12-31T23:59:59Z"],
410
 
      ["-2002-12-31T23:59:59+00:00",
411
 
        "-2002-12-31T23:59:59Z"],
412
 
      ["-2002-12-31T23:59:59-00:00",
413
 
        "-2002-12-31T23:59:59Z"],
414
 
    ]
415
 
    targets.each do |data, expected|
416
 
      assert_equal(expected, XSD::XSDDateTime.new(data).to_s)
417
 
      d = DateTime.parse(data)
418
 
      d >>= 12 if d.year < 0    # XSDDateTime.year(-1) == DateTime.year(0)
419
 
      assert_equal(expected, XSD::XSDDateTime.new(d).to_s)
420
 
    end
421
 
 
422
 
    targets = [
423
 
      "0000-05-18T16:52:20Z",
424
 
      "05-18T16:52:20Z",
425
 
      "2002-05T16:52:20Z",
426
 
      "2002-05-18T16:52Z",
427
 
      "",
428
 
    ]
429
 
    targets.each do |d|
430
 
      assert_raises(XSD::ValueSpaceError, d.to_s) do
431
 
        XSD::XSDDateTime.new(d)
432
 
      end
433
 
    end
434
 
  end
435
 
 
436
 
  def test_XSDTime
437
 
    o = XSD::XSDTime.new
438
 
    assert_equal(XSD::Namespace, o.type.namespace)
439
 
    assert_equal(XSD::TimeLiteral, o.type.name)
440
 
    assert_equal(nil, o.data)
441
 
    assert_equal(true, o.is_nil)
442
 
 
443
 
    targets = [
444
 
      "16:52:20Z",
445
 
      "00:00:00Z",
446
 
      "23:59:59Z",
447
 
      "23:59:59.999Z",
448
 
      "23:59:59.001Z",
449
 
      "23:59:59.99999999999999999999Z",
450
 
      "23:59:59.00000000000000000001Z",
451
 
      "23:59:59+09:00",
452
 
      "23:59:59+00:01",
453
 
      "23:59:59-00:01",
454
 
      "23:59:59-23:59",
455
 
      "23:59:59.00000000000000000001+13:30",
456
 
      "23:59:59.51345Z",
457
 
      "23:59:59.51345+12:34",
458
 
      "23:59:59+00:01",
459
 
    ]
460
 
    targets.each do |str|
461
 
      assert_parsed_result(XSD::XSDTime, str)
462
 
    end
463
 
 
464
 
    targets = [
465
 
      ["23:59:59.00",
466
 
        "23:59:59Z"],
467
 
      ["23:59:59+00:00",
468
 
        "23:59:59Z"],
469
 
      ["23:59:59-00:00",
470
 
        "23:59:59Z"],
471
 
    ]
472
 
    targets.each do |data, expected|
473
 
      assert_equal(expected, XSD::XSDTime.new(data).to_s)
474
 
    end
475
 
  end
476
 
 
477
 
  def test_XSDDate
478
 
    o = XSD::XSDDate.new
479
 
    assert_equal(XSD::Namespace, o.type.namespace)
480
 
    assert_equal(XSD::DateLiteral, o.type.name)
481
 
    assert_equal(nil, o.data)
482
 
    assert_equal(true, o.is_nil)
483
 
 
484
 
    targets = [
485
 
      "2002-05-18Z",
486
 
      "0001-01-01Z",
487
 
      "9999-12-31Z",
488
 
      "19999-12-31Z",
489
 
      "2002-12-31+09:00",
490
 
      "2002-12-31+00:01",
491
 
      "2002-12-31-00:01",
492
 
      "2002-12-31-23:59",
493
 
      "2002-12-31+13:30",
494
 
      "-2002-05-18Z",
495
 
      "-19999-12-31Z",
496
 
      "-2002-12-31+00:01",
497
 
      "-0001-12-31+13:30",
498
 
    ]
499
 
    targets.each do |str|
500
 
      assert_parsed_result(XSD::XSDDate, str)
501
 
    end
502
 
 
503
 
    targets = [
504
 
      ["2002-12-31",
505
 
        "2002-12-31Z"],
506
 
      ["2002-12-31+00:00",
507
 
        "2002-12-31Z"],
508
 
      ["2002-12-31-00:00",
509
 
        "2002-12-31Z"],
510
 
      ["-2002-12-31",
511
 
        "-2002-12-31Z"],
512
 
      ["-2002-12-31+00:00",
513
 
        "-2002-12-31Z"],
514
 
      ["-2002-12-31-00:00",
515
 
        "-2002-12-31Z"],
516
 
    ]
517
 
    targets.each do |data, expected|
518
 
      assert_equal(expected, XSD::XSDDate.new(data).to_s)
519
 
      d = Date.parse(data)
520
 
      d >>= 12 if d.year < 0    # XSDDate.year(-1) == Date.year(0)
521
 
      assert_equal(expected, XSD::XSDDate.new(d).to_s)
522
 
    end
523
 
  end
524
 
end
525
 
 
526
 
class TestXSD2 < Test::Unit::TestCase
527
 
  def setup
528
 
    # Nothing to do.
529
 
  end
530
 
 
531
 
  def teardown
532
 
    # Nothing to do.
533
 
  end
534
 
 
535
 
  def assert_parsed_result(klass, str)
536
 
    o = klass.new(str)
537
 
    assert_equal(str, o.to_s)
538
 
  end
539
 
 
540
 
  def test_XSDGYearMonth
541
 
    o = XSD::XSDGYearMonth.new
542
 
    assert_equal(XSD::Namespace, o.type.namespace)
543
 
    assert_equal(XSD::GYearMonthLiteral, o.type.name)
544
 
    assert_equal(nil, o.data)
545
 
    assert_equal(true, o.is_nil)
546
 
 
547
 
    targets = [
548
 
      "2002-05Z",
549
 
      "0001-01Z",
550
 
      "9999-12Z",
551
 
      "19999-12Z",
552
 
      "2002-12+09:00",
553
 
      "2002-12+00:01",
554
 
      "2002-12-00:01",
555
 
      "2002-12-23:59",
556
 
      "2002-12+13:30",
557
 
      "-2002-05Z",
558
 
      "-19999-12Z",
559
 
      "-2002-12+00:01",
560
 
      "-0001-12+13:30",
561
 
    ]
562
 
    targets.each do |str|
563
 
      assert_parsed_result(XSD::XSDGYearMonth, str)
564
 
    end
565
 
 
566
 
    targets = [
567
 
      ["2002-12",
568
 
        "2002-12Z"],
569
 
      ["2002-12+00:00",
570
 
        "2002-12Z"],
571
 
      ["2002-12-00:00",
572
 
        "2002-12Z"],
573
 
      ["-2002-12",
574
 
        "-2002-12Z"],
575
 
      ["-2002-12+00:00",
576
 
        "-2002-12Z"],
577
 
      ["-2002-12-00:00",
578
 
        "-2002-12Z"],
579
 
    ]
580
 
    targets.each do |data, expected|
581
 
      assert_equal(expected, XSD::XSDGYearMonth.new(data).to_s)
582
 
    end
583
 
  end
584
 
 
585
 
  def test_XSDGYear
586
 
    o = XSD::XSDGYear.new
587
 
    assert_equal(XSD::Namespace, o.type.namespace)
588
 
    assert_equal(XSD::GYearLiteral, o.type.name)
589
 
    assert_equal(nil, o.data)
590
 
    assert_equal(true, o.is_nil)
591
 
 
592
 
    targets = [
593
 
      "2002Z",
594
 
      "0001Z",
595
 
      "9999Z",
596
 
      "19999Z",
597
 
      "2002+09:00",
598
 
      "2002+00:01",
599
 
      "2002-00:01",
600
 
      "2002-23:59",
601
 
      "2002+13:30",
602
 
      "-2002Z",
603
 
      "-19999Z",
604
 
      "-2002+00:01",
605
 
      "-0001+13:30",
606
 
    ]
607
 
    targets.each do |str|
608
 
      assert_parsed_result(XSD::XSDGYear, str)
609
 
    end
610
 
 
611
 
    targets = [
612
 
      ["2002",
613
 
        "2002Z"],
614
 
      ["2002+00:00",
615
 
        "2002Z"],
616
 
      ["2002-00:00",
617
 
        "2002Z"],
618
 
      ["-2002",
619
 
        "-2002Z"],
620
 
      ["-2002+00:00",
621
 
        "-2002Z"],
622
 
      ["-2002-00:00",
623
 
        "-2002Z"],
624
 
    ]
625
 
    targets.each do |data, expected|
626
 
      assert_equal(expected, XSD::XSDGYear.new(data).to_s)
627
 
    end
628
 
  end
629
 
 
630
 
  def test_XSDGMonthDay
631
 
    o = XSD::XSDGMonthDay.new
632
 
    assert_equal(XSD::Namespace, o.type.namespace)
633
 
    assert_equal(XSD::GMonthDayLiteral, o.type.name)
634
 
    assert_equal(nil, o.data)
635
 
    assert_equal(true, o.is_nil)
636
 
 
637
 
    targets = [
638
 
      "05-18Z",
639
 
      "01-01Z",
640
 
      "12-31Z",
641
 
      "12-31+09:00",
642
 
      "12-31+00:01",
643
 
      "12-31-00:01",
644
 
      "12-31-23:59",
645
 
      "12-31+13:30",
646
 
    ]
647
 
    targets.each do |str|
648
 
      assert_parsed_result(XSD::XSDGMonthDay, str)
649
 
    end
650
 
 
651
 
    targets = [
652
 
      ["12-31",
653
 
        "12-31Z"],
654
 
      ["12-31+00:00",
655
 
        "12-31Z"],
656
 
      ["12-31-00:00",
657
 
        "12-31Z"],
658
 
    ]
659
 
    targets.each do |data, expected|
660
 
      assert_equal(expected, XSD::XSDGMonthDay.new(data).to_s)
661
 
    end
662
 
  end
663
 
 
664
 
  def test_XSDGDay
665
 
    o = XSD::XSDGDay.new
666
 
    assert_equal(XSD::Namespace, o.type.namespace)
667
 
    assert_equal(XSD::GDayLiteral, o.type.name)
668
 
    assert_equal(nil, o.data)
669
 
    assert_equal(true, o.is_nil)
670
 
 
671
 
    targets = [
672
 
      "18Z",
673
 
      "01Z",
674
 
      "31Z",
675
 
      "31+09:00",
676
 
      "31+00:01",
677
 
      "31-00:01",
678
 
      "31-23:59",
679
 
      "31+13:30",
680
 
    ]
681
 
    targets.each do |str|
682
 
      assert_parsed_result(XSD::XSDGDay, str)
683
 
    end
684
 
 
685
 
    targets = [
686
 
      ["31",
687
 
        "31Z"],
688
 
      ["31+00:00",
689
 
        "31Z"],
690
 
      ["31-00:00",
691
 
        "31Z"],
692
 
    ]
693
 
    targets.each do |data, expected|
694
 
      assert_equal(expected, XSD::XSDGDay.new(data).to_s)
695
 
    end
696
 
  end
697
 
 
698
 
  def test_XSDGMonth
699
 
    o = XSD::XSDGMonth.new
700
 
    assert_equal(XSD::Namespace, o.type.namespace)
701
 
    assert_equal(XSD::GMonthLiteral, o.type.name)
702
 
    assert_equal(nil, o.data)
703
 
    assert_equal(true, o.is_nil)
704
 
 
705
 
    targets = [
706
 
      "05Z",
707
 
      "01Z",
708
 
      "12Z",
709
 
      "12+09:00",
710
 
      "12+00:01",
711
 
      "12-00:01",
712
 
      "12-23:59",
713
 
      "12+13:30",
714
 
    ]
715
 
    targets.each do |str|
716
 
      assert_parsed_result(XSD::XSDGMonth, str)
717
 
    end
718
 
 
719
 
    targets = [
720
 
      ["12",
721
 
        "12Z"],
722
 
      ["12+00:00",
723
 
        "12Z"],
724
 
      ["12-00:00",
725
 
        "12Z"],
726
 
    ]
727
 
    targets.each do |data, expected|
728
 
      assert_equal(expected, XSD::XSDGMonth.new(data).to_s)
729
 
    end
730
 
  end
731
 
 
732
 
  def test_XSDHexBinary
733
 
    o = XSD::XSDHexBinary.new
734
 
    assert_equal(XSD::Namespace, o.type.namespace)
735
 
    assert_equal(XSD::HexBinaryLiteral, o.type.name)
736
 
    assert_equal(nil, o.data)
737
 
    assert_equal(true, o.is_nil)
738
 
 
739
 
    targets = [
740
 
      "abcdef",
741
 
      "\xe3\x81\xaa\xe3\x81\xb2",
742
 
      %Q(\0),
743
 
      "",
744
 
    ]
745
 
    targets.each do |str|
746
 
      assert_equal(str, XSD::XSDHexBinary.new(str).string)
747
 
      assert_equal(str.unpack("H*")[0 ].tr('a-f', 'A-F'),
748
 
        XSD::XSDHexBinary.new(str).data)
749
 
      o = XSD::XSDHexBinary.new
750
 
      o.set_encoded(str.unpack("H*")[0 ].tr('a-f', 'A-F'))
751
 
      assert_equal(str, o.string)
752
 
      o.set_encoded(str.unpack("H*")[0 ].tr('A-F', 'a-f'))
753
 
      assert_equal(str, o.string)
754
 
    end
755
 
 
756
 
    targets = [
757
 
      "0FG7",
758
 
      "0fg7",
759
 
    ]
760
 
    targets.each do |d|
761
 
      assert_raises(XSD::ValueSpaceError, d.to_s) do
762
 
        o = XSD::XSDHexBinary.new
763
 
        o.set_encoded(d)
764
 
        p o.string
765
 
      end
766
 
    end
767
 
  end
768
 
 
769
 
  def test_XSDBase64Binary
770
 
    o = XSD::XSDBase64Binary.new
771
 
    assert_equal(XSD::Namespace, o.type.namespace)
772
 
    assert_equal(XSD::Base64BinaryLiteral, o.type.name)
773
 
    assert_equal(nil, o.data)
774
 
    assert_equal(true, o.is_nil)
775
 
 
776
 
    targets = [
777
 
      "abcdef",
778
 
      "\xe3\x81\xaa\xe3\x81\xb2",
779
 
      %Q(\0),
780
 
      "",
781
 
    ]
782
 
    targets.each do |str|
783
 
      assert_equal(str, XSD::XSDBase64Binary.new(str).string)
784
 
      assert_equal([str ].pack("m").chomp, XSD::XSDBase64Binary.new(str).data)
785
 
      o = XSD::XSDBase64Binary.new
786
 
      o.set_encoded([str ].pack("m").chomp)
787
 
      assert_equal(str, o.string)
788
 
    end
789
 
 
790
 
    targets = [
791
 
      "-",
792
 
      "*",
793
 
    ]
794
 
    targets.each do |d|
795
 
      assert_raises(XSD::ValueSpaceError, d.to_s) do
796
 
        o = XSD::XSDBase64Binary.new
797
 
        o.set_encoded(d)
798
 
        p o.string
799
 
      end
800
 
    end
801
 
  end
802
 
 
803
 
  def test_XSDAnyURI
804
 
    o = XSD::XSDAnyURI.new
805
 
    assert_equal(XSD::Namespace, o.type.namespace)
806
 
    assert_equal(XSD::AnyURILiteral, o.type.name)
807
 
    assert_equal(nil, o.data)
808
 
    assert_equal(true, o.is_nil)
809
 
 
810
 
    # Too few tests here I know.  Believe uri module. :)
811
 
    targets = [
812
 
      "foo",
813
 
      "http://foo",
814
 
      "http://foo/bar/baz",
815
 
      "http://foo/bar#baz",
816
 
      "http://foo/bar%20%20?a+b",
817
 
      "HTTP://FOO/BAR%20%20?A+B",
818
 
    ]
819
 
    targets.each do |str|
820
 
      assert_parsed_result(XSD::XSDAnyURI, str)
821
 
    end
822
 
  end
823
 
 
824
 
  def test_XSDQName
825
 
    o = XSD::XSDQName.new
826
 
    assert_equal(XSD::Namespace, o.type.namespace)
827
 
    assert_equal(XSD::QNameLiteral, o.type.name)
828
 
    assert_equal(nil, o.data)
829
 
    assert_equal(true, o.is_nil)
830
 
 
831
 
    # More strict test is needed but current implementation allows all non-':'
832
 
    # chars like ' ', C0 or C1...
833
 
    targets = [
834
 
      "foo",
835
 
      "foo:bar",
836
 
      "a:b",
837
 
    ]
838
 
    targets.each do |str|
839
 
      assert_parsed_result(XSD::XSDQName, str)
840
 
    end
841
 
  end
842
 
 
843
 
 
844
 
  ###
845
 
  ## Derived types
846
 
  #
847
 
 
848
 
  def test_XSDInteger
849
 
    o = XSD::XSDInteger.new
850
 
    assert_equal(XSD::Namespace, o.type.namespace)
851
 
    assert_equal(XSD::IntegerLiteral, o.type.name)
852
 
    assert_equal(nil, o.data)
853
 
    assert_equal(true, o.is_nil)
854
 
 
855
 
    targets = [
856
 
      0,
857
 
      1000000000,
858
 
      -9999999999,
859
 
      12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890,
860
 
      12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890,
861
 
      -1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789,
862
 
    ]
863
 
    targets.each do |int|
864
 
      assert_equal(int, XSD::XSDInteger.new(int).data)
865
 
    end
866
 
 
867
 
    targets = [
868
 
      "0",
869
 
      "1000000000",
870
 
      "-9999999999",
871
 
      "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890",
872
 
      "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890",
873
 
      "-1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789",
874
 
    ]
875
 
    targets.each do |str|
876
 
      assert_equal(str, XSD::XSDInteger.new(str).to_s)
877
 
    end
878
 
 
879
 
    targets = [
880
 
      ["-0", "0"],
881
 
      ["+0", "0"],
882
 
      ["000123", "123"],
883
 
      ["-000123", "-123"],
884
 
      [
885
 
        "+12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890",
886
 
        "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
887
 
     ],
888
 
    ]
889
 
    targets.each do |data, expected|
890
 
      assert_equal(expected, XSD::XSDInteger.new(data).to_s)
891
 
    end
892
 
 
893
 
    targets = [
894
 
      "0.0",
895
 
      "-5.2",
896
 
      "0.000000000000a",
897
 
      "+-5",
898
 
      "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890."
899
 
    ]
900
 
    targets.each do |d|
901
 
      assert_raises(XSD::ValueSpaceError) do
902
 
        XSD::XSDInteger.new(d)
903
 
      end
904
 
    end
905
 
  end
906
 
 
907
 
  def test_XSDNonPositiveInteger
908
 
    o = XSD::XSDNonPositiveInteger.new
909
 
    assert_equal(XSD::Namespace, o.type.namespace)
910
 
    assert_equal(XSD::NonPositiveIntegerLiteral, o.type.name)
911
 
    assert_equal(nil, o.data)
912
 
    assert_equal(true, o.is_nil)
913
 
 
914
 
    targets = [
915
 
      0,
916
 
      -9999999999,
917
 
      -1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789,
918
 
    ]
919
 
    targets.each do |int|
920
 
      assert_equal(int, XSD::XSDNonPositiveInteger.new(int).data)
921
 
    end
922
 
 
923
 
    targets = [
924
 
      "0",
925
 
      "-9999999999",
926
 
      "-1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789",
927
 
    ]
928
 
    targets.each do |str|
929
 
      assert_equal(str, XSD::XSDNonPositiveInteger.new(str).to_s)
930
 
    end
931
 
 
932
 
    targets = [
933
 
      ["-0", "0"],
934
 
      ["-000123", "-123"],
935
 
    ]
936
 
    targets.each do |data, expected|
937
 
      assert_equal(expected, XSD::XSDNonPositiveInteger.new(data).to_s)
938
 
    end
939
 
 
940
 
    targets = [
941
 
      "0.0",
942
 
      "-5.2",
943
 
      "0.000000000000a",
944
 
      "+-5",
945
 
      "-12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890."
946
 
    ]
947
 
    targets.each do |d|
948
 
      assert_raises(XSD::ValueSpaceError) do
949
 
        XSD::XSDNonPositiveInteger.new(d)
950
 
      end
951
 
    end
952
 
  end
953
 
 
954
 
  def test_XSDNegativeInteger
955
 
    o = XSD::XSDNegativeInteger.new
956
 
    assert_equal(XSD::Namespace, o.type.namespace)
957
 
    assert_equal(XSD::NegativeIntegerLiteral, o.type.name)
958
 
    assert_equal(nil, o.data)
959
 
    assert_equal(true, o.is_nil)
960
 
 
961
 
    targets = [
962
 
      -1,
963
 
      -9999999999,
964
 
      -1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789,
965
 
    ]
966
 
    targets.each do |int|
967
 
      assert_equal(int, XSD::XSDNegativeInteger.new(int).data)
968
 
    end
969
 
 
970
 
    targets = [
971
 
      "-1",
972
 
      "-9999999999",
973
 
      "-1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789",
974
 
    ]
975
 
    targets.each do |str|
976
 
      assert_equal(str, XSD::XSDNegativeInteger.new(str).to_s)
977
 
    end
978
 
 
979
 
    targets = [
980
 
      ["-000123", "-123"],
981
 
    ]
982
 
    targets.each do |data, expected|
983
 
      assert_equal(expected, XSD::XSDNegativeInteger.new(data).to_s)
984
 
    end
985
 
 
986
 
    targets = [
987
 
      "-0.0",
988
 
      "-5.2",
989
 
      "-0.000000000000a",
990
 
      "+-5",
991
 
      "-12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890."
992
 
    ]
993
 
    targets.each do |d|
994
 
      assert_raises(XSD::ValueSpaceError) do
995
 
        XSD::XSDNegativeInteger.new(d)
996
 
      end
997
 
    end
998
 
  end
999
 
 
1000
 
  def test_XSDLong
1001
 
    o = XSD::XSDLong.new
1002
 
    assert_equal(XSD::Namespace, o.type.namespace)
1003
 
    assert_equal(XSD::LongLiteral, o.type.name)
1004
 
    assert_equal(nil, o.data)
1005
 
    assert_equal(true, o.is_nil)
1006
 
 
1007
 
    targets = [
1008
 
      0,
1009
 
      123,
1010
 
      -123,
1011
 
      9223372036854775807,
1012
 
      -9223372036854775808,
1013
 
    ]
1014
 
    targets.each do |lng|
1015
 
      assert_equal(lng, XSD::XSDLong.new(lng).data)
1016
 
    end
1017
 
 
1018
 
    targets = [
1019
 
      "0",
1020
 
      "123",
1021
 
      "-123",
1022
 
      "9223372036854775807",
1023
 
      "-9223372036854775808",
1024
 
    ]
1025
 
    targets.each do |str|
1026
 
      assert_equal(str, XSD::XSDLong.new(str).to_s)
1027
 
    end
1028
 
 
1029
 
    targets = [
1030
 
      ["-0", "0"],
1031
 
      ["+0", "0"],
1032
 
      ["000123", "123"],
1033
 
      ["-000123", "-123"],
1034
 
    ]
1035
 
    targets.each do |data, expected|
1036
 
      assert_equal(expected, XSD::XSDLong.new(data).to_s)
1037
 
    end
1038
 
 
1039
 
    targets = [
1040
 
      9223372036854775808,
1041
 
      -9223372036854775809,
1042
 
      "0.0",
1043
 
      "-5.2",
1044
 
      "0.000000000000a",
1045
 
      "+-5",
1046
 
    ]
1047
 
    targets.each do |d|
1048
 
      assert_raises(XSD::ValueSpaceError) do
1049
 
        XSD::XSDLong.new(d)
1050
 
      end
1051
 
    end
1052
 
  end
1053
 
 
1054
 
  def test_XSDInt
1055
 
    o = XSD::XSDInt.new
1056
 
    assert_equal(XSD::Namespace, o.type.namespace)
1057
 
    assert_equal(XSD::IntLiteral, o.type.name)
1058
 
    assert_equal(nil, o.data)
1059
 
    assert_equal(true, o.is_nil)
1060
 
 
1061
 
    targets = [
1062
 
      0,
1063
 
      123,
1064
 
      -123,
1065
 
      2147483647,
1066
 
      -2147483648,
1067
 
    ]
1068
 
    targets.each do |lng|
1069
 
      assert_equal(lng, XSD::XSDInt.new(lng).data)
1070
 
    end
1071
 
 
1072
 
    targets = [
1073
 
      "0",
1074
 
      "123",
1075
 
      "-123",
1076
 
      "2147483647",
1077
 
      "-2147483648",
1078
 
    ]
1079
 
    targets.each do |str|
1080
 
      assert_equal(str, XSD::XSDInt.new(str).to_s)
1081
 
    end
1082
 
 
1083
 
    targets = [
1084
 
      ["-0", "0"],
1085
 
      ["+0", "0"],
1086
 
      ["000123", "123"],
1087
 
      ["-000123", "-123"],
1088
 
    ]
1089
 
    targets.each do |data, expected|
1090
 
      assert_equal(expected, XSD::XSDInt.new(data).to_s)
1091
 
    end
1092
 
 
1093
 
    targets = [
1094
 
      2147483648,
1095
 
      -2147483649,
1096
 
      "0.0",
1097
 
      "-5.2",
1098
 
      "0.000000000000a",
1099
 
      "+-5",
1100
 
    ]
1101
 
    targets.each do |d|
1102
 
      assert_raises(XSD::ValueSpaceError) do
1103
 
        XSD::XSDInt.new(d)
1104
 
      end
1105
 
    end
1106
 
  end
1107
 
 
1108
 
  def test_XSDShort
1109
 
    o = XSD::XSDShort.new
1110
 
    assert_equal(XSD::Namespace, o.type.namespace)
1111
 
    assert_equal(XSD::ShortLiteral, o.type.name)
1112
 
    assert_equal(nil, o.data)
1113
 
    assert_equal(true, o.is_nil)
1114
 
 
1115
 
    targets = [
1116
 
      0,
1117
 
      123,
1118
 
      -123,
1119
 
      32767,
1120
 
      -32768,
1121
 
    ]
1122
 
    targets.each do |lng|
1123
 
      assert_equal(lng, XSD::XSDShort.new(lng).data)
1124
 
    end
1125
 
 
1126
 
    targets = [
1127
 
      "0",
1128
 
      "123",
1129
 
      "-123",
1130
 
      "32767",
1131
 
      "-32768",
1132
 
    ]
1133
 
    targets.each do |str|
1134
 
      assert_equal(str, XSD::XSDShort.new(str).to_s)
1135
 
    end
1136
 
 
1137
 
    targets = [
1138
 
      ["-0", "0"],
1139
 
      ["+0", "0"],
1140
 
      ["000123", "123"],
1141
 
      ["-000123", "-123"],
1142
 
    ]
1143
 
    targets.each do |data, expected|
1144
 
      assert_equal(expected, XSD::XSDShort.new(data).to_s)
1145
 
    end
1146
 
 
1147
 
    targets = [
1148
 
      32768,
1149
 
      -32769,
1150
 
      "0.0",
1151
 
      "-5.2",
1152
 
      "0.000000000000a",
1153
 
      "+-5",
1154
 
    ]
1155
 
    targets.each do |d|
1156
 
      assert_raises(XSD::ValueSpaceError) do
1157
 
        XSD::XSDShort.new(d)
1158
 
      end
1159
 
    end
1160
 
  end
1161
 
 
1162
 
  def test_XSDByte
1163
 
    o = XSD::XSDByte.new
1164
 
    assert_equal(XSD::Namespace, o.type.namespace)
1165
 
    assert_equal(XSD::ByteLiteral, o.type.name)
1166
 
    assert_equal(nil, o.data)
1167
 
    assert_equal(true, o.is_nil)
1168
 
 
1169
 
    targets = [
1170
 
      0,
1171
 
      123,
1172
 
      -123,
1173
 
      127,
1174
 
      -128,
1175
 
    ]
1176
 
    targets.each do |lng|
1177
 
      assert_equal(lng, XSD::XSDByte.new(lng).data)
1178
 
    end
1179
 
 
1180
 
    targets = [
1181
 
      "0",
1182
 
      "123",
1183
 
      "-123",
1184
 
      "127",
1185
 
      "-128",
1186
 
    ]
1187
 
    targets.each do |str|
1188
 
      assert_equal(str, XSD::XSDByte.new(str).to_s)
1189
 
    end
1190
 
 
1191
 
    targets = [
1192
 
      ["-0", "0"],
1193
 
      ["+0", "0"],
1194
 
      ["000123", "123"],
1195
 
      ["-000123", "-123"],
1196
 
    ]
1197
 
    targets.each do |data, expected|
1198
 
      assert_equal(expected, XSD::XSDByte.new(data).to_s)
1199
 
    end
1200
 
 
1201
 
    targets = [
1202
 
      128,
1203
 
      -129,
1204
 
      "0.0",
1205
 
      "-5.2",
1206
 
      "0.000000000000a",
1207
 
      "+-5",
1208
 
    ]
1209
 
    targets.each do |d|
1210
 
      assert_raises(XSD::ValueSpaceError) do
1211
 
        XSD::XSDByte.new(d)
1212
 
      end
1213
 
    end
1214
 
  end
1215
 
 
1216
 
  def test_XSDNonNegativeInteger
1217
 
    o = XSD::XSDNonNegativeInteger.new
1218
 
    assert_equal(XSD::Namespace, o.type.namespace)
1219
 
    assert_equal(XSD::NonNegativeIntegerLiteral, o.type.name)
1220
 
    assert_equal(nil, o.data)
1221
 
    assert_equal(true, o.is_nil)
1222
 
 
1223
 
    targets = [
1224
 
      0,
1225
 
      1000000000,
1226
 
      12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890,
1227
 
    ]
1228
 
    targets.each do |int|
1229
 
      assert_equal(int, XSD::XSDNonNegativeInteger.new(int).data)
1230
 
    end
1231
 
 
1232
 
    targets = [
1233
 
      "0",
1234
 
      "1000000000",
1235
 
      "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890",
1236
 
    ]
1237
 
    targets.each do |str|
1238
 
      assert_equal(str, XSD::XSDNonNegativeInteger.new(str).to_s)
1239
 
    end
1240
 
 
1241
 
    targets = [
1242
 
      ["-0", "0"],
1243
 
      ["+0", "0"],
1244
 
      ["000123", "123"],
1245
 
      [
1246
 
        "+12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890",
1247
 
        "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
1248
 
     ],
1249
 
    ]
1250
 
    targets.each do |data, expected|
1251
 
      assert_equal(expected, XSD::XSDNonNegativeInteger.new(data).to_s)
1252
 
    end
1253
 
 
1254
 
    targets = [
1255
 
      "0.0",
1256
 
      "0.000000000000a",
1257
 
      "+-5",
1258
 
      "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890."
1259
 
    ]
1260
 
    targets.each do |d|
1261
 
      assert_raises(XSD::ValueSpaceError) do
1262
 
        XSD::XSDNonNegativeInteger.new(d)
1263
 
      end
1264
 
    end
1265
 
  end
1266
 
 
1267
 
  def test_XSDUnsignedLong
1268
 
    o = XSD::XSDUnsignedLong.new
1269
 
    assert_equal(XSD::Namespace, o.type.namespace)
1270
 
    assert_equal(XSD::UnsignedLongLiteral, o.type.name)
1271
 
    assert_equal(nil, o.data)
1272
 
    assert_equal(true, o.is_nil)
1273
 
 
1274
 
    targets = [
1275
 
      0,
1276
 
      1000000000,
1277
 
      18446744073709551615,
1278
 
    ]
1279
 
    targets.each do |int|
1280
 
      assert_equal(int, XSD::XSDUnsignedLong.new(int).data)
1281
 
    end
1282
 
 
1283
 
    targets = [
1284
 
      "0",
1285
 
      "1000000000",
1286
 
      "18446744073709551615",
1287
 
    ]
1288
 
    targets.each do |str|
1289
 
      assert_equal(str, XSD::XSDUnsignedLong.new(str).to_s)
1290
 
    end
1291
 
 
1292
 
    targets = [
1293
 
      ["-0", "0"],
1294
 
      ["+0", "0"],
1295
 
      ["000123", "123"],
1296
 
      ["+18446744073709551615", "18446744073709551615"],
1297
 
    ]
1298
 
    targets.each do |data, expected|
1299
 
      assert_equal(expected, XSD::XSDUnsignedLong.new(data).to_s)
1300
 
    end
1301
 
 
1302
 
    targets = [
1303
 
      "0.0",
1304
 
      "0.000000000000a",
1305
 
      "+-5",
1306
 
      "18446744073709551615."
1307
 
    ]
1308
 
    targets.each do |d|
1309
 
      assert_raises(XSD::ValueSpaceError) do
1310
 
        XSD::XSDUnsignedLong.new(d)
1311
 
      end
1312
 
    end
1313
 
  end
1314
 
 
1315
 
  def test_XSDUnsignedInt
1316
 
    o = XSD::XSDUnsignedInt.new
1317
 
    assert_equal(XSD::Namespace, o.type.namespace)
1318
 
    assert_equal(XSD::UnsignedIntLiteral, o.type.name)
1319
 
    assert_equal(nil, o.data)
1320
 
    assert_equal(true, o.is_nil)
1321
 
 
1322
 
    targets = [
1323
 
      0,
1324
 
      1000000000,
1325
 
      4294967295,
1326
 
    ]
1327
 
    targets.each do |int|
1328
 
      assert_equal(int, XSD::XSDUnsignedInt.new(int).data)
1329
 
    end
1330
 
 
1331
 
    targets = [
1332
 
      "0",
1333
 
      "1000000000",
1334
 
      "4294967295",
1335
 
    ]
1336
 
    targets.each do |str|
1337
 
      assert_equal(str, XSD::XSDUnsignedInt.new(str).to_s)
1338
 
    end
1339
 
 
1340
 
    targets = [
1341
 
      ["-0", "0"],
1342
 
      ["+0", "0"],
1343
 
      ["000123", "123"],
1344
 
      ["+4294967295", "4294967295"],
1345
 
    ]
1346
 
    targets.each do |data, expected|
1347
 
      assert_equal(expected, XSD::XSDUnsignedInt.new(data).to_s)
1348
 
    end
1349
 
 
1350
 
    targets = [
1351
 
      "0.0",
1352
 
      "0.000000000000a",
1353
 
      "+-5",
1354
 
      "4294967295."
1355
 
    ]
1356
 
    targets.each do |d|
1357
 
      assert_raises(XSD::ValueSpaceError) do
1358
 
        XSD::XSDUnsignedInt.new(d)
1359
 
      end
1360
 
    end
1361
 
  end
1362
 
 
1363
 
  def test_XSDUnsignedShort
1364
 
    o = XSD::XSDUnsignedShort.new
1365
 
    assert_equal(XSD::Namespace, o.type.namespace)
1366
 
    assert_equal(XSD::UnsignedShortLiteral, o.type.name)
1367
 
    assert_equal(nil, o.data)
1368
 
    assert_equal(true, o.is_nil)
1369
 
 
1370
 
    targets = [
1371
 
      0,
1372
 
      10000,
1373
 
      65535,
1374
 
    ]
1375
 
    targets.each do |int|
1376
 
      assert_equal(int, XSD::XSDUnsignedShort.new(int).data)
1377
 
    end
1378
 
 
1379
 
    targets = [
1380
 
      "0",
1381
 
      "1000",
1382
 
      "65535",
1383
 
    ]
1384
 
    targets.each do |str|
1385
 
      assert_equal(str, XSD::XSDUnsignedShort.new(str).to_s)
1386
 
    end
1387
 
 
1388
 
    targets = [
1389
 
      ["-0", "0"],
1390
 
      ["+0", "0"],
1391
 
      ["000123", "123"],
1392
 
      ["+65535", "65535"],
1393
 
    ]
1394
 
    targets.each do |data, expected|
1395
 
      assert_equal(expected, XSD::XSDUnsignedShort.new(data).to_s)
1396
 
    end
1397
 
 
1398
 
    targets = [
1399
 
      "0.0",
1400
 
      "0.000000000000a",
1401
 
      "+-5",
1402
 
      "65535."
1403
 
    ]
1404
 
    targets.each do |d|
1405
 
      assert_raises(XSD::ValueSpaceError) do
1406
 
        XSD::XSDUnsignedShort.new(d)
1407
 
      end
1408
 
    end
1409
 
  end
1410
 
 
1411
 
  def test_XSDUnsignedByte
1412
 
    o = XSD::XSDUnsignedByte.new
1413
 
    assert_equal(XSD::Namespace, o.type.namespace)
1414
 
    assert_equal(XSD::UnsignedByteLiteral, o.type.name)
1415
 
    assert_equal(nil, o.data)
1416
 
    assert_equal(true, o.is_nil)
1417
 
 
1418
 
    targets = [
1419
 
      0,
1420
 
      10,
1421
 
      255,
1422
 
    ]
1423
 
    targets.each do |int|
1424
 
      assert_equal(int, XSD::XSDUnsignedByte.new(int).data)
1425
 
    end
1426
 
 
1427
 
    targets = [
1428
 
      "0",
1429
 
      "10",
1430
 
      "255",
1431
 
    ]
1432
 
    targets.each do |str|
1433
 
      assert_equal(str, XSD::XSDUnsignedByte.new(str).to_s)
1434
 
    end
1435
 
 
1436
 
    targets = [
1437
 
      ["-0", "0"],
1438
 
      ["+0", "0"],
1439
 
      ["000123", "123"],
1440
 
      ["+255", "255"],
1441
 
    ]
1442
 
    targets.each do |data, expected|
1443
 
      assert_equal(expected, XSD::XSDUnsignedByte.new(data).to_s)
1444
 
    end
1445
 
 
1446
 
    targets = [
1447
 
      "0.0",
1448
 
      "0.000000000000a",
1449
 
      "+-5",
1450
 
      "255."
1451
 
    ]
1452
 
    targets.each do |d|
1453
 
      assert_raises(XSD::ValueSpaceError) do
1454
 
        XSD::XSDUnsignedByte.new(d)
1455
 
      end
1456
 
    end
1457
 
  end
1458
 
 
1459
 
  def test_XSDPositiveInteger
1460
 
    o = XSD::XSDPositiveInteger.new
1461
 
    assert_equal(XSD::Namespace, o.type.namespace)
1462
 
    assert_equal(XSD::PositiveIntegerLiteral, o.type.name)
1463
 
    assert_equal(nil, o.data)
1464
 
    assert_equal(true, o.is_nil)
1465
 
 
1466
 
    targets = [
1467
 
      1,
1468
 
      1000000000,
1469
 
      12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890,
1470
 
    ]
1471
 
    targets.each do |int|
1472
 
      assert_equal(int, XSD::XSDPositiveInteger.new(int).data)
1473
 
    end
1474
 
 
1475
 
    targets = [
1476
 
      "1",
1477
 
      "1000000000",
1478
 
      "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890",
1479
 
    ]
1480
 
    targets.each do |str|
1481
 
      assert_equal(str, XSD::XSDPositiveInteger.new(str).to_s)
1482
 
    end
1483
 
 
1484
 
    targets = [
1485
 
      ["+1", "1"],
1486
 
      ["000123", "123"],
1487
 
      [
1488
 
        "+12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890",
1489
 
        "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"
1490
 
     ],
1491
 
    ]
1492
 
    targets.each do |data, expected|
1493
 
      assert_equal(expected, XSD::XSDPositiveInteger.new(data).to_s)
1494
 
    end
1495
 
 
1496
 
    targets = [
1497
 
      "1.0",
1498
 
      "1.000000000000a",
1499
 
      "+-5",
1500
 
      "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890."
1501
 
    ]
1502
 
    targets.each do |d|
1503
 
      assert_raises(XSD::ValueSpaceError) do
1504
 
        XSD::XSDPositiveInteger.new(d)
1505
 
      end
1506
 
    end
1507
 
  end
1508
 
end
1509
 
 
1510
 
 
1511
 
end