CoCalc -- binary-test.js

Summer of Sage Days 2015: San Diego (sd64.25), etc.
react / wstein / node_modules / browserify / node_modules / crypto-browserify / node_modules / diffie-hellman / node_modules / bn.js / test / binary-test.js
⁸⁰⁵⁵⁹ views
1
var assert = require('assert');
2
var BN = require('../').BN;
3
var fixtures = require('./fixtures');
4

5
describe('BN.js/Binary', function() {
6
  describe('.shl()', function() {
7
    it('should shl numbers', function() {
8
      assert.equal(new BN('69527932928').shln(13).toString(16),
9
                   '2060602000000');
10
      assert.equal(new BN('69527932928').shln(45).toString(16),
11
                   '206060200000000000000');
12
    });
13
  });
14

15
  describe('.shr()', function() {
16
    it('should shr numbers', function() {
17
      assert.equal(new BN('69527932928').shrn(13).toString(16),
18
                   '818180');
19
      assert.equal(new BN('69527932928').shrn(17).toString(16),
20
                   '81818');
21
      assert.equal(new BN('69527932928').shrn(256).toString(16),
22
                   '0');
23
    });
24
  });
25

26
  describe('.bincn()', function() {
27
    it('should increment bit', function() {
28
      assert.equal(new BN(0).bincn(1).toString(16), '2');
29
      assert.equal(new BN(2).bincn(1).toString(16), '4');
30
      assert.equal(new BN(2).bincn(1).bincn(1).toString(16),
31
                   new BN(2).bincn(2).toString(16));
32
      assert.equal(new BN(0xffffff).bincn(1).toString(16), '1000001');
33
    });
34
  });
35

36
  describe('.imaskn()', function() {
37
    it('should mask bits in-place', function() {
38
      assert.equal(new BN(0).imaskn(1).toString(16), '0');
39
      assert.equal(new BN(3).imaskn(1).toString(16), '1');
40
      assert.equal(new BN('123456789', 16).imaskn(4).toString(16), '9');
41
      assert.equal(new BN('123456789', 16).imaskn(16).toString(16), '6789');
42
      assert.equal(new BN('123456789', 16).imaskn(28).toString(16), '3456789');
43
    });
44
  });
45

46
  describe('.testn()', function() {
47
    it('should support test specific bit', function() {
48
      [
49
        'ff',
50
        'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'
51
      ].forEach(function(hex) {
52
        var bn = new BN(hex, 16)
53
        var bl = bn.bitLength()
54

55
        for (var i = 0; i < bl; ++i) {
56
          assert.equal(bn.testn(i), true);
57
        }
58

59
        // test off the end
60
        assert.equal(bn.testn(bl), false);
61
      })
62

63
      var xbits = '01111001010111001001000100011101' +
64
                  '11010011101100011000111001011101' +
65
                  '10010100111000000001011000111101' +
66
                  '01011111001111100100011110000010' +
67
                  '01011010100111010001010011000100' +
68
                  '01101001011110100001001111100110' +
69
                  '001110010111';
70

71
      var x = new BN(
72
        '23478905234580795234378912401239784125643978256123048348957342'
73
      )
74
      for (var i = 0; i < x.bitLength(); ++i) {
75
        assert.equal(x.testn(i), (xbits.charAt(i) === '1'), 'Failed @ bit ' + i)
76
      }
77
    });
78

79
    it('should have short-cuts', function() {
80
      var x = new BN('abcd', 16);
81
      assert(!x.testn(128));
82
    });
83
  });
84

85
  describe('.and()', function() {
86
    it('should and numbers', function() {
87
      assert.equal(new BN('1010101010101010101010101010101010101010', 2)
88
                   .and(new BN('101010101010101010101010101010101010101', 2))
89
                   .toString(2), '0');
90
    });
91

92
    it('should and numbers of different limb-length', function() {
93
      assert.equal(
94
          new BN('abcd0000ffff', 16)
95
              .and(new BN('abcd', 16)).toString(16),
96
          'abcd');
97
    });
98
  });
99

100
  describe('.iand()', function() {
101
    it('should iand numbers', function() {
102
      assert.equal(new BN('1010101010101010101010101010101010101010', 2)
103
                   .iand(new BN('101010101010101010101010101010101010101', 2))
104
                   .toString(2), '0');
105
      assert.equal(new BN('1000000000000000000000000000000000000001', 2)
106
                   .iand(new BN('1', 2))
107
                   .toString(2), '1')
108
      assert.equal(new BN('1', 2)
109
                   .iand(new BN('1000000000000000000000000000000000000001', 2))
110
                   .toString(2), '1')
111
    });
112
  });
113

114
  describe('.or()', function() {
115
    it('should or numbers', function () {
116
      assert.equal(new BN('1010101010101010101010101010101010101010', 2)
117
                   .or(new BN('101010101010101010101010101010101010101', 2))
118
                   .toString(2), '1111111111111111111111111111111111111111');
119
    });
120

121
    it('should or numbers of different limb-length', function() {
122
      assert.equal(
123
          new BN('abcd00000000', 16)
124
              .or(new BN('abcd', 16)).toString(16),
125
          'abcd0000abcd');
126
    });
127
  });
128

129
  describe('.ior()', function() {
130
    it('should ior numbers', function () {
131
      assert.equal(new BN('1010101010101010101010101010101010101010', 2)
132
                   .ior(new BN('101010101010101010101010101010101010101', 2))
133
                   .toString(2), '1111111111111111111111111111111111111111');
134
      assert.equal(new BN('1000000000000000000000000000000000000000', 2)
135
                   .ior(new BN('1', 2))
136
                   .toString(2), '1000000000000000000000000000000000000001');
137
      assert.equal(new BN('1', 2)
138
                   .ior(new BN('1000000000000000000000000000000000000000', 2))
139
                   .toString(2), '1000000000000000000000000000000000000001');
140
    });
141
  });
142

143
  describe('.xor()', function() {
144
    it('should xor numbers', function () {
145
      assert.equal(new BN('11001100110011001100110011001100', 2)
146
                   .xor(new BN('1100110011001100110011001100110', 2))
147
                   .toString(2), '10101010101010101010101010101010');
148
    });
149
  });
150

151
  describe('.ixor()', function() {
152
    it('should ixor numbers', function () {
153
      assert.equal(new BN('11001100110011001100110011001100', 2)
154
                   .ixor(new BN('1100110011001100110011001100110', 2))
155
                   .toString(2), '10101010101010101010101010101010');
156
      assert.equal(new BN('11001100110011001100110011001100', 2)
157
                   .ixor(new BN('1', 2))
158
                   .toString(2), '11001100110011001100110011001101');
159
      assert.equal(new BN('1', 2)
160
                   .ixor(new BN('11001100110011001100110011001100', 2))
161
                   .toString(2), '11001100110011001100110011001101');
162
    });
163

164
    it('should and numbers of different limb-length', function() {
165
      assert.equal(
166
          new BN('abcd0000ffff', 16)
167
              .xor(new BN('abcd', 16)).toString(16),
168
          'abcd00005432');
169
    });
170
  });
171

172
  describe('.setn()', function() {
173
    it('should allow single bits to be set', function () {
174
      assert.equal(new BN(0).setn(2, true).toString(2), '100');
175
      assert.equal(new BN(0).setn(27, true).toString(2),
176
                   '1000000000000000000000000000');
177
      assert.equal(new BN('1000000000000000000000000001', 2).setn(27, false)
178
                   .toString(2), '1');
179
      assert.equal(new BN('101', 2).setn(2, false).toString(2), '1');
180
    });
181
  });
182
});
183

184
Product

Resources

Company
