OLD | NEW |
(Empty) | |
| 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 define([ |
| 6 "gin/test/expect", |
| 7 "mojo/public/js/bindings/buffer", |
| 8 "mojo/public/js/bindings/tests/validation_test_input_parser" |
| 9 ], function(expect, buffer, parser) { |
| 10 |
| 11 function checkTestMessageParser() { |
| 12 function TestMessageParserFailure(message, input) { |
| 13 this.message = message; |
| 14 this.input = input; |
| 15 } |
| 16 |
| 17 TestMessageParserFailure.prototype.toString = function() { |
| 18 return 'Error: ' + this.message + ' for "' + this.input + '"'; |
| 19 } |
| 20 |
| 21 function checkData(data, expectedData, input) { |
| 22 if (data.byteLength != expectedData.byteLength) { |
| 23 var s = "message length (" + data.byteLength + ") doesn't match " + |
| 24 "expected length: " + expectedData.byteLength; |
| 25 throw new TestMessageParserFailure(s, input); |
| 26 } |
| 27 |
| 28 for (var i = 0; i < data.byteLength; i++) { |
| 29 if (data.getUint8(i) != expectedData.getUint8(i)) { |
| 30 var s = 'message data mismatch at byte offset ' + i; |
| 31 throw new TestMessageParserFailure(s, input); |
| 32 } |
| 33 } |
| 34 } |
| 35 |
| 36 function testFloatItems() { |
| 37 var input = '[f]+.3e9 [d]-10.03'; |
| 38 var msg = parser.parseTestMessage(input); |
| 39 var expectedData = new buffer.Buffer(12); |
| 40 expectedData.setFloat32(0, +.3e9); |
| 41 expectedData.setFloat64(4, -10.03); |
| 42 checkData(msg.buffer, expectedData, input); |
| 43 } |
| 44 |
| 45 function testUnsignedIntegerItems() { |
| 46 var input = '[u1]0x10// hello world !! \n\r \t [u2]65535 \n' + |
| 47 '[u4]65536 [u8]0xFFFFFFFFFFFFF 0 0Xff'; |
| 48 var msg = parser.parseTestMessage(input); |
| 49 var expectedData = new buffer.Buffer(17); |
| 50 expectedData.setUint8(0, 0x10); |
| 51 expectedData.setUint16(1, 65535); |
| 52 expectedData.setUint32(3, 65536); |
| 53 expectedData.setUint64(7, 0xFFFFFFFFFFFFF); |
| 54 expectedData.setUint8(15, 0); |
| 55 expectedData.setUint8(16, 0xff); |
| 56 checkData(msg.buffer, expectedData, input); |
| 57 } |
| 58 |
| 59 function testSignedIntegerItems() { |
| 60 var input = '[s8]-0x800 [s1]-128\t[s2]+0 [s4]-40'; |
| 61 var msg = parser.parseTestMessage(input); |
| 62 var expectedData = new buffer.Buffer(15); |
| 63 expectedData.setInt64(0, -0x800); |
| 64 expectedData.setInt8(8, -128); |
| 65 expectedData.setInt16(9, 0); |
| 66 expectedData.setInt32(11, -40); |
| 67 checkData(msg.buffer, expectedData, input); |
| 68 } |
| 69 |
| 70 function testByteItems() { |
| 71 var input = '[b]00001011 [b]10000000 // hello world\n [b]00000000'; |
| 72 var msg = parser.parseTestMessage(input); |
| 73 var expectedData = new buffer.Buffer(3); |
| 74 expectedData.setUint8(0, 11); |
| 75 expectedData.setUint8(1, 128); |
| 76 expectedData.setUint8(2, 0); |
| 77 checkData(msg.buffer, expectedData, input); |
| 78 } |
| 79 |
| 80 function testAnchors() { |
| 81 var input = '[dist4]foo 0 [dist8]bar 0 [anchr]foo [anchr]bar'; |
| 82 var msg = parser.parseTestMessage(input); |
| 83 var expectedData = new buffer.Buffer(14); |
| 84 expectedData.setUint32(0, 14); |
| 85 expectedData.setUint8(4, 0); |
| 86 expectedData.setUint64(5, 9); |
| 87 expectedData.setUint8(13, 0); |
| 88 checkData(msg.buffer, expectedData, input); |
| 89 } |
| 90 |
| 91 function testHandles() { |
| 92 var input = '// This message has handles! \n[handles]50 [u8]2'; |
| 93 var msg = parser.parseTestMessage(input); |
| 94 var expectedData = new buffer.Buffer(8); |
| 95 expectedData.setUint64(0, 2); |
| 96 |
| 97 if (msg.handleCount != 50) { |
| 98 var s = 'wrong handle count (' + msg.handleCount + ')'; |
| 99 throw new TestMessageParserFailure(s, input); |
| 100 } |
| 101 checkData(msg.buffer, expectedData, input); |
| 102 } |
| 103 |
| 104 function testEmptyInput() { |
| 105 var msg = parser.parseTestMessage(''); |
| 106 if (msg.buffer.byteLength != 0) |
| 107 throw new TestMessageParserFailure('expected empty message', ''); |
| 108 } |
| 109 |
| 110 function testBlankInput() { |
| 111 var input = ' \t // hello world \n\r \t// the answer is 42 '; |
| 112 var msg = parser.parseTestMessage(input); |
| 113 if (msg.buffer.byteLength != 0) |
| 114 throw new TestMessageParserFailure('expected empty message', input); |
| 115 } |
| 116 |
| 117 function testInvalidInput() { |
| 118 function parserShouldFail(input) { |
| 119 try { |
| 120 parser.parseTestMessage(input); |
| 121 } catch (e) { |
| 122 if (e instanceof parser.InputError) |
| 123 return; |
| 124 throw new TestMessageParserFailure( |
| 125 'unexpected exception ' + e.toString(), input); |
| 126 } |
| 127 throw new TestMessageParserFailure("didn't detect invalid input", file); |
| 128 } |
| 129 |
| 130 ['/ hello world', |
| 131 '[u1]x', |
| 132 '[u2]-1000', |
| 133 '[u1]0x100', |
| 134 '[s2]-0x8001', |
| 135 '[b]1', |
| 136 '[b]1111111k', |
| 137 '[dist4]unmatched', |
| 138 '[anchr]hello [dist8]hello', |
| 139 '[dist4]a [dist4]a [anchr]a', |
| 140 // '[dist4]a [anchr]a [dist4]a [anchr]a', |
| 141 '0 [handles]50' |
| 142 ].forEach(parserShouldFail); |
| 143 } |
| 144 |
| 145 try { |
| 146 testFloatItems(); |
| 147 testUnsignedIntegerItems(); |
| 148 testSignedIntegerItems(); |
| 149 testByteItems(); |
| 150 testInvalidInput(); |
| 151 testEmptyInput(); |
| 152 testBlankInput(); |
| 153 testHandles(); |
| 154 testAnchors(); |
| 155 } catch (e) { |
| 156 return e.toString(); |
| 157 } |
| 158 return null; |
| 159 } |
| 160 |
| 161 expect(checkTestMessageParser()).toBeNull(); |
| 162 this.result = "PASS"; |
| 163 }); |
OLD | NEW |