EgaLabs / node-ejsception

// spec/NoSuchElementException.spec.js

"use strict";

// :: DEPENDENCIES

// load native dependencies

const path = require("path");

// load local dependencies

const root                   = path.dirname(__dirname);

const Throwable              = require(path.join(root, "Throwable.js"));

const Exception              = require(path.join(root, "Exception.js"));

const RuntimeException       = require(path.join(root, "RuntimeException.js"));

const NoSuchElementException = require(path.join(root, "NoSuchElementException.js"));

// :: TESTING

// test the NoSuchElementException 'class'

describe("NoSuchElementException", () => {

    // :: INHERITED PROTOTYPE

    it("should inherit from 'Object'", () => {

        expect(new NoSuchElementException()).toEqual(jasmine.any(Object));

    });

	it("should inherit from 'Throwable'", () => {

		expect(new NoSuchElementException()).toEqual(jasmine.any(Throwable));

	});

	it("should inherit from 'Exception'", () => {

		expect(new NoSuchElementException()).toEqual(jasmine.any(Exception));

	});

    it("should inherit from 'RuntimeException'", () => {

        expect(new NoSuchElementException()).toEqual(jasmine.any(RuntimeException));

    });

	it("should have a prototype method named 'toString()'", () => {

		expect(NoSuchElementException.prototype).toHaveMethod("toString");

	});

	it("should have a prototype method named 'native()'", () => {

		expect(NoSuchElementException.prototype).toHaveMethod("native");

	});

	it("should have a prototype property string named 'name'", () => {

		expect(NoSuchElementException.prototype).toHaveString("name");

	});

	it("should have a prototype property string named 'message'", () => {

		expect(NoSuchElementException.prototype).toHaveString("message");

	});

	it("should have a prototype property string named 'code'", () => {

		expect(NoSuchElementException.prototype).toHaveMember("code");

	});

    // :: EXTENDED PROTOTYPE

    // :: PROTOTYPE VALUES

    it("should have the 'class' name in the prototype property named 'name'", () => {

        expect(NoSuchElementException.prototype.name).toEqual("NoSuchElementException");

    });

    it("should have a dummy default value as message", () => {

        expect(NoSuchElementException.prototype.message).toEqual("thrown");

    });

    it("should have a null default value as code", () => {

        expect(NoSuchElementException.prototype.code).toBeNull();

    });

    // :: CONSTRUCTOR

    it("should instantiate without parameters", () => {

        let arg1, arg2, test;

        test = (() => new NoSuchElementException(arg1, arg2));

        for (let i = 0; i < 2; i += 1) {

            for (let j = 0; j < 2; j += 1) {

                arg1 = (i % 2 === 0 ? undefined : null);

                arg2 = (j % 2 === 0 ? undefined : null);

                expect(test).not.toThrowError("parameter 'name' must be a 'string'");

                expect(test).not.toThrowError("parameter 'message' must be a 'string'");

                expect(test).not.toThrowError("parameter 'code' must be a 'number'");

            }

        }

        test = (() => new NoSuchElementException());

        expect(test).not.toThrowError("parameter 'name' must be a 'string'");

        expect(test).not.toThrowError("parameter 'message' must be a 'string'");

        expect(test).not.toThrowError("parameter 'code' must be a 'number'");

    });

    it("should instantiate with parameters", () => {

        let arg1, arg2, test1, test2;

        const args1 = [undefined, null, NoSuchElementException.prototype.message];

        const args2 = [undefined, null, Math.round(Math.random() * 0xFFFFFFFF)];

        test1       = (() => new NoSuchElementException(arg1));

        test2       = (() => new NoSuchElementException(arg1, arg2));

        for (let i = 0; i < args1.length; i += 1) {

            arg1 = args1[i];

            for (let j = 0; j < args2.length; j += 1) {

                arg2 = args2[j];

                expect(test2).not.toThrowError("parameter 'message' must be a 'string'");

                expect(test2).not.toThrowError("parameter 'code' must be a 'number'");

            }

            expect(test1).not.toThrowError("parameter 'message' must be a 'string'");

            expect(test1).not.toThrowError("parameter 'code' must be a 'number'");

        }

    });

    it("should throw an Error if 'message' or 'code' are invalid parameters", () => {

        let arg1, arg2, test21, test22, test11;

        const noStr = [{}, true, false, 42, 3.1416, -42, -3.1416, () => null];

        const noNmb = [{}, true, false, '', "qwerty", () => null];

        test22      = (() => new NoSuchElementException(arg1, arg2));

        test21      = (() => new NoSuchElementException(null, arg2));

        test11      = (() => new NoSuchElementException(arg1));

        if (typeof Symbol === "function") {

            noStr.push(Symbol("symbol"));

            noNmb.push(Symbol("symbol"));

        }

        for (let i = 0; i < noStr.length; i += 1) {

            arg1 = noStr[i];

            for (let j = 0; j < noNmb.length; j += 1) {

                arg2 = noNmb[j];

                expect(test22).toThrowError("parameter 'message' must be a 'string'");

                expect(test21).toThrowError("parameter 'code' must be a 'number'");

            }

            expect(test11).toThrowError("parameter 'message' must be a 'string'");

        }

    });

    // :: MEMBER PROPERTIES

    it("should have all correct properties once instantiated", () => {

        const message = "asdf";

        const code    = Math.round(Math.random() * 0xFFFFFFFF);

        for (let i = 0; i < 2; i += 1) {

            const arg1    = (i % 2 === 0 ? message : null);

            const source1 = new NoSuchElementException(arg1);

            for (let j = 0; j < 2; j += 1) {

                const arg2    = (j % 2 === 0 ? code : null);

                const source2 = new NoSuchElementException(arg1, arg2);

                if (i % 2 === 0) {

                    expect(source1.message).toEqual(message);

                    expect(source2.message).toEqual(message);

                } else {

                    expect(source1.message).toEqual(NoSuchElementException.prototype.message);

                    expect(source2.message).toEqual(NoSuchElementException.prototype.message);

                }

                if (j % 2 === 0) {

                    expect(source2.code).toEqual(code);

                } else {

                    expect(source2.code).toBeNull();

                }

                expect(source1.code).toBeNull();

            }

        }

    });

    // :: MEMBER METHODS

    const name    = "NoSuchElementException";

    const message = "asdf";

    const code    = Math.round(Math.random() * 0xFFFFFFFF);

    it("#toString()", () => {

        for (let i = 0; i < 2; i += 1) {

            const arg1    = (i % 2 === 0 ? message : null);

            const source1 = new NoSuchElementException(arg1);

            for (let j = 0; j < 2; j += 1) {

                const arg2    = (j % 2 === 0 ? code : null);

                const source2 = new NoSuchElementException(arg1, arg2);

                const str1    = source1.toString();

                const str2    = source2.toString();

                let exp1, exp2;

                exp1 = exp2 = "NoSuchElementException";

                if (j % 2 === 0) {

                    exp2 += " (0x" + code.toString(16) + ')';

                }

                if (i % 2 === 0) {

                    exp1 += ": " + message + '.';

                    exp2 += ": " + message + '.';

                } else {

                    exp1 += ": " + NoSuchElementException.prototype.message + '.';

                    exp2 += ": " + NoSuchElementException.prototype.message + '.';

                }

                expect(str1).toEqual(exp1);

                expect(str2).toEqual(exp2);

            }

        }

    });

    it("#native()", () => {

        for (let i = 0; i < 2; i += 1) {

            const arg1    = (i % 2 === 0 ? message : null);

            const source1 = new NoSuchElementException(arg1);

            for (let j = 0; j < 2; j += 1) {

                const arg2    = (j % 2 === 0 ? code : null);

                const source2 = new NoSuchElementException(arg1, arg2);

                const err1    = source1.native();

                const err2    = source2.native();

                const exp1    = (i % 2 === 0 ? message : NoSuchElementException.prototype.message);

                const exp2    = exp1;

                expect(err1).toEqual(new Error(exp1));

                expect(err2).toEqual(new Error(exp2));

            }

        }

    });

});

