import { VerifyUtil } from '@/core/utils/verify-util';

describe('compare unit test', () => {
	test('value and value2 is Number', () => {
        const value = 123;
        const value2 = 456;
        const value3 = 123;
		expect(VerifyUtil.compare(value, value2)).toBe(-1);
        expect(VerifyUtil.compare(value2, value)).toBe(1);
        expect(VerifyUtil.compare(value, value3)).toBe(0);
	});
    test('value and value2 is Date', () => {
        const value = 'January 12,2022 22:19:35';
        const value2 = '2022-10-22 18:25:54';
        const value3 = '2022-01-12 22:19:35';
		expect(VerifyUtil.compare(value, value2)).toBe(-1);
        expect(VerifyUtil.compare(value2, value)).toBe(1);
        expect(VerifyUtil.compare(value, value3)).toBe(0);
	});
	test('value and value2 is Boolean', () => {
        const value = true;
        const value2 = false;
        const value3 = true;
		expect(VerifyUtil.compare(value, value2)).toBe(-1);
        expect(VerifyUtil.compare(value, value3)).toBe(0);
	});
    test('value and value2 is String', () => {
        const value = 'aaa';
        const value2 = 'bbb';
        const value3 = 'aaa';
		expect(VerifyUtil.compare(value, value2)).toBe(-1);
        expect(VerifyUtil.compare(value2, value)).toBe(1);
        expect(VerifyUtil.compare(value, value3)).toBe(0);
	});
});

describe('compareString unit test', () => {
	test('value before value2', () => {
        const value = 'aaa';
        const value2 = 'bbb';
		expect(VerifyUtil.compareString(value, value2)).toBe(-1);
	});
    test('value after value2', () => {
        const value = 'bbb';
        const value2 = 'aaa';
		expect(VerifyUtil.compareString(value, value2)).toBe(1);
	});
    test('value == value2', () => {
        const value = 'aaa';
        const value2 = 'aaa';
		expect(VerifyUtil.compareString(value, value2)).toBe(0);
	});
});

describe('compareBoolean unit test', () => {
	test('value true, value2 false', () => {
        const value = true;
        const value2 = false;
		expect(VerifyUtil.compareBoolean(value, value2)).toBe(-1);
	});
    test('value false, value2 false', () => {
        const value = false;
        const value2 = false;
		expect(VerifyUtil.compareBoolean(value, value2)).toBe(0);
	});
});

describe('compareDate unit test', () => {
	test('value < value2', () => {
        const value = 1;
        const value2 = 2;
		expect(VerifyUtil.compareDate(value, value2)).toBe(-1);
	});
    test('value > value2', () => {
        const value = 3;
        const value2 = 2;
		expect(VerifyUtil.compareDate(value, value2)).toBe(1);
	});
    test('value == value2', () => {
        const value = 3;
        const value2 = 3;
		expect(VerifyUtil.compareDate(value, value2)).toBe(0);
	});
});

describe('isParseDate unit test', () => {
	test('value is date string', () => {
        const value = '2022-03-28 10:27:38';
		expect(VerifyUtil.isParseDate(value)).toBe(true);
	});
    test('value is number string', () => {
        const value = '3554353453';
		expect(VerifyUtil.isParseDate(value)).toBe(false);
	});
    test('value is any string', () => {
        const value = '{date: 2022-03-28 10:27:38}';
		expect(VerifyUtil.isParseDate(value)).toBe(false);
	});
    test("value is ''", () => {
        const value = '';
		expect(VerifyUtil.isParseDate(value)).toBe(false);
	});
});

describe('compareNumber unit test', () => {
	test('value < value2', () => {
        const value = 1;
        const value2 = 2;
		expect(VerifyUtil.compareNumber(value, value2)).toBe(-1);
	});
    test('value > value2', () => {
        const value = 3;
        const value2 = 2;
		expect(VerifyUtil.compareNumber(value, value2)).toBe(1);
	});
    test('value == value2', () => {
        const value = 3;
        const value2 = 3;
		expect(VerifyUtil.compareNumber(value, value2)).toBe(0);
	});
});

