1 files changed, 169 insertions, 0 deletions
diff --git a/node_modules/des.js/test/utils-test.js b/node_modules/des.js/test/utils-test.js
new file mode 100644
index 0000000..4c576de
--- /dev/null
+++ b/node_modules/des.js/test/utils-test.js
@@ -0,0 +1,169 @@
+'use strict';
+
+var assert = require('assert');
+
+var des = require('../');
+var utils = des.utils;
+
+var fixtures = require('./fixtures');
+var bin = fixtures.bin;
+
+describe('utils', function() {
+  describe('IP', function() {
+    it('should permute properly', function() {
+      var out = new Array(2);
+      var inp = [
+        bin('00000001 00100011 01000101 01100111'),
+        bin('10001001 10101011 11001101 11101111')
+      ];
+
+      utils.ip(inp[0], inp[1], out, 0);
+
+      var expected = [
+        bin('11001100 00000000 11001100 11111111'),
+        bin('11110000 10101010 11110000 10101010')
+      ];
+
+      assert.deepEqual(out, expected);
+    });
+
+    it('should rev-permute properly', function() {
+      var out = new Array(2);
+      var inp = [
+        bin('11001100 00000000 11001100 11111111'),
+        bin('11110000 10101010 11110000 10101010')
+      ];
+
+      utils.rip(inp[0], inp[1], out, 0);
+
+      var expected = [
+        bin('00000001 00100011 01000101 01100111'),
+        bin('10001001 10101011 11001101 11101111')
+      ];
+
+      assert.deepEqual(out, expected);
+    });
+  });
+
+  describe('PC1', function() {
+    it('should permute properly', function() {
+      var out = new Array(2);
+      var inp = [
+        bin('00010011 00110100 01010111 01111001'),
+        bin('10011011 10111100 11011111 11110001')
+      ];
+
+      utils.pc1(inp[0], inp[1], out, 0);
+
+      var expected = [
+        bin('1111000 0110011 0010101 0101111'),
+        bin('0101010 1011001 1001111 0001111')
+      ];
+
+      assert.deepEqual(out, expected);
+    });
+  });
+
+  describe('r28shl', function() {
+    it('should shl properly', function() {
+      assert.equal(utils.r28shl(bin('1111000011001100101010101111'), 1),
+                   bin('1110000110011001010101011111'));
+
+      assert.equal(utils.r28shl(bin('0101010101100110011110001111'), 1),
+                   bin('1010101011001100111100011110'));
+
+      assert.equal(utils.r28shl(bin('1111000011001100101010101111'), 4),
+                   bin('0000110011001010101011111111'));
+
+      assert.equal(utils.r28shl(bin('0101010101100110011110001111'), 4),
+                   bin('0101011001100111100011110101'));
+    });
+  });
+
+  describe('PC2', function() {
+    it('should permute properly', function() {
+      var out = new Array(2);
+      var inp = [
+        bin('1110000 1100110 0101010 1011111'),
+        bin('1010101 0110011 0011110 0011110')
+      ];
+
+      utils.pc2(inp[0], inp[1], out, 0);
+
+      var expected = [
+        bin('000110 110000 001011 101111'),
+        bin('111111 000111 000001 110010')
+      ];
+
+      assert.deepEqual(out, expected);
+    });
+  });
+
+  describe('readUInt32BE', function() {
+    it('should read number properly', function() {
+      var a = [ 0xde, 0xad, 0xbe, 0xef ];
+      var o = utils.readUInt32BE(a, 0);
+      assert.equal(o, 0xdeadbeef);
+    });
+  });
+
+  describe('writeUInt32BE', function() {
+    it('should read number properly', function() {
+      var a = [ 0, 0, 0, 0 ];
+      utils.writeUInt32BE(a, 0xdeadbeef, 0);
+      var expected = [ 0xde, 0xad, 0xbe, 0xef ];
+      assert.deepEqual(a, expected);
+    });
+  });
+
+  describe('expand', function() {
+    it('should expand', function() {
+      var out = [ 0, 0 ];
+      utils.expand(bin('1111 0000 1010 1010 1111 0000 1010 1010'), out, 0);
+      var expected = [
+        bin('011110 100001 010101 010101'),
+        bin('011110 100001 010101 010101')
+      ];
+      assert.deepEqual(out, expected);
+    });
+
+    it('should expand with low 1', function() {
+      var out = [ 0, 0 ];
+      utils.expand(bin('1111 0000 1010 1010 1111 0000 1010 1011'), out, 0);
+      var expected = [
+        bin('111110 100001 010101 010101'),
+        bin('011110 100001 010101 010111')
+      ];
+      assert.deepEqual(out, expected);
+    });
+
+    it('should expand with low 1', function() {
+      var out = [ 0, 0 ];
+      utils.expand(bin('10100010 01011100 00001011 11110100'), out, 0);
+      var expected = [
+        bin('010100 000100 001011 111000'),
+        bin('000001 010111 111110 101001')
+      ];
+      assert.deepEqual(out, expected);
+    });
+  });
+
+  describe('substitute', function() {
+    it('should substitute', function() {
+      var input = [
+        bin('011000 010001 011110 111010'),
+        bin('100001 100110 010100 100111')
+      ];
+      var output = utils.substitute(input[0], input[1]);
+      assert.equal(output, bin('0101 1100 1000 0010 1011 0101 1001 0111'));
+    });
+  });
+
+  describe('permute', function() {
+    it('should permute', function() {
+      var output = utils.permute(
+          bin('0101 1100 1000 0010 1011 0101 1001 0111'));
+      assert.equal(output, bin('0010 0011 0100 1010 1010 1001 1011 1011'));
+    });
+  });
+});