Lines Matching refs:assert
3585 var assert = function assert(test, message) {
3591 assert(table.ref, 'Table must have ref');
3592 assert(table.columns, 'Table must have column definitions');
3593 assert(table.rows, 'Table must have row definitions');
3598 assert(row > 0, 'Table must be on valid row');
3599 assert(col > 0, 'Table must be on valid col');
3608 assert(column.name, "Column ".concat(i, " must have a name"));
28131 var assert = require('minimalistic-assert'); // Supported tags
28197 assert(state.parent === null);
28203 assert.equal(state.children.length, 1, 'Root node can have only one child');
28217 assert(state.children === null);
28226 assert(state.args === null);
28257 assert(state.tag === null);
28267 assert(item);
28269 assert(state.use === null);
28282 assert(state['default'] === null);
28290 assert(state.explicit === null && state.implicit === null);
28297 assert(state.explicit === null && state.implicit === null);
28312 assert(state.key === null);
28325 assert(state.choice === null);
28337 assert(state.use === null);
28452 assert(state.useDecoder._baseState.parent === null);
28589 assert(false, data.type + ' not found in ' + JSON.stringify(Object.keys(state.choice)));
29443 function assert(val, msg) {
29526 assert(base === (base | 0) && base >= 2 && base <= 36);
29563 assert(number < 0x20000000000000); // 2 ^ 53 (unsafe)
29576 assert(typeof number.length === 'number');
29901 assert(false, 'Base should be between 2 and 36');
29913 assert(false, 'Number can only safely store up to 53 bits');
29924 assert(typeof Buffer !== 'undefined');
29935 assert(byteLength <= reqLength, 'byte array longer than desired length');
29936 assert(reqLength > 0, 'Requested array length <= 0');
30122 assert((this.negative | num.negative) === 0);
30157 assert((this.negative | num.negative) === 0);
30201 assert((this.negative | num.negative) === 0);
30218 assert(typeof width === 'number' && width >= 0);
30248 assert(typeof bit === 'number' && bit >= 0);
31250 assert(carry === 0);
31251 assert((carry & ~0x1fff) === 0);
31318 assert(typeof num === 'number');
31319 assert(num < 0x4000000); // Carry
31378 assert(typeof bits === 'number' && bits >= 0);
31417 assert(this.negative === 0);
31425 assert(typeof bits === 'number' && bits >= 0);
31484 assert(this.negative === 0);
31508 assert(typeof bit === 'number' && bit >= 0);
31521 assert(typeof bits === 'number' && bits >= 0);
31524 assert(this.negative === 0, 'imaskn works only with positive numbers');
31551 assert(typeof num === 'number');
31552 assert(num < 0x4000000);
31591 assert(typeof num === 'number');
31592 assert(num < 0x4000000);
31660 assert(carry === -1);
31759 assert(!num.isZero());
31885 assert(num <= 0x3ffffff);
31898 assert(num <= 0x3ffffff);
31915 assert(p.negative === 0);
31916 assert(!p.isZero());
32002 assert(p.negative === 0);
32003 assert(!p.isZero());
32133 assert(typeof bit === 'number');
32182 assert(num <= 0x3ffffff, 'Number is too big');
32276 assert(!this.red, 'Already a number in reduction context');
32277 assert(this.negative === 0, 'red works only with positives');
32282 assert(this.red, 'fromRed works only with numbers in reduction context');
32292 assert(!this.red, 'Already a number in reduction context');
32297 assert(this.red, 'redAdd works only with red numbers');
32302 assert(this.red, 'redIAdd works only with red numbers');
32307 assert(this.red, 'redSub works only with red numbers');
32312 assert(this.red, 'redISub works only with red numbers');
32317 assert(this.red, 'redShl works only with red numbers');
32322 assert(this.red, 'redMul works only with red numbers');
32330 assert(this.red, 'redMul works only with red numbers');
32338 assert(this.red, 'redSqr works only with red numbers');
32346 assert(this.red, 'redISqr works only with red numbers');
32355 assert(this.red, 'redSqrt works only with red numbers');
32363 assert(this.red, 'redInvm works only with red numbers');
32372 assert(this.red, 'redNeg works only with red numbers');
32380 assert(this.red && !num.red, 'redPow(normalNum)');
32591 assert(m.gtn(1), 'modulus must be greater than 1');
32598 assert(a.negative === 0, 'red works only with positives');
32599 assert(a.red, 'red works only with red numbers');
32603 assert((a.negative | b.negative) === 0, 'red works only with positives');
32604 assert(a.red && a.red === b.red, 'red works only with red numbers');
32697 assert(mod3 % 2 === 1); // Fast case
32715 assert(!q.isZero());
32740 assert(i < m);
33032 function assert(val, msg) {
33115 assert(base === (base | 0) && base >= 2 && base <= 36);
33153 assert(number < 0x20000000000000); // 2 ^ 53 (unsafe)
33166 assert(typeof number.length === 'number');
33235 assert(!(z & 0xf0), 'Invalid character in ' + str);
33291 assert(c >= 0 && b < mul, 'Invalid character');
33524 assert(false, 'Base should be between 2 and 36');
33536 assert(false, 'Number can only safely store up to 53 bits');
33569 assert(byteLength <= reqLength, 'byte array longer than desired length');
33570 assert(reqLength > 0, 'Requested array length <= 0');
33806 assert((this.negative | num.negative) === 0);
33841 assert((this.negative | num.negative) === 0);
33885 assert((this.negative | num.negative) === 0);
33902 assert(typeof width === 'number' && width >= 0);
33932 assert(typeof bit === 'number' && bit >= 0);
34936 assert(carry === 0);
34937 assert((carry & ~0x1fff) === 0);
35006 assert(typeof num === 'number');
35007 assert(num < 0x4000000); // Carry
35066 assert(typeof bits === 'number' && bits >= 0);
35105 assert(this.negative === 0);
35113 assert(typeof bits === 'number' && bits >= 0);
35172 assert(this.negative === 0);
35196 assert(typeof bit === 'number' && bit >= 0);
35209 assert(typeof bits === 'number' && bits >= 0);
35212 assert(this.negative === 0, 'imaskn works only with positive numbers');
35239 assert(typeof num === 'number');
35240 assert(num < 0x4000000);
35279 assert(typeof num === 'number');
35280 assert(num < 0x4000000);
35348 assert(carry === -1);
35448 assert(!num.isZero());
35576 assert(num <= 0x3ffffff);
35596 assert(num <= 0x3ffffff);
35615 assert(p.negative === 0);
35616 assert(!p.isZero());
35702 assert(p.negative === 0);
35703 assert(!p.isZero());
35833 assert(typeof bit === 'number');
35884 assert(num <= 0x3ffffff, 'Number is too big');
35978 assert(!this.red, 'Already a number in reduction context');
35979 assert(this.negative === 0, 'red works only with positives');
35984 assert(this.red, 'fromRed works only with numbers in reduction context');
35994 assert(!this.red, 'Already a number in reduction context');
35999 assert(this.red, 'redAdd works only with red numbers');
36004 assert(this.red, 'redIAdd works only with red numbers');
36009 assert(this.red, 'redSub works only with red numbers');
36014 assert(this.red, 'redISub works only with red numbers');
36019 assert(this.red, 'redShl works only with red numbers');
36024 assert(this.red, 'redMul works only with red numbers');
36032 assert(this.red, 'redMul works only with red numbers');
36040 assert(this.red, 'redSqr works only with red numbers');
36048 assert(this.red, 'redISqr works only with red numbers');
36057 assert(this.red, 'redSqrt works only with red numbers');
36065 assert(this.red, 'redInvm works only with red numbers');
36074 assert(this.red, 'redNeg works only with red numbers');
36082 assert(this.red && !num.red, 'redPow(normalNum)');
36293 assert(m.gtn(1), 'modulus must be greater than 1');
36300 assert(a.negative === 0, 'red works only with positives');
36301 assert(a.red, 'red works only with red numbers');
36305 assert((a.negative | b.negative) === 0, 'red works only with positives');
36306 assert(a.red && a.red === b.red, 'red works only with red numbers');
36400 assert(mod3 % 2 === 1); // Fast case
36418 assert(!q.isZero());
36443 assert(i < m);
44604 var assert = require('minimalistic-assert');
44611 assert.equal(iv.length, 8, 'Invalid IV length');
44679 var assert = require('minimalistic-assert');
44798 assert.equal(this.bufferOff, this.blockSize, 'Not enough data to decrypt');
44809 var assert = require('minimalistic-assert');
44840 assert.equal(key.length, this.blockSize, 'Invalid key length');
44884 assert.equal(buffer[i], pad);
44937 var assert = require('minimalistic-assert');
44946 assert.equal(key.length, 24, 'Invalid key length');
45649 var assert = utils.assert;
45691 assert(p.precomputed);
45748 assert(z !== 0);
45907 …if (bytes[0] === 0x06) assert(bytes[bytes.length - 1] % 2 === 0);else if (bytes[0] === 0x07) asser…
46013 var assert = utils.assert;
46027 assert(!this.twisted || this.c.fromRed().cmpn(1) === 0);
46578 var assert = utils.assert;
46623 assert(this.g.mul(lambda).x.cmp(this.g.x.redMul(beta)) === 0);
47416 var assert = utils.assert;
47423 assert(this.g.validate(), 'Invalid curve');
47424 assert(this.g.mul(this.n).isInfinity(), 'Invalid curve, G*N != O');
47571 var assert = utils.assert;
47581 assert(curves.hasOwnProperty(options), 'Unknown curve ' + options);
47725 assert((3 & j) === j, 'The recovery param is more than two bits');
47771 var assert = utils.assert;
47849 assert(key.x, 'Need x coordinate');
47851 assert(key.x && key.y, 'Need both x and y coordinate');
47886 var assert = utils.assert;
47891 assert(options.r && options.s, 'Signature without r or s');
48070 var assert = utils.assert;
48078 assert(curve === 'ed25519', 'only tested with ed25519 so far');
48192 var assert = utils.assert;
48257 assert(this._secret, 'KeyPair can only verify');
48266 assert(this._secret, 'KeyPair is public only');
48285 var assert = utils.assert;
48308 assert(sig.R && sig.S, 'Signature without R or S');
48363 utils.assert = minAssert;
49360 var assert = require('minimalistic-assert');
49400 assert(this.pending === null);
49454 var assert = require('minimalistic-assert');
49472 assert(key.length <= this.blockSize); // Add padding to key
49695 var assert = require('minimalistic-assert');
49743 assert(this.k.length === W.length);
49803 var assert = require('minimalistic-assert');
49879 assert(this.k.length === W.length);
50096 var assert = require('minimalistic-assert');
50213 assert(len % 4 === 0);
50393 var assert = require('minimalistic-assert');
50408 …assert(entropy.length >= this.minEntropy / 8, 'Not enough entropy. Minimum is: ' + this.minEntropy…
50456 …assert(entropy.length >= this.minEntropy / 8, 'Not enough entropy. Minimum is: ' + this.minEntropy…
61681 module.exports = assert;
61683 function assert(val, msg) {
61687 assert.equal = function assertEqual(l, r, msg) {