describe('contains unit test', () => {
	test('value contains value2', () => {
        const value = '文本';
        const value2 = '文本,测试,内容';
		expect(VerifyUtil.contains(value, value2)).toBe(true);
	});
    test('value not contains value2', () => {
        const value = '测试文本内容';
        const value2 = '这是一个测试,文本内容测试';
		expect(VerifyUtil.contains(value, value2)).toBe(false);
	});
    test("value is null, value2 is ''", () => {
        const value = null;
        const value2 = '';
		expect(VerifyUtil.contains(value, value2)).toBe(false);
	});
    test("value is Number, value2 is ''", () => {
        const value = 56;
        const value2 = '56,37,29';
		expect(VerifyUtil.contains(value, value2)).toBe(true);
	});
});

describe('testCond unit test', () => {
	describe('op is EQ', () => {
        const op = 'EQ';
        test('value is null, value2 is undefined', () => {
            const value = null;
            const value2 = undefined;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(true);
        });
        test('value is String, value2 is String', () => {
            const value = 'abcd';
            const value2 = 'accd';
            const value3 = 'abcd';
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(true);
        });
        test('value is Number, value2 is Number', () => {
            const value = 137;
            const value2 = 256;
            const value3 = 137;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(true);
        });
        test('value is Boolean, value2 is Boolean', () => {
            const value = true;
            const value2 = false;
            const value3 = true;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(true);
        });
        test('value is String, value2 is Number', () => {
            const value = '137';
            const value2 = 137;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(true);
        });
        test('value is String, value2 is Boolean', () => {
            const value = 'true';
            const value2 = true;
            const value3 = false;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
        });
        test('value is Number, value2 is Boolean', () => {
            const value = 0;
            const value2 = true;
            const value3 = false;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(true);
        });
	});
    describe('op is NOTEQ', () => {
        const op = 'NOTEQ';
        test('value is null, value2 is undefined', () => {
            const value = null;
            const value2 = undefined;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
        });
        test('value is String, value2 is String', () => {
            const value = 'abcd';
            const value2 = 'accd';
            const value3 = 'abcd';
            expect(VerifyUtil.testCond(value, op, value2)).toBe(true);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
        });
        test('value is Number, value2 is Number', () => {
            const value = 137;
            const value2 = 256;
            const value3 = 137;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(true);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
        });
        test('value is Boolean, value2 is Boolean', () => {
            const value = true;
            const value2 = false;
            const value3 = true;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(true);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
        });
        test('value is String, value2 is Number', () => {
            const value = '137';
            const value2 = 137;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
        });
        test('value is String, value2 is Boolean', () => {
            const value = 'true';
            const value2 = true;
            const value3 = false;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(true);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(true);
        });
        test('value is Number, value2 is Boolean', () => {
            const value = 0;
            const value2 = true;
            const value3 = false;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(true);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
        });
	});
    describe('op is GT', () => {
        const op = 'GT';
        test('value is null, value2 is undefined', () => {
            const value = null;
            const value2 = undefined;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
        });
        test('value is String, value2 is String', () => {
            const value = 'abcd';
            const value2 = 'aacd';
            const value3 = 'abcd';
            const value4 = 'accd';
            expect(VerifyUtil.testCond(value, op, value2)).toBe(true);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value4)).toBe(false);
        });
        test('value is Number, value2 is Number', () => {
            const value = 137;
            const value2 = 13;
            const value3 = 137;
            const value4 = 256;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(true);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value4)).toBe(false);
        });
        test('value is Boolean, value2 is Boolean', () => {
            const value = true;
            const value2 = false;
            const value3 = true;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
        });
        test('value is String, value2 is Number', () => {
            const value = '137';
            const value2 = 137;
            const value3 = 13;
            const value4 = 256;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(true);
            expect(VerifyUtil.testCond(value, op, value4)).toBe(false);
        });
        test('value is String, value2 is Boolean', () => {
            const value = 'true';
            const value2 = true;
            const value3 = false;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
        });
        test('value is Number, value2 is Boolean', () => {
            const value = 0;
            const value2 = true;
            const value3 = false;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
        });
	});
    describe('op is GTANDEQ', () => {
        const op = 'GTANDEQ';
        test('value is null, value2 is undefined', () => {
            const value = null;
            const value2 = undefined;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
        });
        test('value is String, value2 is String', () => {
            const value = 'abcd';
            const value2 = 'aacd';
            const value3 = 'abcd';
            const value4 = 'accd';
            expect(VerifyUtil.testCond(value, op, value2)).toBe(true);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(true);
            expect(VerifyUtil.testCond(value, op, value4)).toBe(false);
        });
        test('value is Number, value2 is Number', () => {
            const value = 137;
            const value2 = 13;
            const value3 = 137;
            const value4 = 256;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(true);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(true);
            expect(VerifyUtil.testCond(value, op, value4)).toBe(false);
        });
        test('value is Boolean, value2 is Boolean', () => {
            const value = true;
            const value2 = false;
            const value3 = true;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
        });
        test('value is String, value2 is Number', () => {
            const value = '137';
            const value2 = 137;
            const value3 = 13;
            const value4 = 256;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(true);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(true);
            expect(VerifyUtil.testCond(value, op, value4)).toBe(false);
        });
        test('value is String, value2 is Boolean', () => {
            const value = 'true';
            const value2 = true;
            const value3 = false;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
        });
        test('value is Number, value2 is Boolean', () => {
            const value = 0;
            const value2 = true;
            const value3 = false;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
        });
	});
    describe('op is LT', () => {
        const op = 'LT';
        test('value is null, value2 is undefined', () => {
            const value = null;
            const value2 = undefined;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
        });
        test('value is String, value2 is String', () => {
            const value = 'abcd';
            const value2 = 'aacd';
            const value3 = 'abcd';
            const value4 = 'accd';
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value4)).toBe(true);
        });
        test('value is Number, value2 is Number', () => {
            const value = 137;
            const value2 = 13;
            const value3 = 137;
            const value4 = 256;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value4)).toBe(true);
        });
        test('value is Boolean, value2 is Boolean', () => {
            const value = true;
            const value2 = false;
            const value3 = true;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
        });
        test('value is String, value2 is Number', () => {
            const value = '137';
            const value2 = 137;
            const value3 = 13;
            const value4 = 256;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value4)).toBe(true);
        });
        test('value is String, value2 is Boolean', () => {
            const value = 'true';
            const value2 = true;
            const value3 = false;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
        });
        test('value is Number, value2 is Boolean', () => {
            const value = 0;
            const value2 = true;
            const value3 = false;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
        });
	});
    describe('op is LTANDEQ', () => {
        const op = 'LTANDEQ';
        test('value is null, value2 is undefined', () => {
            const value = null;
            const value2 = undefined;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
        });
        test('value is String, value2 is String', () => {
            const value = 'abcd';
            const value2 = 'aacd';
            const value3 = 'abcd';
            const value4 = 'accd';
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(true);
            expect(VerifyUtil.testCond(value, op, value4)).toBe(true);
        });
        test('value is Number, value2 is Number', () => {
            const value = 137;
            const value2 = 13;
            const value3 = 137;
            const value4 = 256;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(true);
            expect(VerifyUtil.testCond(value, op, value4)).toBe(true);
        });
        test('value is Boolean, value2 is Boolean', () => {
            const value = true;
            const value2 = false;
            const value3 = true;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
        });
        test('value is String, value2 is Number', () => {
            const value = '137';
            const value2 = 137;
            const value3 = 13;
            const value4 = 256;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(true);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value4)).toBe(true);
        });
        test('value is String, value2 is Boolean', () => {
            const value = 'true';
            const value2 = true;
            const value3 = false;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
        });
        test('value is Number, value2 is Boolean', () => {
            const value = 0;
            const value2 = true;
            const value3 = false;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
        });
	});
    describe('op is IN', () => {
        const op = 'IN';
        test('value is null, value2 is undefined', () => {
            const value = null;
            const value2 = undefined;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
        });
        test('value is String, value2 is String', () => {
            const value = 'abcd';
            const value2 = 'abcd';
            const value3 = 'abcd,cddf';
            const value4 = 'cddf,addf';
            expect(VerifyUtil.testCond(value, op, value2)).toBe(true);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(true);
            expect(VerifyUtil.testCond(value, op, value4)).toBe(false);
        });
        test('value is Number, value2 is Number', () => {
            const value = 137;
            const value2 = 137;
            const value3 = 137256;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
        });
        test('value is Boolean, value2 is Boolean', () => {
            const value = true;
            const value2 = false;
            const value3 = true;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
        });
        test('value is String, value2 is Number', () => {
            const value = '137';
            const value2 = 137;
            const value3 = 137256;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
            expect(VerifyUtil.testCond(value2, op, value)).toBe(true);
            expect(VerifyUtil.testCond(value3, op, value)).toBe(false);
        });
        test('value is String, value2 is Boolean', () => {
            const value = 'true';
            const value2 = true;
            const value3 = false;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
            expect(VerifyUtil.testCond(value2, op, value)).toBe(true);
            expect(VerifyUtil.testCond(value3, op, value)).toBe(false);
        });
        test('value is Number, value2 is Boolean', () => {
            const value = 0;
            const value2 = true;
            const value3 = false;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
        });
	});
    describe('op is NOTIN', () => {
        const op = 'NOTIN';
        test('value is null, value2 is undefined', () => {
            const value = null;
            const value2 = undefined;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
        });
        test('value is String, value2 is String', () => {
            const value = 'abcd';
            const value2 = 'abcd';
            const value3 = 'abcd,cddf';
            const value4 = 'cddf,addf';
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value4)).toBe(true);
        });
        test('value is Number, value2 is Number', () => {
            const value = 137;
            const value2 = 137;
            const value3 = 137256;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
        });
        test('value is Boolean, value2 is Boolean', () => {
            const value = true;
            const value2 = false;
            const value3 = true;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
        });
        test('value is String, value2 is Number', () => {
            const value = '137';
            const value2 = 137;
            const value3 = 137256;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
            expect(VerifyUtil.testCond(value2, op, value)).toBe(false);
            expect(VerifyUtil.testCond(value3, op, value)).toBe(true);
        });
        test('value is String, value2 is Boolean', () => {
            const value = 'true';
            const value2 = true;
            const value3 = false;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
            expect(VerifyUtil.testCond(value2, op, value)).toBe(false);
            expect(VerifyUtil.testCond(value3, op, value)).toBe(true);
        });
        test('value is Number, value2 is Boolean', () => {
            const value = 0;
            const value2 = true;
            const value3 = false;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
        });
	});
    describe('op is LIKE', () => {
        const op = 'LIKE';
        test('value is null, value2 is undefined', () => {
            const value = null;
            const value2 = undefined;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value2, op, value)).toBe(false);
        });
        test('value is String, value2 is String', () => {
            const value = 'abcd';
            const value2 = 'ab';
            const value3 = 'ac';
            const value4 = '';
            expect(VerifyUtil.testCond(value, op, value2)).toBe(true);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value4)).toBe(false);
        });
        test('value is Number, value2 is Number', () => {
            const value = 137;
            const value2 = 13;
            const value3 = 256;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
        });
        test('value is Boolean, value2 is Boolean', () => {
            const value = true;
            const value2 = false;
            const value3 = true;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
        });
        test('value is String, value2 is Number', () => {
            const value = '1371';
            const value2 = 37;
            const value3 = 256;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(true);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
        });
        test('value is String, value2 is Boolean', () => {
            const value = 'true1234';
            const value2 = true;
            const value3 = false;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(true);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
        });
        test('value is Number, value2 is Boolean', () => {
            const value = 137;
            const value2 = true;
            const value3 = false;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
        });
	});
    describe('op is LEFTLIKE', () => {
        const op = 'LEFTLIKE';
        test('value is null, value2 is undefined', () => {
            const value = null;
            const value2 = undefined;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value2, op, value)).toBe(false);
        });
        test('value is String, value2 is String', () => {
            const value = 'abcd';
            const value2 = 'ab';
            const value3 = 'ac';
            const value4 = '';
            expect(VerifyUtil.testCond(value, op, value2)).toBe(true);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value4)).toBe(false);
        });
        test('value is Number, value2 is Number', () => {
            const value = 137;
            const value2 = 13;
            const value3 = 256;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
        });
        test('value is Boolean, value2 is Boolean', () => {
            const value = true;
            const value2 = false;
            const value3 = true;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
        });
        test('value is String, value2 is Number', () => {
            const value = '137';
            const value2 = 13;
            const value3 = 256;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(true);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
        });
        test('value is String, value2 is Boolean', () => {
            const value = 'true';
            const value2 = true;
            const value3 = false;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(true);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
        });
        test('value is Number, value2 is Boolean', () => {
            const value = 137;
            const value2 = true;
            const value3 = false;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
        });
	});
    describe('op is RIGHTLIKE', () => {
        const op = 'RIGHTLIKE';
        test('value is null, value2 is undefined', () => {
            const value = null;
            const value2 = undefined;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value2, op, value)).toBe(false);
        });
        test('value is String, value2 is String', () => {
            const value = 'abcd';
            const value2 = 'bc';
            const value3 = 'cd';
            const value4 = '';
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(true);
            expect(VerifyUtil.testCond(value, op, value4)).toBe(false);
        });
        test('value is Number, value2 is Number', () => {
            const value = 137;
            const value2 = 13;
            const value3 = 256;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
        });
        test('value is Boolean, value2 is Boolean', () => {
            const value = true;
            const value2 = false;
            const value3 = true;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
        });
        test('value is String, value2 is Number', () => {
            const value = '1371';
            const value2 = 13;
            const value3 = 71;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(true);
        });
        test('value is String, value2 is Boolean', () => {
            const value = '213214true';
            const value2 = true;
            const value3 = false;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(true);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
        });
        test('value is Number, value2 is Boolean', () => {
            const value = 137;
            const value2 = true;
            const value3 = false;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value, op, value3)).toBe(false);
        });
	});
    describe('op is ISNOTNULL', () => {
        const op = 'ISNOTNULL';
        test('value is null or undefined', () => {
            const value = null;
            const value2 = undefined;
            const value3 = undefined;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value3, op, value2)).toBe(false);
        });
        test('value is Number', () => {
            const value = 0;
            const value2 = undefined;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(true);
        });
        test('value is String', () => {
            const value = '';
            const value2 = undefined;
            const value3 = 'null';
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value3, op, value2)).toBe(true);
        });
        test('value is Boolean', () => {
            const value = true;
            const value2 = undefined;
            const value3 = false;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(true);
            expect(VerifyUtil.testCond(value3, op, value2)).toBe(true);
        });
	});
    describe('op is ISNULL', () => {
        const op = 'ISNULL';
        test('value is null or undefined', () => {
            const value = null;
            const value2 = undefined;
            const value3 = undefined;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(true);
            expect(VerifyUtil.testCond(value3, op, value2)).toBe(true);
        });
        test('value is Number', () => {
            const value = 0;
            const value2 = undefined;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
        });
        test('value is String', () => {
            const value = '';
            const value2 = undefined;
            const value3 = 'null';
            expect(VerifyUtil.testCond(value, op, value2)).toBe(true);
            expect(VerifyUtil.testCond(value3, op, value2)).toBe(false);
        });
        test('value is Boolean', () => {
            const value = true;
            const value2 = undefined;
            const value3 = false;
            expect(VerifyUtil.testCond(value, op, value2)).toBe(false);
            expect(VerifyUtil.testCond(value3, op, value2)).toBe(false);
        });
	});
});