// spec/UnsupportedOperationException.spec.js

"use strict";

// :: DEPENDENCIES

// load native dependencies

const path = require("path");

// load local dependencies

const root                          = path.dirname(__dirname);

const Throwable                     = require(path.join(root, "Throwable.js"));

const Exception                     = require(path.join(root, "Exception.js"));

const RuntimeException              = require(path.join(root, "RuntimeException.js"));

const UnsupportedOperationException = require(path.join(root, "UnsupportedOperationException.js"));

// :: TESTING

// test the UnsupportedOperationException 'class'

describe("UnsupportedOperationException", () => {

    // :: INHERITED PROTOTYPE

    it("should inherit from 'Object'", () => {

        expect(new UnsupportedOperationException()).toEqual(jasmine.any(Object));

    });

	it("should inherit from 'Throwable'", () => {

		expect(new UnsupportedOperationException()).toEqual(jasmine.any(Throwable));

	});

	it("should inherit from 'Exception'", () => {

		expect(new UnsupportedOperationException()).toEqual(jasmine.any(Exception));

	});

    it("should inherit from 'RuntimeException'", () => {

        expect(new UnsupportedOperationException()).toEqual(jasmine.any(RuntimeException));

    });

	it("should have a prototype method named 'toString()'", () => {

		expect(UnsupportedOperationException.prototype).toHaveMethod("toString");

	});

	it("should have a prototype method named 'native()'", () => {

		expect(UnsupportedOperationException.prototype).toHaveMethod("native");

	});

	it("should have a prototype property string named 'name'", () => {

		expect(UnsupportedOperationException.prototype).toHaveString("name");

	});

	it("should have a prototype property string named 'message'", () => {

		expect(UnsupportedOperationException.prototype).toHaveString("message");

	});

	it("should have a prototype property string named 'code'", () => {

		expect(UnsupportedOperationException.prototype).toHaveMember("code");

	});

    // :: EXTENDED PROTOTYPE

    // :: PROTOTYPE VALUES

    it("should have the 'class' name in the prototype property named 'name'", () => {

        expect(UnsupportedOperationException.prototype.name).toEqual("UnsupportedOperationException");

    });

    it("should have a dummy default value as message", () => {

        expect(UnsupportedOperationException.prototype.message).toEqual("thrown");

    });

    it("should have a null default value as code", () => {

        expect(UnsupportedOperationException.prototype.code).toBeNull();

    });

    // :: CONSTRUCTOR

    it("should instantiate without parameters", () => {

        let arg1, arg2, test;

        test = (() => new UnsupportedOperationException(arg1, arg2));

        for (let i = 0; i < 2; i += 1) {

            for (let j = 0; j < 2; j += 1) {

                arg1 = (i % 2 === 0 ? undefined : null);

                arg2 = (j % 2 === 0 ? undefined : null);

                expect(test).not.toThrowError("parameter 'name' must be a 'string'");

                expect(test).not.toThrowError("parameter 'message' must be a 'string'");

                expect(test).not.toThrowError("parameter 'code' must be a 'number'");

            }

        }

        test = (() => new UnsupportedOperationException());

        expect(test).not.toThrowError("parameter 'name' must be a 'string'");

        expect(test).not.toThrowError("parameter 'message' must be a 'string'");

        expect(test).not.toThrowError("parameter 'code' must be a 'number'");

    });

    it("should instantiate with parameters", () => {

        let arg1, arg2, test1, test2;

        const args1 = [undefined, null, UnsupportedOperationException.prototype.message];

        const args2 = [undefined, null, Math.round(Math.random() * 0xFFFFFFFF)];

        test1       = (() => new UnsupportedOperationException(arg1));

        test2       = (() => new UnsupportedOperationException(arg1, arg2));

        for (let i = 0; i < args1.length; i += 1) {

            arg1 = args1[i];

            for (let j = 0; j < args2.length; j += 1) {

                arg2 = args2[j];

                expect(test2).not.toThrowError("parameter 'message' must be a 'string'");

                expect(test2).not.toThrowError("parameter 'code' must be a 'number'");

            }

            expect(test1).not.toThrowError("parameter 'message' must be a 'string'");

            expect(test1).not.toThrowError("parameter 'code' must be a 'number'");

        }

    });

    it("should throw an Error if 'message' or 'code' are invalid parameters", () => {

        let arg1, arg2, test21, test22, test11;

        const noStr = [{}, true, false, 42, 3.1416, -42, -3.1416, () => null];

        const noNmb = [{}, true, false, '', "qwerty", () => null];

        test22      = (() => new UnsupportedOperationException(arg1, arg2));

        test21      = (() => new UnsupportedOperationException(null, arg2));

        test11      = (() => new UnsupportedOperationException(arg1));

        if (typeof Symbol === "function") {

            noStr.push(Symbol("symbol"));

            noNmb.push(Symbol("symbol"));

        }

        for (let i = 0; i < noStr.length; i += 1) {

            arg1 = noStr[i];

            for (let j = 0; j < noNmb.length; j += 1) {

                arg2 = noNmb[j];

                expect(test22).toThrowError("parameter 'message' must be a 'string'");

                expect(test21).toThrowError("parameter 'code' must be a 'number'");

            }

            expect(test11).toThrowError("parameter 'message' must be a 'string'");

        }

    });

    // :: MEMBER PROPERTIES

    it("should have all correct properties once instantiated", () => {

        const message = "asdf";

        const code    = Math.round(Math.random() * 0xFFFFFFFF);

        for (let i = 0; i < 2; i += 1) {

            const arg1    = (i % 2 === 0 ? message : null);

            const source1 = new UnsupportedOperationException(arg1);

            for (let j = 0; j < 2; j += 1) {

                const arg2    = (j % 2 === 0 ? code : null);

                const source2 = new UnsupportedOperationException(arg1, arg2);

                if (i % 2 === 0) {

                    expect(source1.message).toEqual(message);

                    expect(source2.message).toEqual(message);

                } else {

                    expect(source1.message).toEqual(UnsupportedOperationException.prototype.message);

                    expect(source2.message).toEqual(UnsupportedOperationException.prototype.message);

                }

                if (j % 2 === 0) {

                    expect(source2.code).toEqual(code);

                } else {

                    expect(source2.code).toBeNull();

                }

                expect(source1.code).toBeNull();

            }

        }

    });

    // :: MEMBER METHODS

    const name    = "UnsupportedOperationException";

    const message = "asdf";

    const code    = Math.round(Math.random() * 0xFFFFFFFF);

    it("#toString()", () => {

        for (let i = 0; i < 2; i += 1) {

            const arg1    = (i % 2 === 0 ? message : null);

            const source1 = new UnsupportedOperationException(arg1);

            for (let j = 0; j < 2; j += 1) {

                const arg2    = (j % 2 === 0 ? code : null);

                const source2 = new UnsupportedOperationException(arg1, arg2);

                const str1    = source1.toString();

                const str2    = source2.toString();

                let exp1, exp2;

                exp1 = exp2 = "UnsupportedOperationException";

                if (j % 2 === 0) {

                    exp2 += " (0x" + code.toString(16) + ')';

                }

                if (i % 2 === 0) {

                    exp1 += ": " + message + '.';

                    exp2 += ": " + message + '.';

                } else {

                    exp1 += ": " + UnsupportedOperationException.prototype.message + '.';

                    exp2 += ": " + UnsupportedOperationException.prototype.message + '.';

                }

                expect(str1).toEqual(exp1);

                expect(str2).toEqual(exp2);

            }

        }

    });

    it("#native()", () => {

        for (let i = 0; i < 2; i += 1) {

            const arg1    = (i % 2 === 0 ? message : null);

            const source1 = new UnsupportedOperationException(arg1);

            for (let j = 0; j < 2; j += 1) {

                const arg2    = (j % 2 === 0 ? code : null);

                const source2 = new UnsupportedOperationException(arg1, arg2);

                const err1    = source1.native();

                const err2    = source2.native();

                const exp1    = (i % 2 === 0 ? message : UnsupportedOperationException.prototype.message);

                const exp2    = exp1;

                expect(err1).toEqual(new Error(exp1));

                expect(err2).toEqual(new Error(exp2));

            }

        }

    });

});

