describe('StringBuilder class', () => {

    describe('Constructor test', () => {

        it('Empty', () => {
            let a = new StringBuilder();
            assert.deepEqual(a._stringArray, []);
        });

        it('String', () => {
            let a = new StringBuilder('string');
            assert.deepEqual(a._stringArray, ['s', 't', 'r', 'i', 'n', 'g']);
        });

        it('Number, Array, Boolean', () => {
            let a = () => new StringBuilder(5);
            let b = () => new StringBuilder([]);
            let c = () => new StringBuilder(false);

            assert.throws(a, 'Argument must be string');
            assert.throws(b, 'Argument must be string');
            assert.throws(c, 'Argument must be string');
        });
    });

    describe('.append test', () => {

        it('String', () => {
            let a = new StringBuilder('abc');
            a.append('cba');
            assert.deepEqual(a._stringArray, ['a', 'b', 'c', 'c', 'b', 'a']);
        });

        it('Boolean', () => {
            let a = new StringBuilder();
            let b = () => a.append(true);

            assert.throws(b, 'Argument must be string');
        });
    });

    describe('.prepend test', () => {

        it('String', () => {
            let a = new StringBuilder('abc');
            a.prepend('cba');
            assert.deepEqual(a._stringArray, ['c', 'b', 'a', 'a', 'b', 'c']);
        });

        it('Number', () => {
            let a = new StringBuilder();
            let b = () => a.prepend(5);
            assert.throws(b, 'Argument must be string');
        });
    });

    describe('.insertAt test', () => {

        it('Number insted of string', () => {
            let a = new StringBuilder('Debugger');
            let b = () => a.insertAt(7, 1);

            assert.throws(b, 'Argument must be string');
        });

        it('First index, Last index', () => {
            let a = new StringBuilder('abc');
            let b = new StringBuilder('abc');
            a.insertAt('h', 0);
            b.insertAt('h', 2);

            assert.deepEqual(a._stringArray, ['h', 'a', 'b', 'c']);
            assert.deepEqual(b._stringArray, ['a', 'b', 'h', 'c']);
        });

        it('Empty string, Space', () => {
            let a = new StringBuilder('abc');
            a.insertAt('', 1);
            assert.deepEqual(a._stringArray, ['a', 'b', 'c']);

            a.insertAt(' ', 1);
            assert.deepEqual(a._stringArray, ['a', ' ', 'b', 'c']);
        });
    });

    describe('.remove test', () => {

        it('Negative, Zero, Positive length', () => {
            let a = new StringBuilder('Debugger');

            a.remove(0, -1);
            assert.deepEqual(a._stringArray, ['D', 'e', 'b', 'u', 'g', 'g', 'e', 'r']);

            a.remove(0, 0);
            assert.deepEqual(a._stringArray, ['D', 'e', 'b', 'u', 'g', 'g', 'e', 'r']);

            a.remove(0, 5);
            assert.deepEqual(a._stringArray, ['g', 'e', 'r']);
        });

        it('String, Floating point, Bigger length', () => {
            let a = new StringBuilder('Debugger');

            a.remove(0, '1');
            assert.deepEqual(a._stringArray, ['e', 'b', 'u', 'g', 'g', 'e', 'r']);

            a.remove(0, 1.5);
            assert.deepEqual(a._stringArray, ['b', 'u', 'g', 'g', 'e', 'r']);

            a.remove(0, 15);
            assert.deepEqual(a._stringArray, []);
        });

        it('Array, Object, Boolean', () => {
            let a = new StringBuilder('Debugger');

            a.remove(0, []);
            assert.deepEqual(a._stringArray, ['D', 'e', 'b', 'u', 'g', 'g', 'e', 'r']);

            a.remove(0, {});
            assert.deepEqual(a._stringArray, ['D', 'e', 'b', 'u', 'g', 'g', 'e', 'r']);

            a.remove(0, true);
            assert.deepEqual(a._stringArray, ['e', 'b', 'u', 'g', 'g', 'e', 'r']);
        });
    });

    describe('.toString test', () => {

        it('Non-empty array', () => {
            let a = new StringBuilder('abc');
            let b = a.toString();

            assert.equal(b, 'abc');
        });

        it('Empty array', () => {
            let a = new StringBuilder();
            let b = a.toString();

            assert.equal(b, '');
        });
    });
})