describe('checkFieldSimpleRule unit test', () => {
    test('paramType is CURTIME', () => {
        const value = '2022-11-20 20:35:46';
        const op = 'LTANDEQ';
        const value2 = '2022-12-25 21:33:52';
        const errorInfo = '结束时间必须大于等于开始时间';
        const paramType = 'CURTIME';
        const form = {};
        const primaryModel = false;
        expect(VerifyUtil.checkFieldSimpleRule(value, op, value2, errorInfo, paramType, form, primaryModel)).toBe(false);
    })
    test('paramType is ENTITYFIELD', () => {
        const value = 217;
        const op = 'GT';
        const value2 = 'test';
        const errorInfo = 'value 必须大于 value2';
        const paramType = 'ENTITYFIELD';
        const form = {
            test: 333
        };
        const primaryModel = false;
        expect(VerifyUtil.checkFieldSimpleRule(value, op, value2, errorInfo, paramType, form, primaryModel)).toBe(true);
        const value3 = '123';
        expect(VerifyUtil.checkFieldSimpleRule(value, op, value3, errorInfo, paramType, form, primaryModel)).toBe(false);
    })
    test("paramType is ''", () => {
        const value = 217;
        const op = 'GT';
        const value2 = 123;
        const errorInfo = 'value 必须大于 value2';
        const paramType = '';
        const form = {};
        const primaryModel = false;
        expect(VerifyUtil.checkFieldSimpleRule(value, op, value2, errorInfo, paramType, form, primaryModel)).toBe(false);
    })
});