// spec/IllegalArgumentException.spec.js

"use strict";

// :: DEPENDENCIES

// load native dependencies

const path = require("path");

// load local dependencies

const root                     = path.dirname(__dirname);

const Throwable                = require(path.join(root, "Throwable.js"));

const Exception                = require(path.join(root, "Exception.js"));

const RuntimeException         = require(path.join(root, "RuntimeException.js"));

const IllegalArgumentException = require(path.join(root, "IllegalArgumentException.js"));

// :: TESTING

// test the IllegalArgumentException 'class'

describe("IllegalArgumentException", () => {

    // :: INHERITED PROTOTYPE

    it("should inherit from 'Object'", () => {

        expect(new IllegalArgumentException()).toEqual(jasmine.any(Object));

    });

	it("should inherit from 'Throwable'", () => {

		expect(new IllegalArgumentException()).toEqual(jasmine.any(Throwable));

	});

	it("should inherit from 'Exception'", () => {

		expect(new IllegalArgumentException()).toEqual(jasmine.any(Exception));

	});

    it("should inherit from 'RuntimeException'", () => {

        expect(new IllegalArgumentException()).toEqual(jasmine.any(RuntimeException));

    });

	it("should have a prototype method named 'toString()'", () => {

		expect(IllegalArgumentException.prototype).toHaveMethod("toString");

	});

	it("should have a prototype method named 'native()'", () => {

		expect(IllegalArgumentException.prototype).toHaveMethod("native");

	});

	it("should have a prototype property string named 'name'", () => {

		expect(IllegalArgumentException.prototype).toHaveString("name");

	});

	it("should have a prototype property string named 'message'", () => {

		expect(IllegalArgumentException.prototype).toHaveString("message");

	});

	it("should have a prototype property string named 'code'", () => {

		expect(IllegalArgumentException.prototype).toHaveMember("code");

	});

    // :: EXTENDED PROTOTYPE

    // :: PROTOTYPE VALUES

    it("should have the 'class' name in the prototype property named 'name'", () => {

        expect(IllegalArgumentException.prototype.name).toEqual("IllegalArgumentException");

    });

    it("should have a dummy default value as message", () => {

        expect(IllegalArgumentException.prototype.message).toEqual("thrown");

    });

    it("should have a null default value as code", () => {

        expect(IllegalArgumentException.prototype.code).toBeNull();

    });

    // :: CONSTRUCTOR

    it("should instantiate without parameters", () => {

        let arg1, arg2, test;

        test = (() => new IllegalArgumentException(arg1, arg2));

        for (let i = 0; i < 2; i += 1) {

            for (let j = 0; j < 2; j += 1) {

                arg1 = (i % 2 === 0 ? undefined : null);

                arg2 = (j % 2 === 0 ? undefined : null);

                expect(test).not.toThrowError("parameter 'name' must be a 'string'");

                expect(test).not.toThrowError("parameter 'message' must be a 'string'");

                expect(test).not.toThrowError("parameter 'code' must be a 'number'");

            }

        }

        test = (() => new IllegalArgumentException());

        expect(test).not.toThrowError("parameter 'name' must be a 'string'");

        expect(test).not.toThrowError("parameter 'message' must be a 'string'");

        expect(test).not.toThrowError("parameter 'code' must be a 'number'");

    });

    it("should instantiate with parameters", () => {

        let arg1, arg2, test1, test2;

        const args1 = [undefined, null, IllegalArgumentException.prototype.message];

        const args2 = [undefined, null, Math.round(Math.random() * 0xFFFFFFFF)];

        test1       = (() => new IllegalArgumentException(arg1));

        test2       = (() => new IllegalArgumentException(arg1, arg2));

        for (let i = 0; i < args1.length; i += 1) {

            arg1 = args1[i];

            for (let j = 0; j < args2.length; j += 1) {

                arg2 = args2[j];

                expect(test2).not.toThrowError("parameter 'message' must be a 'string'");

                expect(test2).not.toThrowError("parameter 'code' must be a 'number'");

            }

            expect(test1).not.toThrowError("parameter 'message' must be a 'string'");

            expect(test1).not.toThrowError("parameter 'code' must be a 'number'");

        }

    });

    it("should throw an Error if 'message' or 'code' are invalid parameters", () => {

        let arg1, arg2, test21, test22, test11;

        const noStr = [{}, true, false, 42, 3.1416, -42, -3.1416, () => null];

        const noNmb = [{}, true, false, '', "qwerty", () => null];

        test22      = (() => new IllegalArgumentException(arg1, arg2));

        test21      = (() => new IllegalArgumentException(null, arg2));

        test11      = (() => new IllegalArgumentException(arg1));

        if (typeof Symbol === "function") {

            noStr.push(Symbol("symbol"));

            noNmb.push(Symbol("symbol"));

        }

        for (let i = 0; i < noStr.length; i += 1) {

            arg1 = noStr[i];

            for (let j = 0; j < noNmb.length; j += 1) {

                arg2 = noNmb[j];

                expect(test22).toThrowError("parameter 'message' must be a 'string'");

                expect(test21).toThrowError("parameter 'code' must be a 'number'");

            }

            expect(test11).toThrowError("parameter 'message' must be a 'string'");

        }

    });

    // :: MEMBER PROPERTIES

    it("should have all correct properties once instantiated", () => {

        const message = "asdf";

        const code    = Math.round(Math.random() * 0xFFFFFFFF);

        for (let i = 0; i < 2; i += 1) {

            const arg1    = (i % 2 === 0 ? message : null);

            const source1 = new IllegalArgumentException(arg1);

            for (let j = 0; j < 2; j += 1) {

                const arg2    = (j % 2 === 0 ? code : null);

                const source2 = new IllegalArgumentException(arg1, arg2);

                if (i % 2 === 0) {

                    expect(source1.message).toEqual(message);

                    expect(source2.message).toEqual(message);

                } else {

                    expect(source1.message).toEqual(IllegalArgumentException.prototype.message);

                    expect(source2.message).toEqual(IllegalArgumentException.prototype.message);

                }

                if (j % 2 === 0) {

                    expect(source2.code).toEqual(code);

                } else {

                    expect(source2.code).toBeNull();

                }

                expect(source1.code).toBeNull();

            }

        }

    });

    // :: MEMBER METHODS

    const name    = "IllegalArgumentException";

    const message = "asdf";

    const code    = Math.round(Math.random() * 0xFFFFFFFF);

    it("#toString()", () => {

        for (let i = 0; i < 2; i += 1) {

            const arg1    = (i % 2 === 0 ? message : null);

            const source1 = new IllegalArgumentException(arg1);

            for (let j = 0; j < 2; j += 1) {

                const arg2    = (j % 2 === 0 ? code : null);

                const source2 = new IllegalArgumentException(arg1, arg2);

                const str1    = source1.toString();

                const str2    = source2.toString();

                let exp1, exp2;

                exp1 = exp2 = "IllegalArgumentException";

                if (j % 2 === 0) {

                    exp2 += " (0x" + code.toString(16) + ')';

                }

                if (i % 2 === 0) {

                    exp1 += ": " + message + '.';

                    exp2 += ": " + message + '.';

                } else {

                    exp1 += ": " + IllegalArgumentException.prototype.message + '.';

                    exp2 += ": " + IllegalArgumentException.prototype.message + '.';

                }

                expect(str1).toEqual(exp1);

                expect(str2).toEqual(exp2);

            }

        }

    });

    it("#native()", () => {

        for (let i = 0; i < 2; i += 1) {

            const arg1    = (i % 2 === 0 ? message : null);

            const source1 = new IllegalArgumentException(arg1);

            for (let j = 0; j < 2; j += 1) {

                const arg2    = (j % 2 === 0 ? code : null);

                const source2 = new IllegalArgumentException(arg1, arg2);

                const err1    = source1.native();

                const err2    = source2.native();

                const exp1    = (i % 2 === 0 ? message : IllegalArgumentException.prototype.message);

                const exp2    = exp1;

                expect(err1).toEqual(new Error(exp1));

                expect(err2).toEqual(new Error(exp2));

            }

        }

    });

});

