import toNumber from './toNumber';


describe('float', () => {
    test('non-number as string', () => {
        const result = toNumber('x', 'float');
        expect(result).toEqual({ value: '', isValid: false });
    });

    test('number as string', () => {
        const result = toNumber('1', 'float');
        expect(result).toEqual({ value: 1, isValid: true });
    });

    test('comma', () => {
        const result = toNumber('11,11', 'float');
        expect(result).toEqual({ value: 11.11, isValid: true });
    });

    test('dot', () => {
        const result = toNumber('11.11', 'float');
        expect(result).toEqual({ value: 11.11, isValid: true });
    });

    test('minus', () => {
        const result = toNumber('-', 'float');
        expect(result).toEqual({ value: 0, isValid: true });
    });

    test('single leading comma', () => {
        const result = toNumber(',', 'float');
        expect(result).toEqual({ value: 0, isValid: true });
    });

    test('single leading dot', () => {
        const result = toNumber('.', 'float');
        expect(result).toEqual({ value: 0, isValid: true });
    });

    test('multiple minuses', () => {
        const result = toNumber('--', 'float');
        expect(result).toEqual({ value: '', isValid: false });
    });
});

describe('float-negative-only', () => {
    test('negative number (-1) as string', () => {
        const result = toNumber('-1', 'float-negative-only');
        expect(result).toEqual({ value: -1, isValid: true });
    });

    test('number (0) as string', () => {
        const result = toNumber('0', 'float-negative-only');
        expect(result).toEqual({ value: 0, isValid: true });
    });

    test('number (1) as string', () => {
        const result = toNumber('1', 'float-negative-only');
        expect(result).toEqual({ value: '', isValid: false });
    });

    test('non-number as string', () => {
        const result = toNumber('x', 'float-negative-only');
        expect(result).toEqual({ value: '', isValid: false });
    });

    test('number (0) as string', () => {
        const result = toNumber('0', 'float-negative-only');
        expect(result).toEqual({ value: 0, isValid: true });
    });

    test('number (-1) as string', () => {
        const result = toNumber('-1', 'float-negative-only');
        expect(result).toEqual({ value: -1, isValid: true });
    });

    test('comma', () => {
        const result = toNumber('-11,11', 'float-negative-only');
        expect(result).toEqual({ value: -11.11, isValid: true });
    });

    test('dot', () => {
        const result = toNumber('-11.11', 'float-negative-only');
        expect(result).toEqual({ value: -11.11, isValid: true });
    });

    test('minus', () => {
        const result = toNumber('-', 'float-negative-only');
        expect(result).toEqual({ value: 0, isValid: true });
    });

    test('single leading comma', () => {
        const result = toNumber(',', 'float-negative-only');
        expect(result).toEqual({ value: '', isValid: false });
    });

    test('single leading dot', () => {
        const result = toNumber('.', 'float-negative-only');
        expect(result).toEqual({ value: '', isValid: false });
    });
});

describe('float-positive-only', () => {
    test('negative number (-1) as string', () => {
        const result = toNumber('-1', 'float-positive-only');
        expect(result).toEqual({ value: '', isValid: false });
    });

    test('number (0) as string', () => {
        const result = toNumber('0', 'float-positive-only');
        expect(result).toEqual({ value: 0, isValid: true });
    });

    test('number (1) as string', () => {
        const result = toNumber('1', 'float-positive-only');
        expect(result).toEqual({ value: 1, isValid: true });
    });

    test('non-number as string', () => {
        const result = toNumber('x', 'float-positive-only');
        expect(result).toEqual({ value: '', isValid: false });
    });

    test('number (0) as string', () => {
        const result = toNumber('0', 'float-positive-only');
        expect(result).toEqual({ value: 0, isValid: true });
    });

    test('number (1) as string', () => {
        const result = toNumber('1', 'float-positive-only');
        expect(result).toEqual({ value: 1, isValid: true });
    });

    test('comma', () => {
        const result = toNumber('11,11', 'float-positive-only');
        expect(result).toEqual({ value: 11.11, isValid: true });
    });

    test('dot', () => {
        const result = toNumber('11.11', 'float-positive-only');
        expect(result).toEqual({ value: 11.11, isValid: true });
    });

    test('minus', () => {
        const result = toNumber('-', 'float-positive-only');
        expect(result).toEqual({ value: '', isValid: false });
    });

    test('single leading comma', () => {
        const result = toNumber(',', 'float-positive-only');
        expect(result).toEqual({ value: 0, isValid: true });
    });

    test('single leading dot', () => {
        const result = toNumber('.', 'float-positive-only');
        expect(result).toEqual({ value: 0, isValid: true });
    });
});