describe('checkFieldStringLengthRule unit test', () => {
    const primaryModel = false;
    const errorInfo = '';
    test('string length lt or lteq min length', () => {
        const viewValue = '测试字符串';
        const minLength = 5;
        let indexOfMin = false;
        expect(VerifyUtil.checkFieldStringLengthRule(viewValue, minLength, indexOfMin, null, false, errorInfo, primaryModel)).toBe(true);
        indexOfMin = true;
        expect(VerifyUtil.checkFieldStringLengthRule(viewValue, minLength, indexOfMin, null, true, errorInfo, primaryModel)).toBe(false);
    })
    test('string length gt or gteq max length', () => {
        const viewValue = '测试字符串';
        const maxLength = 5;
        let indexOfMax = false;
        expect(VerifyUtil.checkFieldStringLengthRule(viewValue, null, false, maxLength, indexOfMax, errorInfo, primaryModel)).toBe(true);
        indexOfMax = true;
        expect(VerifyUtil.checkFieldStringLengthRule(viewValue, null, true, maxLength, indexOfMax, errorInfo, primaryModel)).toBe(false);
    })
    test('string length gt minNumber and lt maxNumber', () => {
        const viewValue = '测试字符串';
        const minLength = 1;
        const maxLength = 9;
        const indexOfMin = false;
        const indexOfMax = false;
        expect(VerifyUtil.checkFieldStringLengthRule(viewValue, minLength, indexOfMin, maxLength, indexOfMax, errorInfo, primaryModel)).toBe(false);
    })
});

