session-desktop/test/session/unit/utils/String_test.js

var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
var import_chai = __toESM(require("chai"));
var import_bytebuffer = __toESM(require("bytebuffer"));
var import_utils = require("../../../../session/utils");
var import_chai_as_promised = __toESM(require("chai-as-promised"));
import_chai.default.use(import_chai_as_promised.default);
const { expect } = import_chai.default;
describe("String Utils", () => {
  describe("encode", () => {
    it("can encode to base64", () => {
      const testString = "AAAAAAAAAA";
      const encoded = import_utils.StringUtils.encode(testString, "base64");
      expect(encoded instanceof ArrayBuffer).to.equal(true, "a buffer was not returned from `encode`");
      expect(encoded.byteLength).to.be.greaterThan(0);
    });
    it("can encode to hex", () => {
      const testString = "AAAAAAAAAA";
      const encoded = import_utils.StringUtils.encode(testString, "hex");
      expect(encoded instanceof ArrayBuffer).to.equal(true, "a buffer was not returned from `encode`");
      expect(encoded.byteLength).to.be.greaterThan(0);
    });
    it("wont encode invalid hex", () => {
      const testString = "ZZZZZZZZZZ";
      const encoded = import_utils.StringUtils.encode(testString, "hex");
      expect(encoded.byteLength).to.equal(0);
    });
    it("can encode to binary", () => {
      const testString = "AAAAAAAAAA";
      const encoded = import_utils.StringUtils.encode(testString, "binary");
      expect(encoded instanceof ArrayBuffer).to.equal(true, "a buffer was not returned from `encode`");
      expect(encoded.byteLength).to.be.greaterThan(0);
    });
    it("can encode to utf8", () => {
      const testString = "AAAAAAAAAA";
      const encoded = import_utils.StringUtils.encode(testString, "binary");
      expect(encoded instanceof ArrayBuffer).to.equal(true, "a buffer was not returned from `encode`");
      expect(encoded.byteLength).to.be.greaterThan(0);
    });
    it("can encode empty string", () => {
      const testString = "";
      expect(testString).to.have.length(0);
      const allEncodedings = ["base64", "hex", "binary", "utf8"].map((e) => import_utils.StringUtils.encode(testString, e));
      allEncodedings.forEach((encoded) => {
        expect(encoded instanceof ArrayBuffer).to.equal(true, "a buffer was not returned from `encode`");
        expect(encoded.byteLength).to.equal(0);
      });
    });
    it("can encode huge string", () => {
      const stringSize = Math.pow(2, 16);
      const testString = Array(stringSize).fill("0").join("");
      const allEncodedings = ["base64", "hex", "binary", "utf8"].map((e) => import_utils.StringUtils.encode(testString, e));
      allEncodedings.forEach((encoded) => {
        expect(encoded instanceof ArrayBuffer).to.equal(true, "a buffer was not returned from `encode`");
        expect(encoded.byteLength).to.be.greaterThan(0);
      });
    });
    it("won't encode illegal string length in hex", () => {
      const testString = "A";
      const encode = /* @__PURE__ */ __name(() => import_utils.StringUtils.encode(testString, "hex"), "encode");
      expect(testString.length % 2).to.equal(1);
      expect(encode).to.throw("Illegal str: Length not a multiple of 2");
    });
    it("can encode obscure string", () => {
      const testString = "\u2193\u2190\xB6\u1D91\u1D76\u2151\u23D5\u2192\u2153\u200E\u1D79\u2159\u1D70\u1D8E\u2154\u2157\u2194\u200C\u1D88\u215E\u206F\u2E1C\u1D8A\u206C\u1D74\u1D89\u2189\u206D\xA5\u1D96\u1D8B\u1D83\u1D93\u23E6\u1D7E\u1D82\u1D86\u2195\u2E1D\u1D94\u1D90\u23D4\xA3\u23D9\u2150\u2152\u1D8C\u2041\u1D98\u1D84\u1D92\u206A\u1DB8\u2158\u200F\u206E\u215A\u215B\u1D99\u1D87\u1D95\u1D80\u2191\u1D7F\u23E0\u1D8D\u1D6F\u23D6\u23D7\u215C\u1D9A\u1D8F\u204A\u200D\u1D81\u1D97\u1D7D\u206B\u1D7C\u215D\u23D8\u2156\u2155\u23E1";
      const encodings = ["base64", "binary", "utf8"];
      encodings.forEach((encoding) => {
        const encoded = import_utils.StringUtils.encode(testString, encoding);
        expect(encoded instanceof ArrayBuffer).to.equal(true, `a buffer was not returned using encoding: '${encoding}'`);
        expect(encoded.byteLength).to.be.greaterThan(0);
      });
    });
  });
  describe("decode", () => {
    it("can decode empty buffer", () => {
      const buffer = new import_bytebuffer.default(0);
      const encodings = ["base64", "hex", "binary", "utf8"];
      encodings.forEach((encoding) => {
        const decoded = import_utils.StringUtils.decode(buffer, encoding);
        expect(decoded).to.exist;
        expect(typeof decoded === String.name.toLowerCase());
        expect(decoded).to.have.length(0);
      });
    });
    it("can decode huge buffer", () => {
      const bytes = Math.pow(2, 16);
      const bufferString = Array(bytes).fill("A").join("");
      const buffer = import_bytebuffer.default.fromUTF8(bufferString);
      const encodings = ["base64", "hex", "binary", "utf8"];
      encodings.forEach((encoding) => {
        const decoded = import_utils.StringUtils.decode(buffer, encoding);
        expect(decoded).to.exist;
        expect(typeof decoded === String.name.toLowerCase());
        expect(decoded).to.have.length.greaterThan(0);
      });
    });
    it("can decode from ByteBuffer", () => {
      const buffer = import_bytebuffer.default.fromUTF8("AAAAAAAAAA");
      const encodings = ["base64", "hex", "binary", "utf8"];
      encodings.forEach((encoding) => {
        const decoded = import_utils.StringUtils.decode(buffer, encoding);
        expect(decoded).to.exist;
        expect(typeof decoded === String.name.toLowerCase());
        expect(decoded).to.have.length.greaterThan(0);
      });
    });
    it("can decode from Buffer", () => {
      const arrayBuffer = new ArrayBuffer(10);
      const buffer = Buffer.from(arrayBuffer);
      buffer.writeUInt8(0, 0);
      const encodings = ["base64", "hex", "binary", "utf8"];
      encodings.forEach((encoding) => {
        const decoded = import_utils.StringUtils.decode(buffer, encoding);
        expect(decoded).to.exist;
        expect(typeof decoded === String.name.toLowerCase());
        expect(decoded).to.have.length.greaterThan(0);
      });
    });
    it("can decode from ArrayBuffer", () => {
      const buffer = new ArrayBuffer(10);
      const encodings = ["base64", "hex", "binary", "utf8"];
      encodings.forEach((encoding) => {
        const decoded = import_utils.StringUtils.decode(buffer, encoding);
        expect(decoded).to.exist;
        expect(typeof decoded === String.name.toLowerCase());
        expect(decoded).to.have.length.greaterThan(0);
      });
    });
    it("can decode from Uint8Array", () => {
      const buffer = new Uint8Array(10);
      const encodings = ["base64", "hex", "binary", "utf8"];
      encodings.forEach((encoding) => {
        const decoded = import_utils.StringUtils.decode(buffer, encoding);
        expect(decoded).to.exist;
        expect(typeof decoded === String.name.toLowerCase());
        expect(decoded).to.have.length.greaterThan(0);
      });
    });
  });
});
//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../ts/test/session/unit/utils/String_test.ts"],
  "sourcesContent": ["// tslint:disable: no-implicit-dependencies max-func-body-length no-unused-expression\nimport chai from 'chai';\nimport ByteBuffer from 'bytebuffer';\n\n// Can't import type as StringUtils.Encoding\nimport { Encoding } from '../../../../session/utils/String';\nimport { StringUtils } from '../../../../session/utils';\n\nimport chaiAsPromised from 'chai-as-promised';\nchai.use(chaiAsPromised as any);\n\nconst { expect } = chai;\n\ndescribe('String Utils', () => {\n  describe('encode', () => {\n    it('can encode to base64', () => {\n      const testString = 'AAAAAAAAAA';\n      const encoded = StringUtils.encode(testString, 'base64');\n\n      expect(encoded instanceof ArrayBuffer).to.equal(\n        true,\n        'a buffer was not returned from `encode`'\n      );\n      expect(encoded.byteLength).to.be.greaterThan(0);\n    });\n\n    it('can encode to hex', () => {\n      const testString = 'AAAAAAAAAA';\n      const encoded = StringUtils.encode(testString, 'hex');\n\n      expect(encoded instanceof ArrayBuffer).to.equal(\n        true,\n        'a buffer was not returned from `encode`'\n      );\n      expect(encoded.byteLength).to.be.greaterThan(0);\n    });\n\n    it('wont encode invalid hex', () => {\n      const testString = 'ZZZZZZZZZZ';\n      const encoded = StringUtils.encode(testString, 'hex');\n\n      expect(encoded.byteLength).to.equal(0);\n    });\n\n    it('can encode to binary', () => {\n      const testString = 'AAAAAAAAAA';\n      const encoded = StringUtils.encode(testString, 'binary');\n\n      expect(encoded instanceof ArrayBuffer).to.equal(\n        true,\n        'a buffer was not returned from `encode`'\n      );\n      expect(encoded.byteLength).to.be.greaterThan(0);\n    });\n\n    it('can encode to utf8', () => {\n      const testString = 'AAAAAAAAAA';\n      const encoded = StringUtils.encode(testString, 'binary');\n\n      expect(encoded instanceof ArrayBuffer).to.equal(\n        true,\n        'a buffer was not returned from `encode`'\n      );\n      expect(encoded.byteLength).to.be.greaterThan(0);\n    });\n\n    it('can encode empty string', () => {\n      const testString = '';\n      expect(testString).to.have.length(0);\n\n      const allEncodedings = (['base64', 'hex', 'binary', 'utf8'] as Array<Encoding>).map(e =>\n        StringUtils.encode(testString, e)\n      );\n\n      allEncodedings.forEach(encoded => {\n        expect(encoded instanceof ArrayBuffer).to.equal(\n          true,\n          'a buffer was not returned from `encode`'\n        );\n        expect(encoded.byteLength).to.equal(0);\n      });\n    });\n\n    it('can encode huge string', () => {\n      const stringSize = Math.pow(2, 16);\n      const testString = Array(stringSize)\n        .fill('0')\n        .join('');\n\n      const allEncodedings = (['base64', 'hex', 'binary', 'utf8'] as Array<Encoding>).map(e =>\n        StringUtils.encode(testString, e)\n      );\n\n      allEncodedings.forEach(encoded => {\n        expect(encoded instanceof ArrayBuffer).to.equal(\n          true,\n          'a buffer was not returned from `encode`'\n        );\n        expect(encoded.byteLength).to.be.greaterThan(0);\n      });\n    });\n\n    it(\"won't encode illegal string length in hex\", () => {\n      const testString = 'A';\n      const encode = () => StringUtils.encode(testString, 'hex');\n\n      // Ensure string is odd length\n      expect(testString.length % 2).to.equal(1);\n      expect(encode).to.throw('Illegal str: Length not a multiple of 2');\n    });\n\n    it('can encode obscure string', () => {\n      const testString =\n        '\u2193\u2190\u00B6\u1D91\u1D76\u2151\u23D5\u2192\u2153\u200E\u1D79\u2159\u1D70\u1D8E\u2154\u2157\u2194\u200C\u1D88\u215E\u206F\u2E1C\u1D8A\u206C\u1D74\u1D89\u2189\u206D\u00A5\u1D96\u1D8B\u1D83\u1D93\u23E6\u1D7E\u1D82\u1D86\u2195\u2E1D\u1D94\u1D90\u23D4\u00A3\u23D9\u2150\u2152\u1D8C\u2041\u1D98\u1D84\u1D92\u206A\u1DB8\u2158\u200F\u206E\u215A\u215B\u1D99\u1D87\u1D95\u1D80\u2191\u1D7F\u23E0\u1D8D\u1D6F\u23D6\u23D7\u215C\u1D9A\u1D8F\u204A\u200D\u1D81\u1D97\u1D7D\u206B\u1D7C\u215D\u23D8\u2156\u2155\u23E1';\n\n      // Not valid hex format; try test the others\n      const encodings = ['base64', 'binary', 'utf8'] as Array<Encoding>;\n\n      encodings.forEach(encoding => {\n        const encoded = StringUtils.encode(testString, encoding);\n        expect(encoded instanceof ArrayBuffer).to.equal(\n          true,\n          `a buffer was not returned using encoding: '${encoding}'`\n        );\n        expect(encoded.byteLength).to.be.greaterThan(0);\n      });\n    });\n  });\n\n  describe('decode', () => {\n    it('can decode empty buffer', () => {\n      const buffer = new ByteBuffer(0);\n\n      const encodings = ['base64', 'hex', 'binary', 'utf8'] as Array<Encoding>;\n\n      // Each encoding should be valid\n      encodings.forEach(encoding => {\n        const decoded = StringUtils.decode(buffer, encoding);\n\n        expect(decoded).to.exist;\n        expect(typeof decoded === String.name.toLowerCase());\n        expect(decoded).to.have.length(0);\n      });\n    });\n\n    it('can decode huge buffer', () => {\n      const bytes = Math.pow(2, 16);\n      const bufferString = Array(bytes)\n        .fill('A')\n        .join('');\n      const buffer = ByteBuffer.fromUTF8(bufferString);\n\n      const encodings = ['base64', 'hex', 'binary', 'utf8'] as Array<Encoding>;\n\n      // Each encoding should be valid\n      encodings.forEach(encoding => {\n        const decoded = StringUtils.decode(buffer, encoding);\n\n        expect(decoded).to.exist;\n        expect(typeof decoded === String.name.toLowerCase());\n        expect(decoded).to.have.length.greaterThan(0);\n      });\n    });\n\n    it('can decode from ByteBuffer', () => {\n      const buffer = ByteBuffer.fromUTF8('AAAAAAAAAA');\n\n      const encodings = ['base64', 'hex', 'binary', 'utf8'] as Array<Encoding>;\n\n      // Each encoding should be valid\n      encodings.forEach(encoding => {\n        const decoded = StringUtils.decode(buffer, encoding);\n\n        expect(decoded).to.exist;\n        expect(typeof decoded === String.name.toLowerCase());\n        expect(decoded).to.have.length.greaterThan(0);\n      });\n    });\n\n    it('can decode from Buffer', () => {\n      const arrayBuffer = new ArrayBuffer(10);\n      const buffer = Buffer.from(arrayBuffer);\n      buffer.writeUInt8(0, 0);\n\n      const encodings = ['base64', 'hex', 'binary', 'utf8'] as Array<Encoding>;\n\n      // Each encoding should be valid\n      encodings.forEach(encoding => {\n        const decoded = StringUtils.decode(buffer, encoding);\n\n        expect(decoded).to.exist;\n        expect(typeof decoded === String.name.toLowerCase());\n        expect(decoded).to.have.length.greaterThan(0);\n      });\n    });\n\n    it('can decode from ArrayBuffer', () => {\n      const buffer = new ArrayBuffer(10);\n\n      const encodings = ['base64', 'hex', 'binary', 'utf8'] as Array<Encoding>;\n\n      // Each encoding should be valid\n      encodings.forEach(encoding => {\n        const decoded = StringUtils.decode(buffer, encoding);\n\n        expect(decoded).to.exist;\n        expect(typeof decoded === String.name.toLowerCase());\n        expect(decoded).to.have.length.greaterThan(0);\n      });\n    });\n\n    it('can decode from Uint8Array', () => {\n      const buffer = new Uint8Array(10);\n\n      const encodings = ['base64', 'hex', 'binary', 'utf8'] as Array<Encoding>;\n\n      // Each encoding should be valid\n      encodings.forEach(encoding => {\n        const decoded = StringUtils.decode(buffer, encoding);\n\n        expect(decoded).to.exist;\n        expect(typeof decoded === String.name.toLowerCase());\n        expect(decoded).to.have.length.greaterThan(0);\n      });\n    });\n  });\n});\n"],
  "mappings": "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",
  "names": []
}
