/js/src/jit-test/tests/basic/testComparisons.js

http://github.com/zpao/v8monkey · JavaScript · 988 lines · 959 code · 21 blank · 8 comment · 14 complexity · efbb2b9b73029da8bc14650285c8260f MD5 · raw file 

    

  1. function testComparisons()
    2. 

  2. {
    3. 

  3.   // All the special values from each of the types in
    4. 

  4.   // ECMA-262, 3rd ed. section 8
    5. 

  5.   var undefinedType, nullType, booleanType, stringType, numberType, objectType;
    6. 

  6. 

  7.   var types = [];
    8. 

  8.   types[undefinedType = 0] = "Undefined";
    9. 

  9.   types[nullType = 1] = "Null";
    10. 

  10.   types[booleanType = 2] = "Boolean";
    11. 

  11.   types[stringType = 3] = "String";
    12. 

  12.   types[numberType = 4] = "Number";
    13. 

  13.   types[objectType = 5] = "Object";
    14. 

  14. 

  15.   var JSVAL_INT_MIN = -Math.pow(2, 30);
    16. 

  16.   var JSVAL_INT_MAX = Math.pow(2, 30) - 1;
    17. 

  17. 

  18.   // Values from every ES3 type, hitting all the edge-case and special values
    19. 

  19.   // that can be dreamed up
    20. 

  20.   var values =
    21. 

  21.     {
    22. 

  22.      "undefined":
    23. 

  23.        {
    24. 

  24.          value: function() { return undefined; },
    25. 

  25.          type: undefinedType
    26. 

  26.        },
    27. 

  27.      "null":
    28. 

  28.        {
    29. 

  29.          value: function() { return null; },
    30. 

  30.          type: nullType
    31. 

  31.        },
    32. 

  32.      "true":
    33. 

  33.        {
    34. 

  34.          value: function() { return true; },
    35. 

  35.          type: booleanType
    36. 

  36.        },
    37. 

  37.      "false":
    38. 

  38.        {
    39. 

  39.          value: function() { return false; },
    40. 

  40.          type: booleanType
    41. 

  41.        },
    42. 

  42.      '""':
    43. 

  43.        {
    44. 

  44.          value: function() { return ""; },
    45. 

  45.          type: stringType
    46. 

  46.        },
    47. 

  47.      '"a"':
    48. 

  48.        {
    49. 

  49.          // a > [, for string-object comparisons
    50. 

  50.          value: function() { return "a"; },
    51. 

  51.          type: stringType
    52. 

  52.        },
    53. 

  53.      '"Z"':
    54. 

  54.        {
    55. 

  55.          // Z < [, for string-object comparisons
    56. 

  56.          value: function() { return "Z"; },
    57. 

  57.          type: stringType
    58. 

  58.        },
    59. 

  59.      "0":
    60. 

  60.        {
    61. 

  61.          value: function() { return 0; },
    62. 

  62.          type: numberType
    63. 

  63.        },
    64. 

  64.      "-0":
    65. 

  65.        {
    66. 

  66.          value: function() { return -0; },
    67. 

  67.          type: numberType
    68. 

  68.        },
    69. 

  69.      "1":
    70. 

  70.        {
    71. 

  71.          value: function() { return 1; },
    72. 

  72.          type: numberType
    73. 

  73.        },
    74. 

  74.      "Math.E":
    75. 

  75.        {
    76. 

  76.          value: function() { return Math.E; },
    77. 

  77.          type: numberType
    78. 

  78.        },
    79. 

  79.      "JSVAL_INT_MIN - 1":
    80. 

  80.        {
    81. 

  81.          value: function() { return JSVAL_INT_MIN - 1; },
    82. 

  82.          type: numberType
    83. 

  83.        },
    84. 

  84.      "JSVAL_INT_MIN":
    85. 

  85.        {
    86. 

  86.          value: function() { return JSVAL_INT_MIN; },
    87. 

  87.          type: numberType
    88. 

  88.        },
    89. 

  89.      "JSVAL_INT_MIN + 1":
    90. 

  90.        {
    91. 

  91.          value: function() { return JSVAL_INT_MIN + 1; },
    92. 

  92.          type: numberType
    93. 

  93.        },
    94. 

  94.      "JSVAL_INT_MAX - 1":
    95. 

  95.        {
    96. 

  96.          value: function() { return JSVAL_INT_MAX - 1; },
    97. 

  97.          type: numberType
    98. 

  98.        },
    99. 

  99.      "JSVAL_INT_MAX":
    100. 

  100.        {
    101. 

  101.          value: function() { return JSVAL_INT_MAX; },
    102. 

  102.          type: numberType
    103. 

  103.        },
    104. 

  104.      "JSVAL_INT_MAX + 1":
    105. 

  105.        {
    106. 

  106.          value: function() { return JSVAL_INT_MAX + 1; },
    107. 

  107.          type: numberType
    108. 

  108.        },
    109. 

  109.      "Infinity":
    110. 

  110.        {
    111. 

  111.          value: function() { return Infinity; },
    112. 

  112.          type: numberType
    113. 

  113.        },
    114. 

  114.      "-Infinity":
    115. 

  115.        {
    116. 

  116.          value: function() { return -Infinity; },
    117. 

  117.          type: numberType
    118. 

  118.        },
    119. 

  119.      "NaN":
    120. 

  120.        {
    121. 

  121.          value: function() { return NaN; },
    122. 

  122.          type: numberType
    123. 

  123.        },
    124. 

  124.      "{}":
    125. 

  125.        {
    126. 

  126.          value: function() { return {}; },
    127. 

  127.          type: objectType
    128. 

  128.        },
    129. 

  129.      "{ valueOf: undefined }":
    130. 

  130.        {
    131. 

  131.          value: function() { return { valueOf: undefined }; },
    132. 

  132.          type: objectType
    133. 

  133.        },
    134. 

  134.      "[]":
    135. 

  135.        {
    136. 

  136.          value: function() { return []; },
    137. 

  137.          type: objectType
    138. 

  138.        },
    139. 

  139.      '[""]':
    140. 

  140.        {
    141. 

  141.          value: function() { return [""]; },
    142. 

  142.          type: objectType
    143. 

  143.        },
    144. 

  144.      '["a"]':
    145. 

  145.        {
    146. 

  146.          value: function() { return ["a"]; },
    147. 

  147.          type: objectType
    148. 

  148.        },
    149. 

  149.      "[0]":
    150. 

  150.        {
    151. 

  151.          value: function() { return [0]; },
    152. 

  152.          type: objectType
    153. 

  153.        }
    154. 

  154.     };
    155. 

  155. 

  156.   var orderOps =
    157. 

  157.     {
    158. 

  158.      "<": function(a, b) { return a < b; },
    159. 

  159.      ">": function(a, b) { return a > b; },
    160. 

  160.      "<=": function(a, b) { return a <= b; },
    161. 

  161.      ">=": function(a, b) { return a >= b; }
    162. 

  162.     };
    163. 

  163.   var eqOps =
    164. 

  164.     {
    165. 

  165.      "==": function(a, b) { return a == b; },
    166. 

  166.      "!=": function(a, b) { return a != b; },
    167. 

  167.      "===": function(a, b) { return a === b; },
    168. 

  168.      "!==": function(a, b) { return a !== b; }
    169. 

  169.     };
    170. 

  170. 

  171. 

  172.   var notEqualIncomparable =
    173. 

  173.     {
    174. 

  174.       eq: { "==": false, "!=": true, "===": false, "!==": true },
    175. 

  175.       order: { "<": false, ">": false, "<=": false, ">=": false }
    176. 

  176.     };
    177. 

  177.   var notEqualLessThan =
    178. 

  178.     {
    179. 

  179.       eq: { "==": false, "!=": true, "===": false, "!==": true },
    180. 

  180.       order: { "<": true, ">": false, "<=": true, ">=": false }
    181. 

  181.     };
    182. 

  182.   var notEqualGreaterThan =
    183. 

  183.     {
    184. 

  184.       eq: { "==": false, "!=": true, "===": false, "!==": true },
    185. 

  185.       order: { "<": false, ">": true, "<=": false, ">=": true }
    186. 

  186.     };
    187. 

  187.   var notEqualNorDifferent =
    188. 

  188.     {
    189. 

  189.       eq: { "==": false, "!=": true, "===": false, "!==": true },
    190. 

  190.       order: { "<": false, ">": false, "<=": true, ">=": true }
    191. 

  191.     };
    192. 

  192.   var strictlyEqual =
    193. 

  193.     {
    194. 

  194.       eq: { "==": true, "!=": false, "===": true, "!==": false },
    195. 

  195.       order: { "<": false, ">": false, "<=": true, ">=": true }
    196. 

  196.     };
    197. 

  197.   var looselyEqual =
    198. 

  198.     {
    199. 

  199.       eq: { "==": true, "!=": false, "===": false, "!==": true },
    200. 

  200.       order: { "<": false, ">": false, "<=": true, ">=": true }
    201. 

  201.     };
    202. 

  202.   var looselyEqualNotDifferent =
    203. 

  203.     {
    204. 

  204.       eq: { "==": true, "!=": false, "===": false, "!==": true },
    205. 

  205.       order: { "<": false, ">": false, "<=": true, ">=": true }
    206. 

  206.     };
    207. 

  207.   var looselyEqualIncomparable =
    208. 

  208.     {
    209. 

  209.       eq: { "==": true, "!=": false, "===": false, "!==": true },
    210. 

  210.       order: { "<": false, ">": false, "<=": false, ">=": false }
    211. 

  211.     };
    212. 

  212.   var strictlyEqualNotDifferent =
    213. 

  213.     {
    214. 

  214.       eq: { "==": true, "!=": false, "===": true, "!==": false },
    215. 

  215.       order: { "<": false, ">": false, "<=": true, ">=": true }
    216. 

  216.     };
    217. 

  217.   var strictlyEqualIncomparable =
    218. 

  218.     {
    219. 

  219.       eq: { "==": true, "!=": false, "===": true, "!==": false },
    220. 

  220.       order: { "<": false, ">": false, "<=": false, ">=": false }
    221. 

  221.     };
    222. 

  222. 

  223.   var comparingZeroToSomething =
    224. 

  224.     {
    225. 

  225.       "undefined": notEqualIncomparable,
    226. 

  226.       "null": notEqualNorDifferent,
    227. 

  227.       "true": notEqualLessThan,
    228. 

  228.       "false": looselyEqual,
    229. 

  229.       '""': looselyEqualNotDifferent,
    230. 

  230.       '"a"': notEqualIncomparable,
    231. 

  231.       '"Z"': notEqualIncomparable,
    232. 

  232.       "0": strictlyEqual,
    233. 

  233.       "-0": strictlyEqual,
    234. 

  234.       "1": notEqualLessThan,
    235. 

  235.       "Math.E": notEqualLessThan,
    236. 

  236.       "JSVAL_INT_MIN - 1": notEqualGreaterThan,
    237. 

  237.       "JSVAL_INT_MIN": notEqualGreaterThan,
    238. 

  238.       "JSVAL_INT_MIN + 1": notEqualGreaterThan,
    239. 

  239.       "JSVAL_INT_MAX - 1": notEqualLessThan,
    240. 

  240.       "JSVAL_INT_MAX": notEqualLessThan,
    241. 

  241.       "JSVAL_INT_MAX + 1": notEqualLessThan,
    242. 

  242.       "Infinity": notEqualLessThan,
    243. 

  243.       "-Infinity": notEqualGreaterThan,
    244. 

  244.       "NaN": notEqualIncomparable,
    245. 

  245.       "{}": notEqualIncomparable,
    246. 

  246.       "{ valueOf: undefined }": notEqualIncomparable,
    247. 

  247.       "[]": looselyEqual,
    248. 

  248.       '[""]': looselyEqual,
    249. 

  249.       '["a"]': notEqualIncomparable,
    250. 

  250.       "[0]": looselyEqual
    251. 

  251.     };
    252. 

  252. 

  253.   var comparingObjectOrObjectWithValueUndefined =
    254. 

  254.     {
    255. 

  255.       "undefined": notEqualIncomparable,
    256. 

  256.       "null": notEqualIncomparable,
    257. 

  257.       "true": notEqualIncomparable,
    258. 

  258.       "false": notEqualIncomparable,
    259. 

  259.       '""': notEqualGreaterThan,
    260. 

  260.       '"a"': notEqualLessThan,
    261. 

  261.       '"Z"': notEqualGreaterThan,
    262. 

  262.       "0": notEqualIncomparable,
    263. 

  263.       "-0": notEqualIncomparable,
    264. 

  264.       "1": notEqualIncomparable,
    265. 

  265.       "Math.E": notEqualIncomparable,
    266. 

  266.       "JSVAL_INT_MIN - 1": notEqualIncomparable,
    267. 

  267.       "JSVAL_INT_MIN": notEqualIncomparable,
    268. 

  268.       "JSVAL_INT_MIN + 1": notEqualIncomparable,
    269. 

  269.       "JSVAL_INT_MAX - 1": notEqualIncomparable,
    270. 

  270.       "JSVAL_INT_MAX": notEqualIncomparable,
    271. 

  271.       "JSVAL_INT_MAX + 1": notEqualIncomparable,
    272. 

  272.       "Infinity": notEqualIncomparable,
    273. 

  273.       "-Infinity": notEqualIncomparable,
    274. 

  274.       "NaN": notEqualIncomparable,
    275. 

  275.       "{}": notEqualNorDifferent,
    276. 

  276.       "{ valueOf: undefined }": notEqualNorDifferent,
    277. 

  277.       "[]": notEqualGreaterThan,
    278. 

  278.       '[""]': notEqualGreaterThan,
    279. 

  279.       '["a"]': notEqualLessThan,
    280. 

  280.       "[0]": notEqualGreaterThan
    281. 

  281.     };
    282. 

  282. 

  283.   // Constructed expected-value matrix
    284. 

  284.   var expected =
    285. 

  285.     {
    286. 

  286.      "undefined":
    287. 

  287.        {
    288. 

  288.          "undefined": strictlyEqualIncomparable,
    289. 

  289.          "null": looselyEqualIncomparable,
    290. 

  290.          "true": notEqualIncomparable,
    291. 

  291.          "false": notEqualIncomparable,
    292. 

  292.          '""': notEqualIncomparable,
    293. 

  293.          '"a"': notEqualIncomparable,
    294. 

  294.          '"Z"': notEqualIncomparable,
    295. 

  295.          "0": notEqualIncomparable,
    296. 

  296.          "-0": notEqualIncomparable,
    297. 

  297.          "1": notEqualIncomparable,
    298. 

  298.          "Math.E": notEqualIncomparable,
    299. 

  299.          "JSVAL_INT_MIN - 1": notEqualIncomparable,
    300. 

  300.          "JSVAL_INT_MIN": notEqualIncomparable,
    301. 

  301.          "JSVAL_INT_MIN + 1": notEqualIncomparable,
    302. 

  302.          "JSVAL_INT_MAX - 1": notEqualIncomparable,
    303. 

  303.          "JSVAL_INT_MAX": notEqualIncomparable,
    304. 

  304.          "JSVAL_INT_MAX + 1": notEqualIncomparable,
    305. 

  305.          "Infinity": notEqualIncomparable,
    306. 

  306.          "-Infinity": notEqualIncomparable,
    307. 

  307.          "NaN": notEqualIncomparable,
    308. 

  308.          "{}": notEqualIncomparable,
    309. 

  309.          "{ valueOf: undefined }": notEqualIncomparable,
    310. 

  310.          "[]": notEqualIncomparable,
    311. 

  311.          '[""]': notEqualIncomparable,
    312. 

  312.          '["a"]': notEqualIncomparable,
    313. 

  313.          "[0]": notEqualIncomparable
    314. 

  314.        },
    315. 

  315.      "null":
    316. 

  316.        {
    317. 

  317.          "undefined": looselyEqualIncomparable,
    318. 

  318.          "null": strictlyEqualNotDifferent,
    319. 

  319.          "true": notEqualLessThan,
    320. 

  320.          "false": notEqualNorDifferent,
    321. 

  321.          '""': notEqualNorDifferent,
    322. 

  322.          '"a"': notEqualIncomparable,
    323. 

  323.          '"Z"': notEqualIncomparable,
    324. 

  324.          "0": notEqualNorDifferent,
    325. 

  325.          "-0": notEqualNorDifferent,
    326. 

  326.          "1": notEqualLessThan,
    327. 

  327.          "Math.E": notEqualLessThan,
    328. 

  328.          "JSVAL_INT_MIN - 1": notEqualGreaterThan,
    329. 

  329.          "JSVAL_INT_MIN": notEqualGreaterThan,
    330. 

  330.          "JSVAL_INT_MIN + 1": notEqualGreaterThan,
    331. 

  331.          "JSVAL_INT_MAX - 1": notEqualLessThan,
    332. 

  332.          "JSVAL_INT_MAX": notEqualLessThan,
    333. 

  333.          "JSVAL_INT_MAX + 1": notEqualLessThan,
    334. 

  334.          "Infinity": notEqualLessThan,
    335. 

  335.          "-Infinity": notEqualGreaterThan,
    336. 

  336.          "NaN": notEqualIncomparable,
    337. 

  337.          "{}": notEqualIncomparable,
    338. 

  338.          "{ valueOf: undefined }": notEqualIncomparable,
    339. 

  339.          "[]": notEqualNorDifferent,
    340. 

  340.          '[""]': notEqualNorDifferent,
    341. 

  341.          '["a"]': notEqualIncomparable,
    342. 

  342.          "[0]": notEqualNorDifferent
    343. 

  343.        },
    344. 

  344.      "true":
    345. 

  345.        {
    346. 

  346.          "undefined": notEqualIncomparable,
    347. 

  347.          "null": notEqualGreaterThan,
    348. 

  348.          "true": strictlyEqual,
    349. 

  349.          "false": notEqualGreaterThan,
    350. 

  350.          '""': notEqualGreaterThan,
    351. 

  351.          '"a"': notEqualIncomparable,
    352. 

  352.          '"Z"': notEqualIncomparable,
    353. 

  353.          "0": notEqualGreaterThan,
    354. 

  354.          "-0": notEqualGreaterThan,
    355. 

  355.          "1": looselyEqual,
    356. 

  356.          "Math.E": notEqualLessThan,
    357. 

  357.          "JSVAL_INT_MIN - 1": notEqualGreaterThan,
    358. 

  358.          "JSVAL_INT_MIN": notEqualGreaterThan,
    359. 

  359.          "JSVAL_INT_MIN + 1": notEqualGreaterThan,
    360. 

  360.          "JSVAL_INT_MAX - 1": notEqualLessThan,
    361. 

  361.          "JSVAL_INT_MAX": notEqualLessThan,
    362. 

  362.          "JSVAL_INT_MAX + 1": notEqualLessThan,
    363. 

  363.          "Infinity": notEqualLessThan,
    364. 

  364.          "-Infinity": notEqualGreaterThan,
    365. 

  365.          "NaN": notEqualIncomparable,
    366. 

  366.          "{}": notEqualIncomparable,
    367. 

  367.          "{ valueOf: undefined }": notEqualIncomparable,
    368. 

  368.          "[]": notEqualGreaterThan,
    369. 

  369.          '[""]': notEqualGreaterThan,
    370. 

  370.          '["a"]': notEqualIncomparable,
    371. 

  371.          "[0]": notEqualGreaterThan
    372. 

  372.        },
    373. 

  373.      "false":
    374. 

  374.        {
    375. 

  375.          "undefined": notEqualIncomparable,
    376. 

  376.          "null": notEqualNorDifferent,
    377. 

  377.          "true": notEqualLessThan,
    378. 

  378.          "false": strictlyEqual,
    379. 

  379.          '""': looselyEqualNotDifferent,
    380. 

  380.          '"a"': notEqualIncomparable,
    381. 

  381.          '"Z"': notEqualIncomparable,
    382. 

  382.          "0": looselyEqual,
    383. 

  383.          "-0": looselyEqual,
    384. 

  384.          "1": notEqualLessThan,
    385. 

  385.          "Math.E": notEqualLessThan,
    386. 

  386.          "JSVAL_INT_MIN - 1": notEqualGreaterThan,
    387. 

  387.          "JSVAL_INT_MIN": notEqualGreaterThan,
    388. 

  388.          "JSVAL_INT_MIN + 1": notEqualGreaterThan,
    389. 

  389.          "JSVAL_INT_MAX - 1": notEqualLessThan,
    390. 

  390.          "JSVAL_INT_MAX": notEqualLessThan,
    391. 

  391.          "JSVAL_INT_MAX + 1": notEqualLessThan,
    392. 

  392.          "Infinity": notEqualLessThan,
    393. 

  393.          "-Infinity": notEqualGreaterThan,
    394. 

  394.          "NaN": notEqualIncomparable,
    395. 

  395.          "{}": notEqualIncomparable,
    396. 

  396.          "{ valueOf: undefined }": notEqualIncomparable,
    397. 

  397.          "[]": looselyEqual,
    398. 

  398.          '[""]': looselyEqual,
    399. 

  399.          '["a"]': notEqualIncomparable,
    400. 

  400.          "[0]": looselyEqual
    401. 

  401.        },
    402. 

  402.      '""':
    403. 

  403.        {
    404. 

  404.          "undefined": notEqualIncomparable,
    405. 

  405.          "null": notEqualNorDifferent,
    406. 

  406.          "true": notEqualLessThan,
    407. 

  407.          "false": looselyEqual,
    408. 

  408.          '""': strictlyEqual,
    409. 

  409.          '"a"': notEqualLessThan,
    410. 

  410.          '"Z"': notEqualLessThan,
    411. 

  411.          "0": looselyEqual,
    412. 

  412.          "-0": looselyEqual,
    413. 

  413.          "1": notEqualLessThan,
    414. 

  414.          "Math.E": notEqualLessThan,
    415. 

  415.          "JSVAL_INT_MIN - 1": notEqualGreaterThan,
    416. 

  416.          "JSVAL_INT_MIN": notEqualGreaterThan,
    417. 

  417.          "JSVAL_INT_MIN + 1": notEqualGreaterThan,
    418. 

  418.          "JSVAL_INT_MAX - 1": notEqualLessThan,
    419. 

  419.          "JSVAL_INT_MAX": notEqualLessThan,
    420. 

  420.          "JSVAL_INT_MAX + 1": notEqualLessThan,
    421. 

  421.          "Infinity": notEqualLessThan,
    422. 

  422.          "-Infinity": notEqualGreaterThan,
    423. 

  423.          "NaN": notEqualIncomparable,
    424. 

  424.          "{}": notEqualLessThan,
    425. 

  425.          "{ valueOf: undefined }": notEqualLessThan,
    426. 

  426.          "[]": looselyEqual,
    427. 

  427.          '[""]': looselyEqual,
    428. 

  428.          '["a"]': notEqualLessThan,
    429. 

  429.          "[0]": notEqualLessThan
    430. 

  430.        },
    431. 

  431.      '"a"':
    432. 

  432.        {
    433. 

  433.          "undefined": notEqualIncomparable,
    434. 

  434.          "null": notEqualIncomparable,
    435. 

  435.          "true": notEqualIncomparable,
    436. 

  436.          "false": notEqualIncomparable,
    437. 

  437.          '""': notEqualGreaterThan,
    438. 

  438.          '"a"': strictlyEqual,
    439. 

  439.          '"Z"': notEqualGreaterThan,
    440. 

  440.          "0": notEqualIncomparable,
    441. 

  441.          "-0": notEqualIncomparable,
    442. 

  442.          "1": notEqualIncomparable,
    443. 

  443.          "Math.E": notEqualIncomparable,
    444. 

  444.          "JSVAL_INT_MIN - 1": notEqualIncomparable,
    445. 

  445.          "JSVAL_INT_MIN": notEqualIncomparable,
    446. 

  446.          "JSVAL_INT_MIN + 1": notEqualIncomparable,
    447. 

  447.          "JSVAL_INT_MAX - 1": notEqualIncomparable,
    448. 

  448.          "JSVAL_INT_MAX": notEqualIncomparable,
    449. 

  449.          "JSVAL_INT_MAX + 1": notEqualIncomparable,
    450. 

  450.          "Infinity": notEqualIncomparable,
    451. 

  451.          "-Infinity": notEqualIncomparable,
    452. 

  452.          "NaN": notEqualIncomparable,
    453. 

  453.          "{}": notEqualGreaterThan,
    454. 

  454.          "{ valueOf: undefined }": notEqualGreaterThan,
    455. 

  455.          "[]": notEqualGreaterThan,
    456. 

  456.          '[""]': notEqualGreaterThan,
    457. 

  457.          '["a"]': looselyEqualNotDifferent,
    458. 

  458.          "[0]": notEqualGreaterThan
    459. 

  459.        },
    460. 

  460.      '"Z"':
    461. 

  461.        {
    462. 

  462.          "undefined": notEqualIncomparable,
    463. 

  463.          "null": notEqualIncomparable,
    464. 

  464.          "true": notEqualIncomparable,
    465. 

  465.          "false": notEqualIncomparable,
    466. 

  466.          '""': notEqualGreaterThan,
    467. 

  467.          '"a"': notEqualLessThan,
    468. 

  468.          '"Z"': strictlyEqual,
    469. 

  469.          "0": notEqualIncomparable,
    470. 

  470.          "-0": notEqualIncomparable,
    471. 

  471.          "1": notEqualIncomparable,
    472. 

  472.          "Math.E": notEqualIncomparable,
    473. 

  473.          "JSVAL_INT_MIN - 1": notEqualIncomparable,
    474. 

  474.          "JSVAL_INT_MIN": notEqualIncomparable,
    475. 

  475.          "JSVAL_INT_MIN + 1": notEqualIncomparable,
    476. 

  476.          "JSVAL_INT_MAX - 1": notEqualIncomparable,
    477. 

  477.          "JSVAL_INT_MAX": notEqualIncomparable,
    478. 

  478.          "JSVAL_INT_MAX + 1": notEqualIncomparable,
    479. 

  479.          "Infinity": notEqualIncomparable,
    480. 

  480.          "-Infinity": notEqualIncomparable,
    481. 

  481.          "NaN": notEqualIncomparable,
    482. 

  482.          "{}": notEqualLessThan,
    483. 

  483.          "{ valueOf: undefined }": notEqualLessThan,
    484. 

  484.          "[]": notEqualGreaterThan,
    485. 

  485.          '[""]': notEqualGreaterThan,
    486. 

  486.          '["a"]': notEqualLessThan,
    487. 

  487.          "[0]": notEqualGreaterThan
    488. 

  488.        },
    489. 

  489.      "0": comparingZeroToSomething,
    490. 

  490.      "-0": comparingZeroToSomething,
    491. 

  491.      "1":
    492. 

  492.        {
    493. 

  493.          "undefined": notEqualIncomparable,
    494. 

  494.          "null": notEqualGreaterThan,
    495. 

  495.          "true": looselyEqual,
    496. 

  496.          "false": notEqualGreaterThan,
    497. 

  497.          '""': notEqualGreaterThan,
    498. 

  498.          '"a"': notEqualIncomparable,
    499. 

  499.          '"Z"': notEqualIncomparable,
    500. 

  500.          "0": notEqualGreaterThan,
    501. 

  501.          "-0": notEqualGreaterThan,
    502. 

  502.          "1": strictlyEqual,
    503. 

  503.          "Math.E": notEqualLessThan,
    504. 

  504.          "JSVAL_INT_MIN - 1": notEqualGreaterThan,
    505. 

  505.          "JSVAL_INT_MIN": notEqualGreaterThan,
    506. 

  506.          "JSVAL_INT_MIN + 1": notEqualGreaterThan,
    507. 

  507.          "JSVAL_INT_MAX - 1": notEqualLessThan,
    508. 

  508.          "JSVAL_INT_MAX": notEqualLessThan,
    509. 

  509.          "JSVAL_INT_MAX + 1": notEqualLessThan,
    510. 

  510.          "Infinity": notEqualLessThan,
    511. 

  511.          "-Infinity": notEqualGreaterThan,
    512. 

  512.          "NaN": notEqualIncomparable,
    513. 

  513.          "{}": notEqualIncomparable,
    514. 

  514.          "{ valueOf: undefined }": notEqualIncomparable,
    515. 

  515.          "[]": notEqualGreaterThan,
    516. 

  516.          '[""]': notEqualGreaterThan,
    517. 

  517.          '["a"]': notEqualIncomparable,
    518. 

  518.          "[0]": notEqualGreaterThan
    519. 

  519.        },
    520. 

  520.      "Math.E":
    521. 

  521.        {
    522. 

  522.          "undefined": notEqualIncomparable,
    523. 

  523.          "null": notEqualGreaterThan,
    524. 

  524.          "true": notEqualGreaterThan,
    525. 

  525.          "false": notEqualGreaterThan,
    526. 

  526.          '""': notEqualGreaterThan,
    527. 

  527.          '"a"': notEqualIncomparable,
    528. 

  528.          '"Z"': notEqualIncomparable,
    529. 

  529.          "0": notEqualGreaterThan,
    530. 

  530.          "-0": notEqualGreaterThan,
    531. 

  531.          "1": notEqualGreaterThan,
    532. 

  532.          "Math.E": strictlyEqual,
    533. 

  533.          "JSVAL_INT_MIN - 1": notEqualGreaterThan,
    534. 

  534.          "JSVAL_INT_MIN": notEqualGreaterThan,
    535. 

  535.          "JSVAL_INT_MIN + 1": notEqualGreaterThan,
    536. 

  536.          "JSVAL_INT_MAX - 1": notEqualLessThan,
    537. 

  537.          "JSVAL_INT_MAX": notEqualLessThan,
    538. 

  538.          "JSVAL_INT_MAX + 1": notEqualLessThan,
    539. 

  539.          "Infinity": notEqualLessThan,
    540. 

  540.          "-Infinity": notEqualGreaterThan,
    541. 

  541.          "NaN": notEqualIncomparable,
    542. 

  542.          "{}": notEqualIncomparable,
    543. 

  543.          "{ valueOf: undefined }": notEqualIncomparable,
    544. 

  544.          "[]": notEqualGreaterThan,
    545. 

  545.          '[""]': notEqualGreaterThan,
    546. 

  546.          '["a"]': notEqualIncomparable,
    547. 

  547.          "[0]": notEqualGreaterThan
    548. 

  548.        },
    549. 

  549.      "JSVAL_INT_MIN - 1":
    550. 

  550.        {
    551. 

  551.          "undefined": notEqualIncomparable,
    552. 

  552.          "null": notEqualLessThan,
    553. 

  553.          "true": notEqualLessThan,
    554. 

  554.          "false": notEqualLessThan,
    555. 

  555.          '""': notEqualLessThan,
    556. 

  556.          '"a"': notEqualIncomparable,
    557. 

  557.          '"Z"': notEqualIncomparable,
    558. 

  558.          "0": notEqualLessThan,
    559. 

  559.          "-0": notEqualLessThan,
    560. 

  560.          "1": notEqualLessThan,
    561. 

  561.          "Math.E": notEqualLessThan,
    562. 

  562.          "JSVAL_INT_MIN - 1": strictlyEqual,
    563. 

  563.          "JSVAL_INT_MIN": notEqualLessThan,
    564. 

  564.          "JSVAL_INT_MIN + 1": notEqualLessThan,
    565. 

  565.          "JSVAL_INT_MAX - 1": notEqualLessThan,
    566. 

  566.          "JSVAL_INT_MAX": notEqualLessThan,
    567. 

  567.          "JSVAL_INT_MAX + 1": notEqualLessThan,
    568. 

  568.          "Infinity": notEqualLessThan,
    569. 

  569.          "-Infinity": notEqualGreaterThan,
    570. 

  570.          "NaN": notEqualIncomparable,
    571. 

  571.          "{}": notEqualIncomparable,
    572. 

  572.          "{ valueOf: undefined }": notEqualIncomparable,
    573. 

  573.          "[]": notEqualLessThan,
    574. 

  574.          '[""]': notEqualLessThan,
    575. 

  575.          '["a"]': notEqualIncomparable,
    576. 

  576.          "[0]": notEqualLessThan
    577. 

  577.        },
    578. 

  578.      "JSVAL_INT_MIN":
    579. 

  579.        {
    580. 

  580.          "undefined": notEqualIncomparable,
    581. 

  581.          "null": notEqualLessThan,
    582. 

  582.          "true": notEqualLessThan,
    583. 

  583.          "false": notEqualLessThan,
    584. 

  584.          '""': notEqualLessThan,
    585. 

  585.          '"a"': notEqualIncomparable,
    586. 

  586.          '"Z"': notEqualIncomparable,
    587. 

  587.          "0": notEqualLessThan,
    588. 

  588.          "-0": notEqualLessThan,
    589. 

  589.          "1": notEqualLessThan,
    590. 

  590.          "Math.E": notEqualLessThan,
    591. 

  591.          "JSVAL_INT_MIN - 1": notEqualGreaterThan,
    592. 

  592.          "JSVAL_INT_MIN": strictlyEqual,
    593. 

  593.          "JSVAL_INT_MIN + 1": notEqualLessThan,
    594. 

  594.          "JSVAL_INT_MAX - 1": notEqualLessThan,
    595. 

  595.          "JSVAL_INT_MAX": notEqualLessThan,
    596. 

  596.          "JSVAL_INT_MAX + 1": notEqualLessThan,
    597. 

  597.          "Infinity": notEqualLessThan,
    598. 

  598.          "-Infinity": notEqualGreaterThan,
    599. 

  599.          "NaN": notEqualIncomparable,
    600. 

  600.          "{}": notEqualIncomparable,
    601. 

  601.          "{ valueOf: undefined }": notEqualIncomparable,
    602. 

  602.          "[]": notEqualLessThan,
    603. 

  603.          '[""]': notEqualLessThan,
    604. 

  604.          '["a"]': notEqualIncomparable,
    605. 

  605.          "[0]": notEqualLessThan
    606. 

  606.        },
    607. 

  607.      "JSVAL_INT_MIN + 1":
    608. 

  608.        {
    609. 

  609.          "undefined": notEqualIncomparable,
    610. 

  610.          "null": notEqualLessThan,
    611. 

  611.          "true": notEqualLessThan,
    612. 

  612.          "false": notEqualLessThan,
    613. 

  613.          '""': notEqualLessThan,
    614. 

  614.          '"a"': notEqualIncomparable,
    615. 

  615.          '"Z"': notEqualIncomparable,
    616. 

  616.          "0": notEqualLessThan,
    617. 

  617.          "-0": notEqualLessThan,
    618. 

  618.          "1": notEqualLessThan,
    619. 

  619.          "Math.E": notEqualLessThan,
    620. 

  620.          "JSVAL_INT_MIN - 1": notEqualGreaterThan,
    621. 

  621.          "JSVAL_INT_MIN": notEqualGreaterThan,
    622. 

  622.          "JSVAL_INT_MIN + 1": strictlyEqual,
    623. 

  623.          "JSVAL_INT_MAX - 1": notEqualLessThan,
    624. 

  624.          "JSVAL_INT_MAX": notEqualLessThan,
    625. 

  625.          "JSVAL_INT_MAX + 1": notEqualLessThan,
    626. 

  626.          "Infinity": notEqualLessThan,
    627. 

  627.          "-Infinity": notEqualGreaterThan,
    628. 

  628.          "NaN": notEqualIncomparable,
    629. 

  629.          "{}": notEqualIncomparable,
    630. 

  630.          "{ valueOf: undefined }": notEqualIncomparable,
    631. 

  631.          "[]": notEqualLessThan,
    632. 

  632.          '[""]': notEqualLessThan,
    633. 

  633.          '["a"]': notEqualIncomparable,
    634. 

  634.          "[0]": notEqualLessThan
    635. 

  635.        },
    636. 

  636.      "JSVAL_INT_MAX - 1":
    637. 

  637.        {
    638. 

  638.          "undefined": notEqualIncomparable,
    639. 

  639.          "null": notEqualGreaterThan,
    640. 

  640.          "true": notEqualGreaterThan,
    641. 

  641.          "false": notEqualGreaterThan,
    642. 

  642.          '""': notEqualGreaterThan,
    643. 

  643.          '"a"': notEqualIncomparable,
    644. 

  644.          '"Z"': notEqualIncomparable,
    645. 

  645.          "0": notEqualGreaterThan,
    646. 

  646.          "-0": notEqualGreaterThan,
    647. 

  647.          "1": notEqualGreaterThan,
    648. 

  648.          "Math.E": notEqualGreaterThan,
    649. 

  649.          "JSVAL_INT_MIN - 1": notEqualGreaterThan,
    650. 

  650.          "JSVAL_INT_MIN": notEqualGreaterThan,
    651. 

  651.          "JSVAL_INT_MIN + 1": notEqualGreaterThan,
    652. 

  652.          "JSVAL_INT_MAX - 1": strictlyEqual,
    653. 

  653.          "JSVAL_INT_MAX": notEqualLessThan,
    654. 

  654.          "JSVAL_INT_MAX + 1": notEqualLessThan,
    655. 

  655.          "Infinity": notEqualLessThan,
    656. 

  656.          "-Infinity": notEqualGreaterThan,
    657. 

  657.          "NaN": notEqualIncomparable,
    658. 

  658.          "{}": notEqualIncomparable,
    659. 

  659.          "{ valueOf: undefined }": notEqualIncomparable,
    660. 

  660.          "[]": notEqualGreaterThan,
    661. 

  661.          '[""]': notEqualGreaterThan,
    662. 

  662.          '["a"]': notEqualIncomparable,
    663. 

  663.          "[0]": notEqualGreaterThan
    664. 

  664.        },
    665. 

  665.      "JSVAL_INT_MAX":
    666. 

  666.        {
    667. 

  667.          "undefined": notEqualIncomparable,
    668. 

  668.          "null": notEqualGreaterThan,
    669. 

  669.          "true": notEqualGreaterThan,
    670. 

  670.          "false": notEqualGreaterThan,
    671. 

  671.          '""': notEqualGreaterThan,
    672. 

  672.          '"a"': notEqualIncomparable,
    673. 

  673.          '"Z"': notEqualIncomparable,
    674. 

  674.          "0": notEqualGreaterThan,
    675. 

  675.          "-0": notEqualGreaterThan,
    676. 

  676.          "1": notEqualGreaterThan,
    677. 

  677.          "Math.E": notEqualGreaterThan,
    678. 

  678.          "JSVAL_INT_MIN - 1": notEqualGreaterThan,
    679. 

  679.          "JSVAL_INT_MIN": notEqualGreaterThan,
    680. 

  680.          "JSVAL_INT_MIN + 1": notEqualGreaterThan,
    681. 

  681.          "JSVAL_INT_MAX - 1": notEqualGreaterThan,
    682. 

  682.          "JSVAL_INT_MAX": strictlyEqual,
    683. 

  683.          "JSVAL_INT_MAX + 1": notEqualLessThan,
    684. 

  684.          "Infinity": notEqualLessThan,
    685. 

  685.          "-Infinity": notEqualGreaterThan,
    686. 

  686.          "NaN": notEqualIncomparable,
    687. 

  687.          "{}": notEqualIncomparable,
    688. 

  688.          "{ valueOf: undefined }": notEqualIncomparable,
    689. 

  689.          "[]": notEqualGreaterThan,
    690. 

  690.          '[""]': notEqualGreaterThan,
    691. 

  691.          '["a"]': notEqualIncomparable,
    692. 

  692.          "[0]": notEqualGreaterThan
    693. 

  693.        },
    694. 

  694.      "JSVAL_INT_MAX + 1":
    695. 

  695.        {
    696. 

  696.          "undefined": notEqualIncomparable,
    697. 

  697.          "null": notEqualGreaterThan,
    698. 

  698.          "true": notEqualGreaterThan,
    699. 

  699.          "false": notEqualGreaterThan,
    700. 

  700.          '""': notEqualGreaterThan,
    701. 

  701.          '"a"': notEqualIncomparable,
    702. 

  702.          '"Z"': notEqualIncomparable,
    703. 

  703.          "0": notEqualGreaterThan,
    704. 

  704.          "-0": notEqualGreaterThan,
    705. 

  705.          "1": notEqualGreaterThan,
    706. 

  706.          "Math.E": notEqualGreaterThan,
    707. 

  707.          "JSVAL_INT_MIN - 1": notEqualGreaterThan,
    708. 

  708.          "JSVAL_INT_MIN": notEqualGreaterThan,
    709. 

  709.          "JSVAL_INT_MIN + 1": notEqualGreaterThan,
    710. 

  710.          "JSVAL_INT_MAX - 1": notEqualGreaterThan,
    711. 

  711.          "JSVAL_INT_MAX": notEqualGreaterThan,
    712. 

  712.          "JSVAL_INT_MAX + 1": strictlyEqual,
    713. 

  713.          "Infinity": notEqualLessThan,
    714. 

  714.          "-Infinity": notEqualGreaterThan,
    715. 

  715.          "NaN": notEqualIncomparable,
    716. 

  716.          "{}": notEqualIncomparable,
    717. 

  717.          "{ valueOf: undefined }": notEqualIncomparable,
    718. 

  718.          "[]": notEqualGreaterThan,
    719. 

  719.          '[""]': notEqualGreaterThan,
    720. 

  720.          '["a"]': notEqualIncomparable,
    721. 

  721.          "[0]": notEqualGreaterThan
    722. 

  722.        },
    723. 

  723.      "Infinity":
    724. 

  724.        {
    725. 

  725.          "undefined": notEqualIncomparable,
    726. 

  726.          "null": notEqualGreaterThan,
    727. 

  727.          "true": notEqualGreaterThan,
    728. 

  728.          "false": notEqualGreaterThan,
    729. 

  729.          '""': notEqualGreaterThan,
    730. 

  730.          '"a"': notEqualIncomparable,
    731. 

  731.          '"Z"': notEqualIncomparable,
    732. 

  732.          "0": notEqualGreaterThan,
    733. 

  733.          "-0": notEqualGreaterThan,
    734. 

  734.          "1": notEqualGreaterThan,
    735. 

  735.          "Math.E": notEqualGreaterThan,
    736. 

  736.          "JSVAL_INT_MIN - 1": notEqualGreaterThan,
    737. 

  737.          "JSVAL_INT_MIN": notEqualGreaterThan,
    738. 

  738.          "JSVAL_INT_MIN + 1": notEqualGreaterThan,
    739. 

  739.          "JSVAL_INT_MAX - 1": notEqualGreaterThan,
    740. 

  740.          "JSVAL_INT_MAX": notEqualGreaterThan,
    741. 

  741.          "JSVAL_INT_MAX + 1": notEqualGreaterThan,
    742. 

  742.          "Infinity": strictlyEqual,
    743. 

  743.          "-Infinity": notEqualGreaterThan,
    744. 

  744.          "NaN": notEqualIncomparable,
    745. 

  745.          "{}": notEqualIncomparable,
    746. 

  746.          "{ valueOf: undefined }": notEqualIncomparable,
    747. 

  747.          "[]": notEqualGreaterThan,
    748. 

  748.          '[""]': notEqualGreaterThan,
    749. 

  749.          '["a"]': notEqualIncomparable,
    750. 

  750.          "[0]": notEqualGreaterThan
    751. 

  751.        },
    752. 

  752.      "-Infinity":
    753. 

  753.        {
    754. 

  754.          "undefined": notEqualIncomparable,
    755. 

  755.          "null": notEqualLessThan,
    756. 

  756.          "true": notEqualLessThan,
    757. 

  757.          "false": notEqualLessThan,
    758. 

  758.          '""': notEqualLessThan,
    759. 

  759.          '"a"': notEqualIncomparable,
    760. 

  760.          '"Z"': notEqualIncomparable,
    761. 

  761.          "0": notEqualLessThan,
    762. 

  762.          "-0": notEqualLessThan,
    763. 

  763.          "1": notEqualLessThan,
    764. 

  764.          "Math.E": notEqualLessThan,
    765. 

  765.          "JSVAL_INT_MIN - 1": notEqualLessThan,
    766. 

  766.          "JSVAL_INT_MIN": notEqualLessThan,
    767. 

  767.          "JSVAL_INT_MIN + 1": notEqualLessThan,
    768. 

  768.          "JSVAL_INT_MAX - 1": notEqualLessThan,
    769. 

  769.          "JSVAL_INT_MAX": notEqualLessThan,
    770. 

  770.          "JSVAL_INT_MAX + 1": notEqualLessThan,
    771. 

  771.          "Infinity": notEqualLessThan,
    772. 

  772.          "-Infinity": strictlyEqual,
    773. 

  773.          "NaN": notEqualIncomparable,
    774. 

  774.          "{}": notEqualIncomparable,
    775. 

  775.          "{ valueOf: undefined }": notEqualIncomparable,
    776. 

  776.          "[]": notEqualLessThan,
    777. 

  777.          '[""]': notEqualLessThan,
    778. 

  778.          '["a"]': notEqualIncomparable,
    779. 

  779.          "[0]": notEqualLessThan
    780. 

  780.        },
    781. 

  781.      "NaN":
    782. 

  782.        {
    783. 

  783.          "undefined": notEqualIncomparable,
    784. 

  784.          "null": notEqualIncomparable,
    785. 

  785.          "true": notEqualIncomparable,
    786. 

  786.          "false": notEqualIncomparable,
    787. 

  787.          '""': notEqualIncomparable,
    788. 

  788.          '"a"': notEqualIncomparable,
    789. 

  789.          '"Z"': notEqualIncomparable,
    790. 

  790.          "0": notEqualIncomparable,
    791. 

  791.          "-0": notEqualIncomparable,
    792. 

  792.          "1": notEqualIncomparable,
    793. 

  793.          "Math.E": notEqualIncomparable,
    794. 

  794.          "JSVAL_INT_MIN - 1": notEqualIncomparable,
    795. 

  795.          "JSVAL_INT_MIN": notEqualIncomparable,
    796. 

  796.          "JSVAL_INT_MIN + 1": notEqualIncomparable,
    797. 

  797.          "JSVAL_INT_MAX - 1": notEqualIncomparable,
    798. 

  798.          "JSVAL_INT_MAX": notEqualIncomparable,
    799. 

  799.          "JSVAL_INT_MAX + 1": notEqualIncomparable,
    800. 

  800.          "Infinity": notEqualIncomparable,
    801. 

  801.          "-Infinity": notEqualIncomparable,
    802. 

  802.          "NaN": notEqualIncomparable,
    803. 

  803.          "{}": notEqualIncomparable,
    804. 

  804.          "{ valueOf: undefined }": notEqualIncomparable,
    805. 

  805.          "[]": notEqualIncomparable,
    806. 

  806.          '[""]': notEqualIncomparable,
    807. 

  807.          '["a"]': notEqualIncomparable,
    808. 

  808.          "[0]": notEqualIncomparable
    809. 

  809.        },
    810. 

  810.      "{}": comparingObjectOrObjectWithValueUndefined,
    811. 

  811.      "{ valueOf: undefined }": comparingObjectOrObjectWithValueUndefined,
    812. 

  812.      "[]":
    813. 

  813.        {
    814. 

  814.          "undefined": notEqualIncomparable,
    815. 

  815.          "null": notEqualNorDifferent,
    816. 

  816.          "true": notEqualLessThan,
    817. 

  817.          "false": looselyEqual,
    818. 

  818.          '""': looselyEqual,
    819. 

  819.          '"a"': notEqualLessThan,
    820. 

  820.          '"Z"': notEqualLessThan,
    821. 

  821.          "0": looselyEqual,
    822. 

  822.          "-0": looselyEqual,
    823. 

  823.          "1": notEqualLessThan,
    824. 

  824.          "Math.E": notEqualLessThan,
    825. 

  825.          "JSVAL_INT_MIN - 1": notEqualGreaterThan,
    826. 

  826.          "JSVAL_INT_MIN": notEqualGreaterThan,
    827. 

  827.          "JSVAL_INT_MIN + 1": notEqualGreaterThan,
    828. 

  828.          "JSVAL_INT_MAX - 1": notEqualLessThan,
    829. 

  829.          "JSVAL_INT_MAX": notEqualLessThan,
    830. 

  830.          "JSVAL_INT_MAX + 1": notEqualLessThan,
    831. 

  831.          "Infinity": notEqualLessThan,
    832. 

  832.          "-Infinity": notEqualGreaterThan,
    833. 

  833.          "NaN": notEqualIncomparable,
    834. 

  834.          "{}": notEqualLessThan,
    835. 

  835.          "{ valueOf: undefined }": notEqualLessThan,
    836. 

  836.          "[]": notEqualNorDifferent,
    837. 

  837.          '[""]': notEqualNorDifferent,
    838. 

  838.          '["a"]': notEqualLessThan,
    839. 

  839.          "[0]": notEqualLessThan
    840. 

  840.        },
    841. 

  841.      '[""]':
    842. 

  842.        {
    843. 

  843.          "undefined": notEqualIncomparable,
    844. 

  844.          "null": notEqualNorDifferent,
    845. 

  845.          "true": notEqualLessThan,
    846. 

  846.          "false": looselyEqual,
    847. 

  847.          '""': looselyEqual,
    848. 

  848.          '"a"': notEqualLessThan,
    849. 

  849.          '"Z"': notEqualLessThan,
    850. 

  850.          "0": looselyEqual,
    851. 

  851.          "-0": looselyEqual,
    852. 

  852.          "1": notEqualLessThan,
    853. 

  853.          "Math.E": notEqualLessThan,
    854. 

  854.          "JSVAL_INT_MIN - 1": notEqualGreaterThan,
    855. 

  855.          "JSVAL_INT_MIN": notEqualGreaterThan,
    856. 

  856.          "JSVAL_INT_MIN + 1": notEqualGreaterThan,
    857. 

  857.          "JSVAL_INT_MAX - 1": notEqualLessThan,
    858. 

  858.          "JSVAL_INT_MAX": notEqualLessThan,
    859. 

  859.          "JSVAL_INT_MAX + 1": notEqualLessThan,
    860. 

  860.          "Infinity": notEqualLessThan,
    861. 

  861.          "-Infinity": notEqualGreaterThan,
    862. 

  862.          "NaN": notEqualIncomparable,
    863. 

  863.          "{}": notEqualLessThan,
    864. 

  864.          "{ valueOf: undefined }": notEqualLessThan,
    865. 

  865.          "[]": notEqualNorDifferent,
    866. 

  866.          '[""]': notEqualNorDifferent,
    867. 

  867.          '["a"]': notEqualLessThan,
    868. 

  868.          "[0]": notEqualLessThan
    869. 

  869.        },
    870. 

  870.      '["a"]':
    871. 

  871.        {
    872. 

  872.          "undefined": notEqualIncomparable,
    873. 

  873.          "null": notEqualIncomparable,
    874. 

  874.          "true": notEqualIncomparable,
    875. 

  875.          "false": notEqualIncomparable,
    876. 

  876.          '""': notEqualGreaterThan,
    877. 

  877.          '"a"': looselyEqual,
    878. 

  878.          '"Z"': notEqualGreaterThan,
    879. 

  879.          "0": notEqualIncomparable,
    880. 

  880.          "-0": notEqualIncomparable,
    881. 

  881.          "1": notEqualIncomparable,
    882. 

  882.          "Math.E": notEqualIncomparable,
    883. 

  883.          "JSVAL_INT_MIN - 1": notEqualIncomparable,
    884. 

  884.          "JSVAL_INT_MIN": notEqualIncomparable,
    885. 

  885.          "JSVAL_INT_MIN + 1": notEqualIncomparable,
    886. 

  886.          "JSVAL_INT_MAX - 1": notEqualIncomparable,
    887. 

  887.          "JSVAL_INT_MAX": notEqualIncomparable,
    888. 

  888.          "JSVAL_INT_MAX + 1": notEqualIncomparable,
    889. 

  889.          "Infinity": notEqualIncomparable,
    890. 

  890.          "-Infinity": notEqualIncomparable,
    891. 

  891.          "NaN": notEqualIncomparable,
    892. 

  892.          "{}": notEqualGreaterThan,
    893. 

  893.          "{ valueOf: undefined }": notEqualGreaterThan,
    894. 

  894.          "[]": notEqualGreaterThan,
    895. 

  895.          '[""]': notEqualGreaterThan,
    896. 

  896.          '["a"]': notEqualNorDifferent,
    897. 

  897.          "[0]": notEqualGreaterThan
    898. 

  898.        },
    899. 

  899.      "[0]":
    900. 

  900.        {
    901. 

  901.          "undefined": notEqualIncomparable,
    902. 

  902.          "null": notEqualNorDifferent,
    903. 

  903.          "true": notEqualLessThan,
    904. 

  904.          "false": looselyEqual,
    905. 

  905.          '""': notEqualGreaterThan,
    906. 

  906.          '"a"': notEqualLessThan,
    907. 

  907.          '"Z"': notEqualLessThan,
    908. 

  908.          "0": looselyEqual,
    909. 

  909.          "-0": looselyEqual,
    910. 

  910.          "1": notEqualLessThan,
    911. 

  911.          "Math.E": notEqualLessThan,
    912. 

  912.          "JSVAL_INT_MIN - 1": notEqualGreaterThan,
    913. 

  913.          "JSVAL_INT_MIN": notEqualGreaterThan,
    914. 

  914.          "JSVAL_INT_MIN + 1": notEqualGreaterThan,
    915. 

  915.          "JSVAL_INT_MAX - 1": notEqualLessThan,
    916. 

  916.          "JSVAL_INT_MAX": notEqualLessThan,
    917. 

  917.          "JSVAL_INT_MAX + 1": notEqualLessThan,
    918. 

  918.          "Infinity": notEqualLessThan,
    919. 

  919.          "-Infinity": notEqualGreaterThan,
    920. 

  920.          "NaN": notEqualIncomparable,
    921. 

  921.          "{}": notEqualLessThan,
    922. 

  922.          "{ valueOf: undefined }": notEqualLessThan,
    923. 

  923.          "[]": notEqualGreaterThan,
    924. 

  924.          '[""]': notEqualGreaterThan,
    925. 

  925.          '["a"]': notEqualLessThan,
    926. 

  926.          "[0]": notEqualNorDifferent
    927. 

  927.        }
    928. 

  928.     };
    929. 

  929. 

  930. 

  931. 

  932.   var failures = [];
    933. 

  933.   function fail(a, ta, b, tb, ex, ac, op)
    934. 

  934.   {
    935. 

  935.     failures.push("(" + a + " " + op + " " + b + ") wrong: " +
    936. 

  936.                   "expected " + ex + ", got " + ac +
    937. 

  937.                   " (types " + types[ta] + ", " + types[tb] + ")");
    938. 

  938.   }
    939. 

  939. 

  940.   var result = false;
    941. 

  941.   for (var i in values)
    942. 

  942.   {
    943. 

  943.     for (var j in values)
    944. 

  944.     {
    945. 

  945.       // Constants, so hoist to help JIT know that
    946. 

  946.       var vala = values[i], valb = values[j];
    947. 

  947.       var a = vala.value(), b = valb.value();
    948. 

  948. 

  949.       for (var opname in orderOps)
    950. 

  950.       {
    951. 

  951.         var op = orderOps[opname];
    952. 

  952.         var expect = expected[i][j].order[opname];
    953. 

  953.         var failed = false;
    954. 

  954. 

  955.         for (var iter = 0; iter < 5; iter++)
    956. 

  956.         {
    957. 

  957.           result = op(a, b);
    958. 

  958.           failed = failed || result !== expect;
    959. 

  959.         }
    960. 

  960. 

  961.         if (failed)
    962. 

  962.           fail(i, vala.type, j, valb.type, expect, result, opname);
    963. 

  963.       }
    964. 

  964. 

  965.       for (var opname in eqOps)
    966. 

  966.       {
    967. 

  967.         var op = eqOps[opname];
    968. 

  968.         var expect = expected[i][j].eq[opname];
    969. 

  969.         var failed = false;
    970. 

  970. 

  971.         for (var iter = 0; iter < 5; iter++)
    972. 

  972.         {
    973. 

  973.           result = op(a, b);
    974. 

  974.           failed = failed || result !== expect;
    975. 

  975.         }
    976. 

  976. 

  977.         if (failed)
    978. 

  978.           fail(i, vala.type, j, valb.type, expect, result, opname);
    979. 

  979.       }
    980. 

  980.     }
    981. 

  981.   }
    982. 

  982. 

  983.   if (failures.length == 0)
    984. 

  984.     return "no failures reported!";
    985. 

  985. 

  986.   return "\n" + failures.join(",\n");
    987. 

  987. }
    988. 

  988. assertEq(testComparisons(), "no failures reported!");
    989.