// spec/NullPointerException.spec.js

"use strict";

// :: DEPENDENCIES

// load native dependencies

const path = require("path");

// load local dependencies

const root                 = path.dirname(__dirname);

const Throwable            = require(path.join(root, "Throwable.js"));

const Exception            = require(path.join(root, "Exception.js"));

const RuntimeException     = require(path.join(root, "RuntimeException.js"));

const NullPointerException = require(path.join(root, "NullPointerException.js"));

// :: TESTING

// test the NullPointerException 'class'

describe("NullPointerException", () => {

    // :: INHERITED PROTOTYPE

    it("should inherit from 'Object'", () => {

        expect(new NullPointerException()).toEqual(jasmine.any(Object));

    });

	it("should inherit from 'Throwable'", () => {

		expect(new NullPointerException()).toEqual(jasmine.any(Throwable));

	});

	it("should inherit from 'Exception'", () => {

		expect(new NullPointerException()).toEqual(jasmine.any(Exception));

	});

    it("should inherit from 'RuntimeException'", () => {

        expect(new NullPointerException()).toEqual(jasmine.any(RuntimeException));

    });

	it("should have a prototype method named 'toString()'", () => {

		expect(NullPointerException.prototype).toHaveMethod("toString");

	});

	it("should have a prototype method named 'native()'", () => {

		expect(NullPointerException.prototype).toHaveMethod("native");

	});

	it("should have a prototype property string named 'name'", () => {

		expect(NullPointerException.prototype).toHaveString("name");

	});

	it("should have a prototype property string named 'message'", () => {

		expect(NullPointerException.prototype).toHaveString("message");

	});

	it("should have a prototype property string named 'code'", () => {

		expect(NullPointerException.prototype).toHaveMember("code");

	});

    // :: EXTENDED PROTOTYPE

    // :: PROTOTYPE VALUES

    it("should have the 'class' name in the prototype property named 'name'", () => {

        expect(NullPointerException.prototype.name).toEqual("NullPointerException");

    });

    it("should have a dummy default value as message", () => {

        expect(NullPointerException.prototype.message).toEqual("thrown");

    });

    it("should have a null default value as code", () => {

        expect(NullPointerException.prototype.code).toBeNull();

    });

    // :: CONSTRUCTOR

    it("should instantiate without parameters", () => {

        let arg1, arg2, test;

        test = (() => new NullPointerException(arg1, arg2));

        for (let i = 0; i < 2; i += 1) {

            for (let j = 0; j < 2; j += 1) {

                arg1 = (i % 2 === 0 ? undefined : null);

                arg2 = (j % 2 === 0 ? undefined : null);

                expect(test).not.toThrowError("parameter 'name' must be a 'string'");

                expect(test).not.toThrowError("parameter 'message' must be a 'string'");

                expect(test).not.toThrowError("parameter 'code' must be a 'number'");

            }

        }

        test = (() => new NullPointerException());

        expect(test).not.toThrowError("parameter 'name' must be a 'string'");

        expect(test).not.toThrowError("parameter 'message' must be a 'string'");

        expect(test).not.toThrowError("parameter 'code' must be a 'number'");

    });

    it("should instantiate with parameters", () => {

        let arg1, arg2, test1, test2;

        const args1 = [undefined, null, NullPointerException.prototype.message];

        const args2 = [undefined, null, Math.round(Math.random() * 0xFFFFFFFF)];

        test1       = (() => new NullPointerException(arg1));

        test2       = (() => new NullPointerException(arg1, arg2));

        for (let i = 0; i < args1.length; i += 1) {

            arg1 = args1[i];

            for (let j = 0; j < args2.length; j += 1) {

                arg2 = args2[j];

                expect(test2).not.toThrowError("parameter 'message' must be a 'string'");

                expect(test2).not.toThrowError("parameter 'code' must be a 'number'");

            }

            expect(test1).not.toThrowError("parameter 'message' must be a 'string'");

            expect(test1).not.toThrowError("parameter 'code' must be a 'number'");

        }

    });

    it("should throw an Error if 'message' or 'code' are invalid parameters", () => {

        let arg1, arg2, test21, test22, test11;

        const noStr = [{}, true, false, 42, 3.1416, -42, -3.1416, () => null];

        const noNmb = [{}, true, false, '', "qwerty", () => null];

        test22      = (() => new NullPointerException(arg1, arg2));

        test21      = (() => new NullPointerException(null, arg2));

        test11      = (() => new NullPointerException(arg1));

        if (typeof Symbol === "function") {

            noStr.push(Symbol("symbol"));

            noNmb.push(Symbol("symbol"));

        }

        for (let i = 0; i < noStr.length; i += 1) {

            arg1 = noStr[i];

            for (let j = 0; j < noNmb.length; j += 1) {

                arg2 = noNmb[j];

                expect(test22).toThrowError("parameter 'message' must be a 'string'");

                expect(test21).toThrowError("parameter 'code' must be a 'number'");

            }

            expect(test11).toThrowError("parameter 'message' must be a 'string'");

        }

    });

    // :: MEMBER PROPERTIES

    it("should have all correct properties once instantiated", () => {

        const message = "asdf";

        const code    = Math.round(Math.random() * 0xFFFFFFFF);

        for (let i = 0; i < 2; i += 1) {

            const arg1    = (i % 2 === 0 ? message : null);

            const source1 = new NullPointerException(arg1);

            for (let j = 0; j < 2; j += 1) {

                const arg2    = (j % 2 === 0 ? code : null);

                const source2 = new NullPointerException(arg1, arg2);

                if (i % 2 === 0) {

                    expect(source1.message).toEqual(message);

                    expect(source2.message).toEqual(message);

                } else {

                    expect(source1.message).toEqual(NullPointerException.prototype.message);

                    expect(source2.message).toEqual(NullPointerException.prototype.message);

                }

                if (j % 2 === 0) {

                    expect(source2.code).toEqual(code);

                } else {

                    expect(source2.code).toBeNull();

                }

                expect(source1.code).toBeNull();

            }

        }

    });

    // :: MEMBER METHODS

    const name    = "NullPointerException";

    const message = "asdf";

    const code    = Math.round(Math.random() * 0xFFFFFFFF);

    it("#toString()", () => {

        for (let i = 0; i < 2; i += 1) {

            const arg1    = (i % 2 === 0 ? message : null);

            const source1 = new NullPointerException(arg1);

            for (let j = 0; j < 2; j += 1) {

                const arg2    = (j % 2 === 0 ? code : null);

                const source2 = new NullPointerException(arg1, arg2);

                const str1    = source1.toString();

                const str2    = source2.toString();

                let exp1, exp2;

                exp1 = exp2 = "NullPointerException";

                if (j % 2 === 0) {

                    exp2 += " (0x" + code.toString(16) + ')';

                }

                if (i % 2 === 0) {

                    exp1 += ": " + message + '.';

                    exp2 += ": " + message + '.';

                } else {

                    exp1 += ": " + NullPointerException.prototype.message + '.';

                    exp2 += ": " + NullPointerException.prototype.message + '.';

                }

                expect(str1).toEqual(exp1);

                expect(str2).toEqual(exp2);

            }

        }

    });

    it("#native()", () => {

        for (let i = 0; i < 2; i += 1) {

            const arg1    = (i % 2 === 0 ? message : null);

            const source1 = new NullPointerException(arg1);

            for (let j = 0; j < 2; j += 1) {

                const arg2    = (j % 2 === 0 ? code : null);

                const source2 = new NullPointerException(arg1, arg2);

                const err1    = source1.native();

                const err2    = source2.native();

                const exp1    = (i % 2 === 0 ? message : NullPointerException.prototype.message);

                const exp2    = exp1;

                expect(err1).toEqual(new Error(exp1));

                expect(err2).toEqual(new Error(exp2));

            }

        }

    });

});

