Welcome to the "trac"-ing site of soap4r!
[soap4r] [httpclient] [openpgp4u] [pkcs1] [logger] [csv] [vtr]

Changeset 1314

Show
Ignore:
Timestamp:
08/03/04 09:32:41 (4 years ago)
Author:
nahi
Message:

* add tests for derived types.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/test/xsd/test_xsd.rb

    r1141 r1314  
    899899  end 
    900900 
     901  def test_XSDNonPositiveInteger 
     902    o = XSD::XSDNonPositiveInteger.new 
     903    assert_equal(XSD::Namespace, o.type.namespace) 
     904    assert_equal(XSD::NonPositiveIntegerLiteral, o.type.name) 
     905    assert_equal(nil, o.data) 
     906    assert_equal(true, o.is_nil) 
     907 
     908    targets = [ 
     909      0, 
     910      -9999999999, 
     911      -1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789, 
     912    ] 
     913    targets.each do |int| 
     914      assert_equal(int, XSD::XSDNonPositiveInteger.new(int).data) 
     915    end 
     916 
     917    targets = [ 
     918      "0", 
     919      "-9999999999", 
     920      "-1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789", 
     921    ] 
     922    targets.each do |str| 
     923      assert_equal(str, XSD::XSDNonPositiveInteger.new(str).to_s) 
     924    end 
     925 
     926    targets = [ 
     927      ["-0", "0"], 
     928      ["-000123", "-123"], 
     929    ] 
     930    targets.each do |data, expected| 
     931      assert_equal(expected, XSD::XSDNonPositiveInteger.new(data).to_s) 
     932    end 
     933 
     934    targets = [ 
     935      "0.0", 
     936      "-5.2", 
     937      "0.000000000000a", 
     938      "+-5", 
     939      "-12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890." 
     940    ] 
     941    targets.each do |d| 
     942      assert_raises(XSD::ValueSpaceError) do 
     943        XSD::XSDNonPositiveInteger.new(d) 
     944      end 
     945    end 
     946  end 
     947 
     948  def test_XSDNegativeInteger 
     949    o = XSD::XSDNegativeInteger.new 
     950    assert_equal(XSD::Namespace, o.type.namespace) 
     951    assert_equal(XSD::NegativeIntegerLiteral, o.type.name) 
     952    assert_equal(nil, o.data) 
     953    assert_equal(true, o.is_nil) 
     954 
     955    targets = [ 
     956      -1, 
     957      -9999999999, 
     958      -1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789, 
     959    ] 
     960    targets.each do |int| 
     961      assert_equal(int, XSD::XSDNegativeInteger.new(int).data) 
     962    end 
     963 
     964    targets = [ 
     965      "-1", 
     966      "-9999999999", 
     967      "-1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789", 
     968    ] 
     969    targets.each do |str| 
     970      assert_equal(str, XSD::XSDNegativeInteger.new(str).to_s) 
     971    end 
     972 
     973    targets = [ 
     974      ["-000123", "-123"], 
     975    ] 
     976    targets.each do |data, expected| 
     977      assert_equal(expected, XSD::XSDNegativeInteger.new(data).to_s) 
     978    end 
     979 
     980    targets = [ 
     981      "-0.0", 
     982      "-5.2", 
     983      "-0.000000000000a", 
     984      "+-5", 
     985      "-12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890." 
     986    ] 
     987    targets.each do |d| 
     988      assert_raises(XSD::ValueSpaceError) do 
     989        XSD::XSDNegativeInteger.new(d) 
     990      end 
     991    end 
     992  end 
     993 
    901994  def test_XSDLong 
    902995    o = XSD::XSDLong.new 
    …… 
    10061099    end 
    10071100  end 
     1101 
     1102  def test_XSDShort 
     1103    o = XSD::XSDShort.new 
     1104    assert_equal(XSD::Namespace, o.type.namespace) 
     1105    assert_equal(XSD::ShortLiteral, o.type.name) 
     1106    assert_equal(nil, o.data) 
     1107    assert_equal(true, o.is_nil) 
     1108 
     1109    targets = [ 
     1110      0, 
     1111      123, 
     1112      -123, 
     1113      32767, 
     1114      -32768, 
     1115    ] 
     1116    targets.each do |lng| 
     1117      assert_equal(lng, XSD::XSDShort.new(lng).data) 
     1118    end 
     1119 
     1120    targets = [ 
     1121      "0", 
     1122      "123", 
     1123      "-123", 
     1124      "32767", 
     1125      "-32768", 
     1126    ] 
     1127    targets.each do |str| 
     1128      assert_equal(str, XSD::XSDShort.new(str).to_s) 
     1129    end 
     1130 
     1131    targets = [ 
     1132      ["-0", "0"], 
     1133      ["+0", "0"], 
     1134      ["000123", "123"], 
     1135      ["-000123", "-123"], 
     1136    ] 
     1137    targets.each do |data, expected| 
     1138      assert_equal(expected, XSD::XSDShort.new(data).to_s) 
     1139    end 
     1140 
     1141    targets = [ 
     1142      32768, 
     1143      -32769, 
     1144      "0.0", 
     1145      "-5.2", 
     1146      "0.000000000000a", 
     1147      "+-5", 
     1148    ] 
     1149    targets.each do |d| 
     1150      assert_raises(XSD::ValueSpaceError) do 
     1151        XSD::XSDShort.new(d) 
     1152      end 
     1153    end 
     1154  end 
     1155 
     1156  def test_XSDByte 
     1157    o = XSD::XSDByte.new 
     1158    assert_equal(XSD::Namespace, o.type.namespace) 
     1159    assert_equal(XSD::ByteLiteral, o.type.name) 
     1160    assert_equal(nil, o.data) 
     1161    assert_equal(true, o.is_nil) 
     1162 
     1163    targets = [ 
     1164      0, 
     1165      123, 
     1166      -123, 
     1167      127, 
     1168      -128, 
     1169    ] 
     1170    targets.each do |lng| 
     1171      assert_equal(lng, XSD::XSDByte.new(lng).data) 
     1172    end 
     1173 
     1174    targets = [ 
     1175      "0", 
     1176      "123", 
     1177      "-123", 
     1178      "127", 
     1179      "-128", 
     1180    ] 
     1181    targets.each do |str| 
     1182      assert_equal(str, XSD::XSDByte.new(str).to_s) 
     1183    end 
     1184 
     1185    targets = [ 
     1186      ["-0", "0"], 
     1187      ["+0", "0"], 
     1188      ["000123", "123"], 
     1189      ["-000123", "-123"], 
     1190    ] 
     1191    targets.each do |data, expected| 
     1192      assert_equal(expected, XSD::XSDByte.new(data).to_s) 
     1193    end 
     1194 
     1195    targets = [ 
     1196      128, 
     1197      -129, 
     1198      "0.0", 
     1199      "-5.2", 
     1200      "0.000000000000a", 
     1201      "+-5", 
     1202    ] 
     1203    targets.each do |d| 
     1204      assert_raises(XSD::ValueSpaceError) do 
     1205        XSD::XSDByte.new(d) 
     1206      end 
     1207    end 
     1208  end 
     1209 
     1210  def test_XSDNonNegativeInteger 
     1211    o = XSD::XSDNonNegativeInteger.new 
     1212    assert_equal(XSD::Namespace, o.type.namespace) 
     1213    assert_equal(XSD::NonNegativeIntegerLiteral, o.type.name) 
     1214    assert_equal(nil, o.data) 
     1215    assert_equal(true, o.is_nil) 
     1216 
     1217    targets = [ 
     1218      0, 
     1219      1000000000, 
     1220      12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890, 
     1221    ] 
     1222    targets.each do |int| 
     1223      assert_equal(int, XSD::XSDNonNegativeInteger.new(int).data) 
     1224    end 
     1225 
     1226    targets = [ 
     1227      "0", 
     1228      "1000000000", 
     1229      "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890", 
     1230    ] 
     1231    targets.each do |str| 
     1232      assert_equal(str, XSD::XSDNonNegativeInteger.new(str).to_s) 
     1233    end 
     1234 
     1235    targets = [ 
     1236      ["-0", "0"], 
     1237      ["+0", "0"], 
     1238      ["000123", "123"], 
     1239      [ 
     1240        "+12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890", 
     1241        "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890" 
     1242     ], 
     1243    ] 
     1244    targets.each do |data, expected| 
     1245      assert_equal(expected, XSD::XSDNonNegativeInteger.new(data).to_s) 
     1246    end 
     1247 
     1248    targets = [ 
     1249      "0.0", 
     1250      "0.000000000000a", 
     1251      "+-5", 
     1252      "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890." 
     1253    ] 
     1254    targets.each do |d| 
     1255      assert_raises(XSD::ValueSpaceError) do 
     1256        XSD::XSDNonNegativeInteger.new(d) 
     1257      end 
     1258    end 
     1259  end 
     1260 
     1261  def test_XSDUnsignedLong 
     1262    o = XSD::XSDUnsignedLong.new 
     1263    assert_equal(XSD::Namespace, o.type.namespace) 
     1264    assert_equal(XSD::UnsignedLongLiteral, o.type.name) 
     1265    assert_equal(nil, o.data) 
     1266    assert_equal(true, o.is_nil) 
     1267 
     1268    targets = [ 
     1269      0, 
     1270      1000000000, 
     1271      18446744073709551615, 
     1272    ] 
     1273    targets.each do |int| 
     1274      assert_equal(int, XSD::XSDUnsignedLong.new(int).data) 
     1275    end 
     1276 
     1277    targets = [ 
     1278      "0", 
     1279      "1000000000", 
     1280      "18446744073709551615", 
     1281    ] 
     1282    targets.each do |str| 
     1283      assert_equal(str, XSD::XSDUnsignedLong.new(str).to_s) 
     1284    end 
     1285 
     1286    targets = [ 
     1287      ["-0", "0"], 
     1288      ["+0", "0"], 
     1289      ["000123", "123"], 
     1290      ["+18446744073709551615", "18446744073709551615"], 
     1291    ] 
     1292    targets.each do |data, expected| 
     1293      assert_equal(expected, XSD::XSDUnsignedLong.new(data).to_s) 
     1294    end 
     1295 
     1296    targets = [ 
     1297      "0.0", 
     1298      "0.000000000000a", 
     1299      "+-5", 
     1300      "18446744073709551615." 
     1301    ] 
     1302    targets.each do |d| 
     1303      assert_raises(XSD::ValueSpaceError) do 
     1304        XSD::XSDUnsignedLong.new(d) 
     1305      end 
     1306    end 
     1307  end 
     1308 
     1309  def test_XSDUnsignedInt 
     1310    o = XSD::XSDUnsignedInt.new 
     1311    assert_equal(XSD::Namespace, o.type.namespace) 
     1312    assert_equal(XSD::UnsignedIntLiteral, o.type.name) 
     1313    assert_equal(nil, o.data) 
     1314    assert_equal(true, o.is_nil) 
     1315 
     1316    targets = [ 
     1317      0, 
     1318      1000000000, 
     1319      4294967295, 
     1320    ] 
     1321    targets.each do |int| 
     1322      assert_equal(int, XSD::XSDUnsignedInt.new(int).data) 
     1323    end 
     1324 
     1325    targets = [ 
     1326      "0", 
     1327      "1000000000", 
     1328      "4294967295", 
     1329    ] 
     1330    targets.each do |str| 
     1331      assert_equal(str, XSD::XSDUnsignedInt.new(str).to_s) 
     1332    end 
     1333 
     1334    targets = [ 
     1335      ["-0", "0"], 
     1336      ["+0", "0"], 
     1337      ["000123", "123"], 
     1338      ["+4294967295", "4294967295"], 
     1339    ] 
     1340    targets.each do |data, expected| 
     1341      assert_equal(expected, XSD::XSDUnsignedInt.new(data).to_s) 
     1342    end 
     1343 
     1344    targets = [ 
     1345      "0.0", 
     1346      "0.000000000000a", 
     1347      "+-5", 
     1348      "4294967295." 
     1349    ] 
     1350    targets.each do |d| 
     1351      assert_raises(XSD::ValueSpaceError) do 
     1352        XSD::XSDUnsignedInt.new(d) 
     1353      end 
     1354    end 
     1355  end 
     1356 
     1357  def test_XSDUnsignedShort 
     1358    o = XSD::XSDUnsignedShort.new 
     1359    assert_equal(XSD::Namespace, o.type.namespace) 
     1360    assert_equal(XSD::UnsignedShortLiteral, o.type.name) 
     1361    assert_equal(nil, o.data) 
     1362    assert_equal(true, o.is_nil) 
     1363 
     1364    targets = [ 
     1365      0, 
     1366      10000, 
     1367      65535, 
     1368    ] 
     1369    targets.each do |int| 
     1370      assert_equal(int, XSD::XSDUnsignedShort.new(int).data) 
     1371    end 
     1372 
     1373    targets = [ 
     1374      "0", 
     1375      "1000", 
     1376      "65535", 
     1377    ] 
     1378    targets.each do |str| 
     1379      assert_equal(str, XSD::XSDUnsignedShort.new(str).to_s) 
     1380    end 
     1381 
     1382    targets = [ 
     1383      ["-0", "0"], 
     1384      ["+0", "0"], 
     1385      ["000123", "123"], 
     1386      ["+65535", "65535"], 
     1387    ] 
     1388    targets.each do |data, expected| 
     1389      assert_equal(expected, XSD::XSDUnsignedShort.new(data).to_s) 
     1390    end 
     1391 
     1392    targets = [ 
     1393      "0.0", 
     1394      "0.000000000000a", 
     1395      "+-5", 
     1396      "65535." 
     1397    ] 
     1398    targets.each do |d| 
     1399      assert_raises(XSD::ValueSpaceError) do 
     1400        XSD::XSDUnsignedShort.new(d) 
     1401      end 
     1402    end 
     1403  end 
     1404 
     1405  def test_XSDUnsignedByte 
     1406    o = XSD::XSDUnsignedByte.new 
     1407    assert_equal(XSD::Namespace, o.type.namespace) 
     1408    assert_equal(XSD::UnsignedByteLiteral, o.type.name) 
     1409    assert_equal(nil, o.data) 
     1410    assert_equal(true, o.is_nil) 
     1411 
     1412    targets = [ 
     1413      0, 
     1414      10, 
     1415      255, 
     1416    ] 
     1417    targets.each do |int| 
     1418      assert_equal(int, XSD::XSDUnsignedByte.new(int).data) 
     1419    end 
     1420 
     1421    targets = [ 
     1422      "0", 
     1423      "10", 
     1424      "255", 
     1425    ] 
     1426    targets.each do |str| 
     1427      assert_equal(str, XSD::XSDUnsignedByte.new(str).to_s) 
     1428    end 
     1429 
     1430    targets = [ 
     1431      ["-0", "0"], 
     1432      ["+0", "0"], 
     1433      ["000123", "123"], 
     1434      ["+255", "255"], 
     1435    ] 
     1436    targets.each do |data, expected| 
     1437      assert_equal(expected, XSD::XSDUnsignedByte.new(data).to_s) 
     1438    end 
     1439 
     1440    targets = [ 
     1441      "0.0", 
     1442      "0.000000000000a", 
     1443      "+-5", 
     1444      "255." 
     1445    ] 
     1446    targets.each do |d| 
     1447      assert_raises(XSD::ValueSpaceError) do 
     1448        XSD::XSDUnsignedByte.new(d) 
     1449      end 
     1450    end 
     1451  end 
     1452 
     1453  def test_XSDPositiveInteger 
     1454    o = XSD::XSDPositiveInteger.new 
     1455    assert_equal(XSD::Namespace, o.type.namespace) 
     1456    assert_equal(XSD::PositiveIntegerLiteral, o.type.name) 
     1457    assert_equal(nil, o.data) 
     1458    assert_equal(true, o.is_nil) 
     1459 
     1460    targets = [ 
     1461      1, 
     1462      1000000000, 
     1463      12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890, 
     1464    ] 
     1465    targets.each do |int| 
     1466      assert_equal(int, XSD::XSDPositiveInteger.new(int).data) 
     1467    end 
     1468 
     1469    targets = [ 
     1470      "1", 
     1471      "1000000000", 
     1472      "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890", 
     1473    ] 
     1474    targets.each do |str| 
     1475      assert_equal(str, XSD::XSDPositiveInteger.new(str).to_s) 
     1476    end 
     1477 
     1478    targets = [ 
     1479      ["+1", "1"], 
     1480      ["000123", "123"], 
     1481      [ 
     1482        "+12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890", 
     1483        "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890" 
     1484     ], 
     1485    ] 
     1486    targets.each do |data, expected| 
     1487      assert_equal(expected, XSD::XSDPositiveInteger.new(data).to_s) 
     1488    end 
     1489 
     1490    targets = [ 
     1491      "1.0", 
     1492      "1.000000000000a", 
     1493      "+-5", 
     1494      "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890." 
     1495    ] 
     1496    targets.each do |d| 
     1497      assert_raises(XSD::ValueSpaceError) do 
     1498        XSD::XSDPositiveInteger.new(d) 
     1499      end 
     1500    end 
     1501  end 
    10081502end 
    10091503