describe('checkFieldRegExRule unit test', () => {
    test('strReg is /A/i', () => {
        const viewValue = 'ADFSDaGGFDG';
        const viewValue2 = 'HFDGHDHFDH';
        const strReg = /A/i;
        expect(VerifyUtil.checkFieldRegExRule(viewValue, strReg, '', false)).toBe(false);
        expect(VerifyUtil.checkFieldRegExRule(viewValue2, strReg, '', false)).toBe(true);
    })
});

describe('checkFieldScriptRule unit test', () => {
    test('scriptCode test', () => {
        const scriptCode = "if(source){ console.log(1) }else{callback({message: '错误！'})}";
        expect(VerifyUtil.checkFieldScriptRule('', null, scriptCode, '', false)).toStrictEqual({ isPast: false,  infoMessage: '错误！'});
        expect(VerifyUtil.checkFieldScriptRule('', { test: 1 }, scriptCode, '', false)).toStrictEqual({ isPast: true,  infoMessage: ''});
    })
});

describe('checkFieldValueRangeRule unit test', () => {
    const primaryModel = false;
    const errorInfo = '';
    test('value lt or lteq minNumber', () => {
        const viewValue = '5';
        const minNumber = 5;
        let indexOfMin = false;
        expect(VerifyUtil.checkFieldValueRangeRule(viewValue, minNumber, indexOfMin, null, false, errorInfo, primaryModel)).toBe(true);
        indexOfMin = true;
        expect(VerifyUtil.checkFieldValueRangeRule(viewValue, minNumber, indexOfMin, null, false, errorInfo, primaryModel)).toBe(false);
    })
    test('value gt or geteq maxNumber', () => {
        const viewValue = '5';
        const maxNumber = 5;
        let indexOfMax = false;
        expect(VerifyUtil.checkFieldValueRangeRule(viewValue, null, true, maxNumber, indexOfMax, errorInfo, primaryModel)).toBe(true);
        indexOfMax = true;
        expect(VerifyUtil.checkFieldValueRangeRule(viewValue, null, false, maxNumber, indexOfMax, errorInfo, primaryModel)).toBe(false);
    })
    test('value gt minNumber and lt maxNumber', () => {
        const viewValue = '7';
        const minNumber = 5;
        const maxNumber = 9;
        const indexOfMin = false;
        const indexOfMax = false;
        expect(VerifyUtil.checkFieldValueRangeRule(viewValue, minNumber, indexOfMin, maxNumber, indexOfMax, errorInfo, primaryModel)).toBe(false);
    })
});