// spec/CompletionException.spec.js

"use strict";

// :: DEPENDENCIES

// load native dependencies

const path = require("path");

// load local dependencies

const root                = path.dirname(__dirname);

const Throwable           = require(path.join(root, "Throwable.js"));

const Exception           = require(path.join(root, "Exception.js"));

const RuntimeException    = require(path.join(root, "RuntimeException.js"));

const CompletionException = require(path.join(root, "CompletionException.js"));

// :: TESTING

// test the CompletionException 'class'

describe("CompletionException", () => {

    // :: INHERITED PROTOTYPE

    it("should inherit from 'Object'", () => {

        expect(new CompletionException()).toEqual(jasmine.any(Object));

    });

	it("should inherit from 'Throwable'", () => {

		expect(new CompletionException()).toEqual(jasmine.any(Throwable));

	});

	it("should inherit from 'Exception'", () => {

		expect(new CompletionException()).toEqual(jasmine.any(Exception));

	});

    it("should inherit from 'RuntimeException'", () => {

        expect(new CompletionException()).toEqual(jasmine.any(RuntimeException));

    });

	it("should have a prototype method named 'toString()'", () => {

		expect(CompletionException.prototype).toHaveMethod("toString");

	});

	it("should have a prototype method named 'native()'", () => {

		expect(CompletionException.prototype).toHaveMethod("native");

	});

	it("should have a prototype property string named 'name'", () => {

		expect(CompletionException.prototype).toHaveString("name");

	});

	it("should have a prototype property string named 'message'", () => {

		expect(CompletionException.prototype).toHaveString("message");

	});

	it("should have a prototype property string named 'code'", () => {

		expect(CompletionException.prototype).toHaveMember("code");

	});

    // :: EXTENDED PROTOTYPE

    // :: PROTOTYPE VALUES

    it("should have the 'class' name in the prototype property named 'name'", () => {

        expect(CompletionException.prototype.name).toEqual("CompletionException");

    });

    it("should have a dummy default value as message", () => {

        expect(CompletionException.prototype.message).toEqual("thrown");

    });

    it("should have a null default value as code", () => {

        expect(CompletionException.prototype.code).toBeNull();

    });

    // :: CONSTRUCTOR

    it("should instantiate without parameters", () => {

        let arg1, arg2, test;

        test = (() => new CompletionException(arg1, arg2));

        for (let i = 0; i < 2; i += 1) {

            for (let j = 0; j < 2; j += 1) {

                arg1 = (i % 2 === 0 ? undefined : null);

                arg2 = (j % 2 === 0 ? undefined : null);

                expect(test).not.toThrowError("parameter 'name' must be a 'string'");

                expect(test).not.toThrowError("parameter 'message' must be a 'string'");

                expect(test).not.toThrowError("parameter 'code' must be a 'number'");

            }

        }

        test = (() => new CompletionException());

        expect(test).not.toThrowError("parameter 'name' must be a 'string'");

        expect(test).not.toThrowError("parameter 'message' must be a 'string'");

        expect(test).not.toThrowError("parameter 'code' must be a 'number'");

    });

    it("should instantiate with parameters", () => {

        let arg1, arg2, test1, test2;

        const args1 = [undefined, null, CompletionException.prototype.message];

        const args2 = [undefined, null, Math.round(Math.random() * 0xFFFFFFFF)];

        test1       = (() => new CompletionException(arg1));

        test2       = (() => new CompletionException(arg1, arg2));

        for (let i = 0; i < args1.length; i += 1) {

            arg1 = args1[i];

            for (let j = 0; j < args2.length; j += 1) {

                arg2 = args2[j];

                expect(test2).not.toThrowError("parameter 'message' must be a 'string'");

                expect(test2).not.toThrowError("parameter 'code' must be a 'number'");

            }

            expect(test1).not.toThrowError("parameter 'message' must be a 'string'");

            expect(test1).not.toThrowError("parameter 'code' must be a 'number'");

        }

    });

    it("should throw an Error if 'message' or 'code' are invalid parameters", () => {

        let arg1, arg2, test21, test22, test11;

        const noStr = [{}, true, false, 42, 3.1416, -42, -3.1416, () => null];

        const noNmb = [{}, true, false, '', "qwerty", () => null];

        test22      = (() => new CompletionException(arg1, arg2));

        test21      = (() => new CompletionException(null, arg2));

        test11      = (() => new CompletionException(arg1));

        if (typeof Symbol === "function") {

            noStr.push(Symbol("symbol"));

            noNmb.push(Symbol("symbol"));

        }

        for (let i = 0; i < noStr.length; i += 1) {

            arg1 = noStr[i];

            for (let j = 0; j < noNmb.length; j += 1) {

                arg2 = noNmb[j];

                expect(test22).toThrowError("parameter 'message' must be a 'string'");

                expect(test21).toThrowError("parameter 'code' must be a 'number'");

            }

            expect(test11).toThrowError("parameter 'message' must be a 'string'");

        }

    });

    // :: MEMBER PROPERTIES

    it("should have all correct properties once instantiated", () => {

        const message = "asdf";

        const code    = Math.round(Math.random() * 0xFFFFFFFF);

        for (let i = 0; i < 2; i += 1) {

            const arg1    = (i % 2 === 0 ? message : null);

            const source1 = new CompletionException(arg1);

            for (let j = 0; j < 2; j += 1) {

                const arg2    = (j % 2 === 0 ? code : null);

                const source2 = new CompletionException(arg1, arg2);

                if (i % 2 === 0) {

                    expect(source1.message).toEqual(message);

                    expect(source2.message).toEqual(message);

                } else {

                    expect(source1.message).toEqual(CompletionException.prototype.message);

                    expect(source2.message).toEqual(CompletionException.prototype.message);

                }

                if (j % 2 === 0) {

                    expect(source2.code).toEqual(code);

                } else {

                    expect(source2.code).toBeNull();

                }

                expect(source1.code).toBeNull();

            }

        }

    });

    // :: MEMBER METHODS

    const name    = "CompletionException";

    const message = "asdf";

    const code    = Math.round(Math.random() * 0xFFFFFFFF);

    it("#toString()", () => {

        for (let i = 0; i < 2; i += 1) {

            const arg1    = (i % 2 === 0 ? message : null);

            const source1 = new CompletionException(arg1);

            for (let j = 0; j < 2; j += 1) {

                const arg2    = (j % 2 === 0 ? code : null);

                const source2 = new CompletionException(arg1, arg2);

                const str1    = source1.toString();

                const str2    = source2.toString();

                let exp1, exp2;

                exp1 = exp2 = "CompletionException";

                if (j % 2 === 0) {

                    exp2 += " (0x" + code.toString(16) + ')';

                }

                if (i % 2 === 0) {

                    exp1 += ": " + message + '.';

                    exp2 += ": " + message + '.';

                } else {

                    exp1 += ": " + CompletionException.prototype.message + '.';

                    exp2 += ": " + CompletionException.prototype.message + '.';

                }

                expect(str1).toEqual(exp1);

                expect(str2).toEqual(exp2);

            }

        }

    });

    it("#native()", () => {

        for (let i = 0; i < 2; i += 1) {

            const arg1    = (i % 2 === 0 ? message : null);

            const source1 = new CompletionException(arg1);

            for (let j = 0; j < 2; j += 1) {

                const arg2    = (j % 2 === 0 ? code : null);

                const source2 = new CompletionException(arg1, arg2);

                const err1    = source1.native();

                const err2    = source2.native();

                const exp1    = (i % 2 === 0 ? message : CompletionException.prototype.message);

                const exp2    = exp1;

                expect(err1).toEqual(new Error(exp1));

                expect(err2).toEqual(new Error(exp2));

            }

        }

    });

});

