"use strict";

const assert = require('assert');
const Immutable = require('immutable');

const { is, Bytes, fromJS } = require('../src/index.js');

describe('immutable byte arrays', () => {
  describe('Uint8Array methods', () => {
    const bs = Bytes.of(10, 20, 30, 40);
    it('should yield entries', () => {
      assert(is(fromJS(Array.from(bs.entries())),
                fromJS([[0,10],[1,20],[2,30],[3,40]])));
    });
    it('should implement every', () => {
      assert(bs.every((b) => !(b & 1)));
      assert(bs.every((b) => b !== 50));
      assert(!(bs.every((b) => b !== 20)));
    });
    it('should implement find', () => {
      assert.strictEqual(bs.find((b) => b > 20), 30);
      assert.strictEqual(bs.find((b) => b > 50), void 0);
    });
    it('should implement findIndex', () => {
      assert.strictEqual(bs.findIndex((b) => b > 20), 2);
      assert.strictEqual(bs.findIndex((b) => b > 50), -1);
    });
    it('should implement forEach', () => {
      const vs = [];
      bs.forEach((b) => vs.push(b));
      assert(is(fromJS(vs), fromJS([10, 20, 30, 40])));
    });
    it('should implement includes', () => {
      assert(bs.includes(20));
      assert(!bs.includes(50));
    });
    it('should implement indexOf', () => {
      assert.strictEqual(bs.indexOf(20), 1);
      assert.strictEqual(bs.indexOf(50), -1);
    });
    it('should implement join', () => assert.strictEqual(bs.join('-'), '10-20-30-40'));
    it('should implement keys', () => {
      assert(is(fromJS(Array.from(bs.keys())), fromJS([0,1,2,3])));
    });
    it('should implement values', () => {
      assert(is(fromJS(Array.from(bs.values())), fromJS([10,20,30,40])));
    });
    it('should implement filter', () => {
      assert(is(bs.filter((b) => b !== 30), Bytes.of(10,20,40)));
    });
    it('should implement slice', () => {
      const vs = bs.slice(2);
      assert(!Object.is(vs._view.buffer, bs._view.buffer));
      assert.strictEqual(vs._view.buffer.byteLength, 2);
      assert.strictEqual(vs.get(0), 30);
      assert.strictEqual(vs.get(1), 40);
      assert.strictEqual(vs.size, 2);
    });
    it('should implement subarray', () => {
      const vs = bs.subarray(2);
      assert(Object.is(vs._view.buffer, bs._view.buffer));
      assert.strictEqual(vs._view.buffer.byteLength, 4);
      assert.strictEqual(vs.get(0), 30);
      assert.strictEqual(vs.get(1), 40);
      assert.strictEqual(vs.size, 2);
    });
    it('should implement reverse', () => {
      const vs = bs.reverse();
      assert(!Object.is(vs._view.buffer, bs._view.buffer));
      assert.strictEqual(bs.get(0), 10);
      assert.strictEqual(bs.get(3), 40);
      assert.strictEqual(vs.get(0), 40);
      assert.strictEqual(vs.get(3), 10);
    });
    it('should implement sort', () => {
      const vs = bs.reverse().sort();
      assert(!Object.is(vs._view.buffer, bs._view.buffer));
      assert.strictEqual(bs.get(0), 10);
      assert.strictEqual(bs.get(3), 40);
      assert.strictEqual(vs.get(0), 10);
      assert.strictEqual(vs.get(3), 40);
    });
  });
});