describe('checkFieldSysValueRule unit test', () => {
    test('strReg is /A/i', () => {
        const viewValue = 'ADFSDaGGFDG';
        const viewValue2 = 'HFDGHDHFDH';
        const strReg = /A/i;
        expect(VerifyUtil.checkFieldRegExRule(viewValue, strReg, '', false)).toBe(false);
        expect(VerifyUtil.checkFieldRegExRule(viewValue2, strReg, '', false)).toBe(true);
    })
});

describe('logicForEach unit test', () => {
    const isReverse = false;
    const callback = (item: any, index: number) => {
        if (item.select) {
            return true
        }
        return false
    }
    test('operateTag is AND', ()=> {
        const array = [{ select: true },{ select: true }];
        const array1 = [{ select: true },{ select: false }];
        const operateTag = 'AND';
        if (!isReverse) {
            expect(VerifyUtil.logicForEach(array, callback, operateTag, isReverse)).toBe(true);
            expect(VerifyUtil.logicForEach(array1, callback, operateTag, isReverse)).toBe(false);
        } else {
            expect(VerifyUtil.logicForEach(array, callback, operateTag, isReverse)).toBe(false);
            expect(VerifyUtil.logicForEach(array1, callback, operateTag, isReverse)).toBe(true);
        }
    })
    test('operateTag is OR', ()=> {
        const array = [{ select: true },{ select: false }];
        const array1 = [{ select: false },{ select: false }];
        const operateTag = 'OR';
        if (!isReverse) {
            expect(VerifyUtil.logicForEach(array, callback, operateTag, isReverse)).toBe(true);
            expect(VerifyUtil.logicForEach(array1, callback, operateTag, isReverse)).toBe(false);
        } else {
            expect(VerifyUtil.logicForEach(array, callback, operateTag, isReverse)).toBe(false);
            expect(VerifyUtil.logicForEach(array1, callback, operateTag, isReverse)).toBe(true);
        }
    })
});

