src/third_party/devtools/node_modules/des.js/test/utils-test.js

'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'));
    });
  });
});