// spec/IndexOutOfBoundsException.spec.js

"use strict";

// :: DEPENDENCIES

// load native dependencies

const path = require("path");

// load local dependencies

const root                      = path.dirname(__dirname);

const Throwable                 = require(path.join(root, "Throwable.js"));

const Exception                 = require(path.join(root, "Exception.js"));

const RuntimeException          = require(path.join(root, "RuntimeException.js"));

const IndexOutOfBoundsException = require(path.join(root, "IndexOutOfBoundsException.js"));

// :: TESTING

// test the IndexOutOfBoundsException 'class'

describe("IndexOutOfBoundsException", () => {

    // :: INHERITED PROTOTYPE

    it("should inherit from 'Object'", () => {

        expect(new IndexOutOfBoundsException()).toEqual(jasmine.any(Object));

    });

	it("should inherit from 'Throwable'", () => {

		expect(new IndexOutOfBoundsException()).toEqual(jasmine.any(Throwable));

	});

	it("should inherit from 'Exception'", () => {

		expect(new IndexOutOfBoundsException()).toEqual(jasmine.any(Exception));

	});

    it("should inherit from 'RuntimeException'", () => {

        expect(new IndexOutOfBoundsException()).toEqual(jasmine.any(RuntimeException));

    });

	it("should have a prototype method named 'toString()'", () => {

		expect(IndexOutOfBoundsException.prototype).toHaveMethod("toString");

	});

	it("should have a prototype method named 'native()'", () => {

		expect(IndexOutOfBoundsException.prototype).toHaveMethod("native");

	});

	it("should have a prototype property string named 'name'", () => {

		expect(IndexOutOfBoundsException.prototype).toHaveString("name");

	});

	it("should have a prototype property string named 'message'", () => {

		expect(IndexOutOfBoundsException.prototype).toHaveString("message");

	});

	it("should have a prototype property string named 'code'", () => {

		expect(IndexOutOfBoundsException.prototype).toHaveMember("code");

	});

    // :: EXTENDED PROTOTYPE

    // :: PROTOTYPE VALUES

    it("should have the 'class' name in the prototype property named 'name'", () => {

        expect(IndexOutOfBoundsException.prototype.name).toEqual("IndexOutOfBoundsException");

    });

    it("should have a dummy default value as message", () => {

        expect(IndexOutOfBoundsException.prototype.message).toEqual("thrown");

    });

    it("should have a null default value as code", () => {

        expect(IndexOutOfBoundsException.prototype.code).toBeNull();

    });

    // :: CONSTRUCTOR

    it("should instantiate without parameters", () => {

        let arg1, arg2, test;

        test = (() => new IndexOutOfBoundsException(arg1, arg2));

        for (let i = 0; i < 2; i += 1) {

            for (let j = 0; j < 2; j += 1) {

                arg1 = (i % 2 === 0 ? undefined : null);

                arg2 = (j % 2 === 0 ? undefined : null);

                expect(test).not.toThrowError("parameter 'name' must be a 'string'");

                expect(test).not.toThrowError("parameter 'message' must be a 'string'");

                expect(test).not.toThrowError("parameter 'code' must be a 'number'");

            }

        }

        test = (() => new IndexOutOfBoundsException());

        expect(test).not.toThrowError("parameter 'name' must be a 'string'");

        expect(test).not.toThrowError("parameter 'message' must be a 'string'");

        expect(test).not.toThrowError("parameter 'code' must be a 'number'");

    });

    it("should instantiate with parameters", () => {

        let arg1, arg2, test1, test2;

        const args1 = [undefined, null, IndexOutOfBoundsException.prototype.message];

        const args2 = [undefined, null, Math.round(Math.random() * 0xFFFFFFFF)];

        test1       = (() => new IndexOutOfBoundsException(arg1));

        test2       = (() => new IndexOutOfBoundsException(arg1, arg2));

        for (let i = 0; i < args1.length; i += 1) {

            arg1 = args1[i];

            for (let j = 0; j < args2.length; j += 1) {

                arg2 = args2[j];

                expect(test2).not.toThrowError("parameter 'message' must be a 'string'");

                expect(test2).not.toThrowError("parameter 'code' must be a 'number'");

            }

            expect(test1).not.toThrowError("parameter 'message' must be a 'string'");

            expect(test1).not.toThrowError("parameter 'code' must be a 'number'");

        }

    });

    it("should throw an Error if 'message' or 'code' are invalid parameters", () => {

        let arg1, arg2, test21, test22, test11;

        const noStr = [{}, true, false, 42, 3.1416, -42, -3.1416, () => null];

        const noNmb = [{}, true, false, '', "qwerty", () => null];

        test22      = (() => new IndexOutOfBoundsException(arg1, arg2));

        test21      = (() => new IndexOutOfBoundsException(null, arg2));

        test11      = (() => new IndexOutOfBoundsException(arg1));

        if (typeof Symbol === "function") {

            noStr.push(Symbol("symbol"));

            noNmb.push(Symbol("symbol"));

        }

        for (let i = 0; i < noStr.length; i += 1) {

            arg1 = noStr[i];

            for (let j = 0; j < noNmb.length; j += 1) {

                arg2 = noNmb[j];

                expect(test22).toThrowError("parameter 'message' must be a 'string'");

                expect(test21).toThrowError("parameter 'code' must be a 'number'");

            }

            expect(test11).toThrowError("parameter 'message' must be a 'string'");

        }

    });

    // :: MEMBER PROPERTIES

    it("should have all correct properties once instantiated", () => {

        const message = "asdf";

        const code    = Math.round(Math.random() * 0xFFFFFFFF);

        for (let i = 0; i < 2; i += 1) {

            const arg1    = (i % 2 === 0 ? message : null);

            const source1 = new IndexOutOfBoundsException(arg1);

            for (let j = 0; j < 2; j += 1) {

                const arg2    = (j % 2 === 0 ? code : null);

                const source2 = new IndexOutOfBoundsException(arg1, arg2);

                if (i % 2 === 0) {

                    expect(source1.message).toEqual(message);

                    expect(source2.message).toEqual(message);

                } else {

                    expect(source1.message).toEqual(IndexOutOfBoundsException.prototype.message);

                    expect(source2.message).toEqual(IndexOutOfBoundsException.prototype.message);

                }

                if (j % 2 === 0) {

                    expect(source2.code).toEqual(code);

                } else {

                    expect(source2.code).toBeNull();

                }

                expect(source1.code).toBeNull();

            }

        }

    });

    // :: MEMBER METHODS

    const name    = "IndexOutOfBoundsException";

    const message = "asdf";

    const code    = Math.round(Math.random() * 0xFFFFFFFF);

    it("#toString()", () => {

        for (let i = 0; i < 2; i += 1) {

            const arg1    = (i % 2 === 0 ? message : null);

            const source1 = new IndexOutOfBoundsException(arg1);

            for (let j = 0; j < 2; j += 1) {

                const arg2    = (j % 2 === 0 ? code : null);

                const source2 = new IndexOutOfBoundsException(arg1, arg2);

                const str1    = source1.toString();

                const str2    = source2.toString();

                let exp1, exp2;

                exp1 = exp2 = "IndexOutOfBoundsException";

                if (j % 2 === 0) {

                    exp2 += " (0x" + code.toString(16) + ')';

                }

                if (i % 2 === 0) {

                    exp1 += ": " + message + '.';

                    exp2 += ": " + message + '.';

                } else {

                    exp1 += ": " + IndexOutOfBoundsException.prototype.message + '.';

                    exp2 += ": " + IndexOutOfBoundsException.prototype.message + '.';

                }

                expect(str1).toEqual(exp1);

                expect(str2).toEqual(exp2);

            }

        }

    });

    it("#native()", () => {

        for (let i = 0; i < 2; i += 1) {

            const arg1    = (i % 2 === 0 ? message : null);

            const source1 = new IndexOutOfBoundsException(arg1);

            for (let j = 0; j < 2; j += 1) {

                const arg2    = (j % 2 === 0 ? code : null);

                const source2 = new IndexOutOfBoundsException(arg1, arg2);

                const err1    = source1.native();

                const err2    = source2.native();

                const exp1    = (i % 2 === 0 ? message : IndexOutOfBoundsException.prototype.message);

                const exp2    = exp1;

                expect(err1).toEqual(new Error(exp1));

                expect(err2).toEqual(new Error(exp2));

            }

        }

    });

});