describe('integer', () => {
    test('non-number as string', () => {
        const result = toNumber('x', 'integer');
        expect(result).toEqual({ value: '', isValid: false });
    });

    test('number as string', () => {
        const result = toNumber('1', 'integer');
        expect(result).toEqual({ value: 1, isValid: true });
    });

    test('negative number as string', () => {
        const result = toNumber('-1', 'integer');
        expect(result).toEqual({ value: -1, isValid: true });
    });

    test('comma', () => {
        const result = toNumber('11,11', 'integer');
        expect(result).toEqual({ value: '', isValid: false });
    });

    test('dot', () => {
        const result = toNumber('11.11', 'integer');
        expect(result).toEqual({ value: '', isValid: false });
    });

    test('minus', () => {
        const result = toNumber('-', 'integer');
        expect(result).toEqual({ value: 0, isValid: true });
    });

    test('single leading comma', () => {
        const result = toNumber(',', 'integer');
        expect(result).toEqual({ value: '', isValid: false });
    });

    test('single leading dot', () => {
        const result = toNumber('.', 'integer');
        expect(result).toEqual({ value: '', isValid: false });
    });

    test('multiple minuses', () => {
        const result = toNumber('--', 'integer');
        expect(result).toEqual({ value: '', isValid: false });
    });

});

describe('integer-negative-only', () => {
    test('negative number (-1) as string', () => {
        const result = toNumber('-1', 'integer-negative-only');
        expect(result).toEqual({ value: -1, isValid: true });
    });

    test('number (0) as string', () => {
        const result = toNumber('0', 'integer-negative-only');
        expect(result).toEqual({ value: 0, isValid: true });
    });

    test('number (1) as string', () => {
        const result = toNumber('1', 'integer-negative-only');
        expect(result).toEqual({ value: '', isValid: false });
    });

    test('non-number as string', () => {
        const result = toNumber('x', 'integer-negative-only');
        expect(result).toEqual({ value: '', isValid: false });
    });

    test('number (0) as string', () => {
        const result = toNumber('0', 'integer-negative-only');
        expect(result).toEqual({ value: 0, isValid: true });
    });

    test('number (-1) as string', () => {
        const result = toNumber('-1', 'integer-negative-only');
        expect(result).toEqual({ value: -1, isValid: true });
    });

    test('comma', () => {
        const result = toNumber('-11,11', 'integer-negative-only');
        expect(result).toEqual({ value: '', isValid: false });
    });

    test('dot', () => {
        const result = toNumber('-11.11', 'integer-negative-only');
        expect(result).toEqual({ value: '', isValid: false });
    });

    test('minus', () => {
        const result = toNumber('-', 'integer-negative-only');
        expect(result).toEqual({ value: 0, isValid: true });
    });

    test('single leading comma', () => {
        const result = toNumber(',', 'integer-negative-only');
        expect(result).toEqual({ value: '', isValid: false });
    });

    test('single leading dot', () => {
        const result = toNumber('.', 'integer-negative-only');
        expect(result).toEqual({ value: '', isValid: false });
    });
});

describe('integer-positive-only', () => {
    test('negative number (-1) as string', () => {
        const result = toNumber('-1', 'integer-positive-only');
        expect(result).toEqual({ value: '', isValid: false });
    });

    test('number (0) as string', () => {
        const result = toNumber('0', 'integer-positive-only');
        expect(result).toEqual({ value: 0, isValid: true });
    });

    test('number (1) as string', () => {
        const result = toNumber('1', 'integer-positive-only');
        expect(result).toEqual({ value: 1, isValid: true });
    });

    test('non-number as string', () => {
        const result = toNumber('x', 'integer-positive-only');
        expect(result).toEqual({ value: '', isValid: false });
    });

    test('number (0) as string', () => {
        const result = toNumber('0', 'integer-positive-only');
        expect(result).toEqual({ value: 0, isValid: true });
    });

    test('number (1) as string', () => {
        const result = toNumber('1', 'integer-positive-only');
        expect(result).toEqual({ value: 1, isValid: true });
    });

    test('comma', () => {
        const result = toNumber('11,11', 'integer-positive-only');
        expect(result).toEqual({ value: '', isValid: false });
    });

    test('dot', () => {
        const result = toNumber('11.11', 'integer-positive-only');
        expect(result).toEqual({ value: '', isValid: false });
    });

    test('minus', () => {
        const result = toNumber('-', 'integer-positive-only');
        expect(result).toEqual({ value: '', isValid: false });
    });

    test('single leading comma', () => {
        const result = toNumber(',', 'integer-positive-only');
        expect(result).toEqual({ value: '', isValid: false });
    });

    test('single leading dot', () => {
        const result = toNumber('.', 'integer-positive-only');
        expect(result).toEqual({ value: '', isValid: false });
    });
});