describe('verifyDeRules unit test', () => {
    test('condType is GROUP and SIMPLE', () => {
        const name = 'test';
        const data = {
            test: 3,
            test2: 1,
            test3: 10,
        };
        const condition = {
            ruleInfo: '测试提示信息',
            conditions: [
                {
                    condType: 'SIMPLE',
                    condOp: 'GT',
                    paramValue: 'test2',
                    ruleInfo: '错误提示',
                    paramType: 'ENTITYFIELD',
                    keyCond: false,
                },
                {
                    condType: 'SIMPLE',
                    condOp: 'LT',
                    paramValue: 'test3',
                    ruleInfo: '错误提示',
                    paramType: 'ENTITYFIELD',
                    keyCond: false,
                }
            ],
            condOp: 'AND',
            notMode: false,
        }
        expect(VerifyUtil.verifyDeRules(name, data, condition)).toStrictEqual({ isPast: true, infoMessage: '测试提示信息' });
    });
    test('condType is GROUP and VALUERANGE2', () => {
        const name = 'test';
        const data = {
            test: 3,
        };
        const condition = {
            ruleInfo: '测试提示信息',
            conditions: [
                {
                    condType: 'VALUERANGE2',
                    minValue: 1,
                    includeMinValue: false,
                    maxValue: 10,
                    includeMaxValue: true,
                    ruleInfo: '错误提示',
                    keyCond: false,
                },
                {
                    condType: 'VALUERANGE2',
                    minValue: 5,
                    includeMinValue: false,
                    maxValue: 10,
                    includeMaxValue: true,
                    ruleInfo: '错误提示',
                    keyCond: false,
                }
            ],
            condOp: 'OR',
            notMode: false,
        }
        expect(VerifyUtil.verifyDeRules(name, data, condition)).toStrictEqual({ isPast: true, infoMessage: '测试提示信息' });
    });
    test('condType is GROUP and REGEX', () => {
        const name = 'test';
        const data = {
            test: 'ASDFGKJGHGH',
        };
        const condition = {
            ruleInfo: '测试提示信息',
            conditions: [
                {
                    condType: 'REGEX',
                    regExCode: /A/i,
                    ruleInfo: '首字母必须为A, 不区分大小写',
                    keyCond: false,
                },
            ],
            condOp: 'AND',
            notMode: false,
        }
        expect(VerifyUtil.verifyDeRules(name, data, condition)).toStrictEqual({ isPast: true, infoMessage: '测试提示信息' });
    });
    test('condType is GROUP and STRINGLENGTH', () => {
        const name = 'test';
        const data = {
            test: 6,
        };
        const condition = {
            ruleInfo: '测试提示信息',
            conditions: [
                {
                    condType: 'STRINGLENGTH',
                    minValue: 1,
                    includeMinValue: false,
                    maxValue: 10,
                    includeMaxValue: true,
                    ruleInfo: '错误提示',
                    keyCond: false,
                },
                {
                    condType: 'STRINGLENGTH',
                    minValue: 5,
                    includeMinValue: false,
                    maxValue: 10,
                    includeMaxValue: true,
                    ruleInfo: '错误提示',
                    keyCond: false,
                }
            ],
            condOp: 'AND',
            notMode: false,
        }
        expect(VerifyUtil.verifyDeRules(name, data, condition)).toStrictEqual({ isPast: true, infoMessage: '测试提示信息' });
    });
    test('condType is GROUP and SYSVALUERULE', () => {
        const name = 'test';
        const data = {
            test: 'ASDFGKJGHGH',
        };
        const condition = {
            ruleInfo: '测试提示信息',
            conditions: [
                {
                    condType: 'SYSVALUERULE',
                    sysValueRule: {
                        ruleType: 'REG',
                        regExCode: /A/i,
                        ruleInfo: '首字母必须为A, 不区分大小写',
                        keyCond: false,
                    },
                },
                {
                    condType: 'SYSVALUERULE',
                    sysValueRule: {
                        ruleType: 'SCRIPT',
                        scriptCode: "if(source && source.test && source.test.length == 11){ console.log(1) }else{callback({message: '错误！'})}",
                        ruleInfo: '字符长度为11',
                        keyCond: false,
                    },
                },
            ],
            condOp: 'AND',
            notMode: false,
        }
        expect(VerifyUtil.verifyDeRules(name, data, condition)).toStrictEqual({ isPast: true, infoMessage: '测试提示信息' });
    });
});