// spec/BufferOverflowException.spec.js

"use strict";

// :: DEPENDENCIES

// load native dependencies

const path = require("path");

// load local dependencies

const root                    = path.dirname(__dirname);

const Throwable               = require(path.join(root, "Throwable.js"));

const Exception               = require(path.join(root, "Exception.js"));

const RuntimeException        = require(path.join(root, "RuntimeException.js"));

const BufferOverflowException = require(path.join(root, "BufferOverflowException.js"));

// :: TESTING

// test the BufferOverflowException 'class'

describe("BufferOverflowException", () => {

    // :: INHERITED PROTOTYPE

    it("should inherit from 'Object'", () => {

        expect(new BufferOverflowException()).toEqual(jasmine.any(Object));

    });

	it("should inherit from 'Throwable'", () => {

		expect(new BufferOverflowException()).toEqual(jasmine.any(Throwable));

	});

	it("should inherit from 'Exception'", () => {

		expect(new BufferOverflowException()).toEqual(jasmine.any(Exception));

	});

    it("should inherit from 'RuntimeException'", () => {

        expect(new BufferOverflowException()).toEqual(jasmine.any(RuntimeException));

    });

	it("should have a prototype method named 'toString()'", () => {

		expect(BufferOverflowException.prototype).toHaveMethod("toString");

	});

	it("should have a prototype method named 'native()'", () => {

		expect(BufferOverflowException.prototype).toHaveMethod("native");

	});

	it("should have a prototype property string named 'name'", () => {

		expect(BufferOverflowException.prototype).toHaveString("name");

	});

	it("should have a prototype property string named 'message'", () => {

		expect(BufferOverflowException.prototype).toHaveString("message");

	});

	it("should have a prototype property string named 'code'", () => {

		expect(BufferOverflowException.prototype).toHaveMember("code");

	});

    // :: EXTENDED PROTOTYPE

    // :: PROTOTYPE VALUES

    it("should have the 'class' name in the prototype property named 'name'", () => {

        expect(BufferOverflowException.prototype.name).toEqual("BufferOverflowException");

    });

    it("should have a dummy default value as message", () => {

        expect(BufferOverflowException.prototype.message).toEqual("thrown");

    });

    it("should have a null default value as code", () => {

        expect(BufferOverflowException.prototype.code).toBeNull();

    });

    // :: CONSTRUCTOR

    it("should instantiate without parameters", () => {

        let arg1, arg2, test;

        test = (() => new BufferOverflowException(arg1, arg2));

        for (let i = 0; i < 2; i += 1) {

            for (let j = 0; j < 2; j += 1) {

                arg1 = (i % 2 === 0 ? undefined : null);

                arg2 = (j % 2 === 0 ? undefined : null);

                expect(test).not.toThrowError("parameter 'name' must be a 'string'");

                expect(test).not.toThrowError("parameter 'message' must be a 'string'");

                expect(test).not.toThrowError("parameter 'code' must be a 'number'");

            }

        }

        test = (() => new BufferOverflowException());

        expect(test).not.toThrowError("parameter 'name' must be a 'string'");

        expect(test).not.toThrowError("parameter 'message' must be a 'string'");

        expect(test).not.toThrowError("parameter 'code' must be a 'number'");

    });

    it("should instantiate with parameters", () => {

        let arg1, arg2, test1, test2;

        const args1 = [undefined, null, BufferOverflowException.prototype.message];

        const args2 = [undefined, null, Math.round(Math.random() * 0xFFFFFFFF)];

        test1       = (() => new BufferOverflowException(arg1));

        test2       = (() => new BufferOverflowException(arg1, arg2));

        for (let i = 0; i < args1.length; i += 1) {

            arg1 = args1[i];

            for (let j = 0; j < args2.length; j += 1) {

                arg2 = args2[j];

                expect(test2).not.toThrowError("parameter 'message' must be a 'string'");

                expect(test2).not.toThrowError("parameter 'code' must be a 'number'");

            }

            expect(test1).not.toThrowError("parameter 'message' must be a 'string'");

            expect(test1).not.toThrowError("parameter 'code' must be a 'number'");

        }

    });

    it("should throw an Error if 'message' or 'code' are invalid parameters", () => {

        let arg1, arg2, test21, test22, test11;

        const noStr = [{}, true, false, 42, 3.1416, -42, -3.1416, () => null];

        const noNmb = [{}, true, false, '', "qwerty", () => null];

        test22      = (() => new BufferOverflowException(arg1, arg2));

        test21      = (() => new BufferOverflowException(null, arg2));

        test11      = (() => new BufferOverflowException(arg1));

        if (typeof Symbol === "function") {

            noStr.push(Symbol("symbol"));

            noNmb.push(Symbol("symbol"));

        }

        for (let i = 0; i < noStr.length; i += 1) {

            arg1 = noStr[i];

            for (let j = 0; j < noNmb.length; j += 1) {

                arg2 = noNmb[j];

                expect(test22).toThrowError("parameter 'message' must be a 'string'");

                expect(test21).toThrowError("parameter 'code' must be a 'number'");

            }

            expect(test11).toThrowError("parameter 'message' must be a 'string'");

        }

    });

    // :: MEMBER PROPERTIES

    it("should have all correct properties once instantiated", () => {

        const message = "asdf";

        const code    = Math.round(Math.random() * 0xFFFFFFFF);

        for (let i = 0; i < 2; i += 1) {

            const arg1    = (i % 2 === 0 ? message : null);

            const source1 = new BufferOverflowException(arg1);

            for (let j = 0; j < 2; j += 1) {

                const arg2    = (j % 2 === 0 ? code : null);

                const source2 = new BufferOverflowException(arg1, arg2);

                if (i % 2 === 0) {

                    expect(source1.message).toEqual(message);

                    expect(source2.message).toEqual(message);

                } else {

                    expect(source1.message).toEqual(BufferOverflowException.prototype.message);

                    expect(source2.message).toEqual(BufferOverflowException.prototype.message);

                }

                if (j % 2 === 0) {

                    expect(source2.code).toEqual(code);

                } else {

                    expect(source2.code).toBeNull();

                }

                expect(source1.code).toBeNull();

            }

        }

    });

    // :: MEMBER METHODS

    const name    = "BufferOverflowException";

    const message = "asdf";

    const code    = Math.round(Math.random() * 0xFFFFFFFF);

    it("#toString()", () => {

        for (let i = 0; i < 2; i += 1) {

            const arg1    = (i % 2 === 0 ? message : null);

            const source1 = new BufferOverflowException(arg1);

            for (let j = 0; j < 2; j += 1) {

                const arg2    = (j % 2 === 0 ? code : null);

                const source2 = new BufferOverflowException(arg1, arg2);

                const str1    = source1.toString();

                const str2    = source2.toString();

                let exp1, exp2;

                exp1 = exp2 = "BufferOverflowException";

                if (j % 2 === 0) {

                    exp2 += " (0x" + code.toString(16) + ')';

                }

                if (i % 2 === 0) {

                    exp1 += ": " + message + '.';

                    exp2 += ": " + message + '.';

                } else {

                    exp1 += ": " + BufferOverflowException.prototype.message + '.';

                    exp2 += ": " + BufferOverflowException.prototype.message + '.';

                }

                expect(str1).toEqual(exp1);

                expect(str2).toEqual(exp2);

            }

        }

    });

    it("#native()", () => {

        for (let i = 0; i < 2; i += 1) {

            const arg1    = (i % 2 === 0 ? message : null);

            const source1 = new BufferOverflowException(arg1);

            for (let j = 0; j < 2; j += 1) {

                const arg2    = (j % 2 === 0 ? code : null);

                const source2 = new BufferOverflowException(arg1, arg2);

                const err1    = source1.native();

                const err2    = source2.native();

                const exp1    = (i % 2 === 0 ? message : BufferOverflowException.prototype.message);

                const exp2    = exp1;

                expect(err1).toEqual(new Error(exp1));

                expect(err2).toEqual(new Error(exp2));

            }

        }

    });

});

// spec/NegativeArraySizeException.spec.js

"use strict";

// :: DEPENDENCIES

// load native dependencies

const path = require("path");

// load local dependencies

const root                       = path.dirname(__dirname);

const Throwable                  = require(path.join(root, "Throwable.js"));

const Exception                  = require(path.join(root, "Exception.js"));

const RuntimeException           = require(path.join(root, "RuntimeException.js"));

const NegativeArraySizeException = require(path.join(root, "NegativeArraySizeException.js"));

// :: TESTING

// test the NegativeArraySizeException 'class'

describe("NegativeArraySizeException", () => {

    // :: INHERITED PROTOTYPE

    it("should inherit from 'Object'", () => {

        expect(new NegativeArraySizeException()).toEqual(jasmine.any(Object));

    });

	it("should inherit from 'Throwable'", () => {

		expect(new NegativeArraySizeException()).toEqual(jasmine.any(Throwable));

	});

	it("should inherit from 'Exception'", () => {

		expect(new NegativeArraySizeException()).toEqual(jasmine.any(Exception));

	});

    it("should inherit from 'RuntimeException'", () => {

        expect(new NegativeArraySizeException()).toEqual(jasmine.any(RuntimeException));

    });

	it("should have a prototype method named 'toString()'", () => {

		expect(NegativeArraySizeException.prototype).toHaveMethod("toString");

	});

	it("should have a prototype method named 'native()'", () => {

		expect(NegativeArraySizeException.prototype).toHaveMethod("native");

	});

	it("should have a prototype property string named 'name'", () => {

		expect(NegativeArraySizeException.prototype).toHaveString("name");

	});

	it("should have a prototype property string named 'message'", () => {

		expect(NegativeArraySizeException.prototype).toHaveString("message");

	});

	it("should have a prototype property string named 'code'", () => {

		expect(NegativeArraySizeException.prototype).toHaveMember("code");

	});

    // :: EXTENDED PROTOTYPE

    // :: PROTOTYPE VALUES

    it("should have the 'class' name in the prototype property named 'name'", () => {

        expect(NegativeArraySizeException.prototype.name).toEqual("NegativeArraySizeException");

    });

    it("should have a dummy default value as message", () => {

        expect(NegativeArraySizeException.prototype.message).toEqual("thrown");

    });

    it("should have a null default value as code", () => {

        expect(NegativeArraySizeException.prototype.code).toBeNull();

    });

    // :: CONSTRUCTOR

    it("should instantiate without parameters", () => {

        let arg1, arg2, test;

        test = (() => new NegativeArraySizeException(arg1, arg2));

        for (let i = 0; i < 2; i += 1) {

            for (let j = 0; j < 2; j += 1) {

                arg1 = (i % 2 === 0 ? undefined : null);