describe('buildVerConditions unit test', () => {
    test('Value Rule', () => {
        const model = {
            editorType: 'NUMBER',
            maxValue: 30,
            minValue: 10,
            getPSSysValueRule: {
                ruleType: 'REG',
                regExCode: /A/i,
                ruleInfo: '首字母必须为A, 不区分大小写',
            },
        }
        const exportRules: any[] = [
            { type: 'number', max: 30, message: 'The maximum content value must be30' },
            { type: 'number', min: 10, message: 'Content minimum value must be10' },
            { type: 'number', pattern: /A/i, message: '首字母必须为A, 不区分大小写' },
        ];
        expect(VerifyUtil.buildVerConditions(model)).toStrictEqual(exportRules);
    })
});

describe('validateItem unit test', () => {
	test('validateItem result is true', async () => {
        const property = 'test';
        const data = { test: '测试', test2: null };
        const rules = {
            test: {
                validator(rule: any, value: any, callback: Function) {
                    return !(value === null || value === undefined || value === '');
                },
                message: 'test 必须填写！',
            }
        }
		await expect(VerifyUtil.validateItem(property, data, rules)).resolves.toStrictEqual({test: '测试', test2: null});
	});
    test('validateItem result is false', async () => {
        const property = 'test2';
        const data = { test: '测试', test2: null };
        const rules = {
            test2: {
                validator(rule: any, value: any, callback: Function) {
                    return !(value === null || value === undefined || value === '');
                },
                message: 'test2 必须填写！',
            }
        }
        await expect(VerifyUtil.validateItem(property, data, rules)).rejects.toThrowError(Error);
	});
});