@colijnit/corecomponents_v12 12.2.23 → 12.2.25

package/projects/corecomponents/src/lib/core/utils/number-utils.spec.ts

@@ -0,0 +1,657 @@
+import {NumberUtils} from "./number-utils";
+
+// NOTE: the commented-out specs are methods which aren't yet in OUR NumberUtils, but still only in NumberUtils of iOneJS
+describe("NumberUtils", () => {
+ /*   describe("ModInverse", () => {
+        it("there is an exact answer, and it's somewhere in the middle", () => {
+            expect(NumberUtils.ModInverse(706, 0, 340, 368, 1)).toBe(353);
+        });
+
+        it("there is an exact answer, and it's the last possible value", () => {
+            expect(NumberUtils.ModInverse(736, 0, 340, 368, 1)).toBe(368);
+        });
+
+        it("there is an exact answer, and it's the first possible value", () => {
+            expect(NumberUtils.ModInverse(680, 0, 340, 368, 1)).toBe(340);
+        });
+
+        it("there is not an exact answer, the optimal value is the last value", () => {
+            expect(NumberUtils.ModInverse(737, 0, 340, 368, 1)).toBe(368);
+        });
+
+        it("there is not an exact answer, the optimal value is the first value", () => {
+            expect(NumberUtils.ModInverse(681, 0, 340, 368, 1)).toBe(340);
+        });
+
+        it("there is not an exact answer, the optimal value is somewhere in the middle", () => {
+            expect(NumberUtils.ModInverse(713, 0, 340, 368, 1)).toBe(356);
+        });
+    });
+
+    describe("ParseInt", () => {
+        // negative
+        it("should handle undefined", () => {
+            expect(isNaN(NumberUtils.ParseInt(undefined))).toBeTruthy();
+        });
+
+        it("should not accept array arg", () => {
+            expect(isNaN(NumberUtils.ParseInt([1, 2, 3]))).toBeTruthy();
+        });
+
+        // positive
+        it("should handle integers correctly", () => {
+            expect(NumberUtils.ParseInt(1)).toBe(1);
+        });
+
+        it("should handle decimal numbers correctly, and cut instead of round them off", () => {
+            expect(NumberUtils.ParseInt(1.99)).toBe(1);
+        });
+
+        it("should handle negative numbers correcly", () => {
+            expect(NumberUtils.ParseInt(-1.99)).toBe(-1);
+        });
+
+        it("should accept string arguments", () => {
+            expect(NumberUtils.ParseInt("1.1234")).toBe(1);
+        });
+    });*/
+
+    describe("ParseFloat", () => {
+        // negative
+        it("should return NaN when given undefined", () => {
+            expect(isNaN(NumberUtils.ParseFloat(undefined))).toBeTruthy();
+        });
+
+        it("should return NaN when given empty array arg", () => {
+            expect(isNaN(NumberUtils.ParseFloat([]))).toBeTruthy();
+        });
+
+        it("should not accept array arg", () => {
+            expect(isNaN(NumberUtils.ParseFloat(["0.1234", 2, 3]))).toBeTruthy();
+        });
+
+        // positive
+        it("should handle undefined decimal precision", () => {
+            expect(NumberUtils.ParseFloat(0.1234, undefined)).toBe(0.12);
+        });
+
+        it("should default to a decimal precision of 2", () => {
+            expect(NumberUtils.ParseFloat(0.1234)).toBe(0.12);
+        });
+
+        it("should convert negative given decimal precisions to the default decimal precision of 2", () => {
+            expect(NumberUtils.ParseFloat(0.1234, -5)).toBe(0.12);
+        });
+
+        it("should handle a 0 decimal precision correctly", () => {
+            expect(NumberUtils.ParseFloat(0.1234, 0)).toBe(0);
+        });
+
+        it("should handle a large decimal precision correctly", () => {
+            expect(NumberUtils.ParseFloat(0.1234567890123456789, 15)).toBe(0.123456789012346);
+        });
+
+        it("should accept string arguments", () => {
+            expect(NumberUtils.ParseFloat("0.1234")).toBe(0.12);
+        });
+    });
+
+    /*describe("ParseFloatKeepPrecision", () => {
+        // negative
+        it("should handle undefined arg", () => {
+            expect(isNaN(NumberUtils.ParseFloatKeepPrecision(undefined))).toBeTruthy();
+        });
+
+        it("should not accept array arg", () => {
+            expect(isNaN(NumberUtils.ParseFloat([1, 2, 3]))).toBeTruthy();
+        });
+
+        // positive
+        it("should return 0 when given 0", () => {
+            expect(NumberUtils.ParseFloatKeepPrecision(0)).toBe(0);
+        });
+
+        it("should handle negative fractions", () => {
+            expect(NumberUtils.ParseFloatKeepPrecision(-0.1234)).toBe(-0.1234);
+        });
+
+        it("should handle a large decimal precision correctly", () => {
+            expect(NumberUtils.ParseFloatKeepPrecision(0.1234567890123456789)).toBe(0.1234567890123456789);
+        });
+
+        it("should accept string arguments", () => {
+            expect(NumberUtils.ParseFloatKeepPrecision("0.1234")).toBe(0.1234);
+        });
+    });*/
+
+    describe("ParseNumber", () => {
+        // negative
+        it("should return the number 0 when undefined was given", () => {
+            expect(NumberUtils.ParseNumberOrDefault(undefined)).toBe(0);
+        });
+
+        it("should return the number 0 when an object was given", () => {
+            expect(NumberUtils.ParseNumberOrDefault({})).toBe(0);
+        });
+
+        it("should not accept number arrays as arg and just return the default value", () => {
+            expect(NumberUtils.ParseNumberOrDefault([1, 2, 3])).toBe(0);
+        });
+
+        // positive
+        it("should keep original decimal precision when fractals given", () => {
+            expect(NumberUtils.ParseNumberOrDefault(0.1234)).toBe(0.1234);
+        });
+
+        it("should parse strings to numbers", () => {
+            expect(NumberUtils.ParseNumberOrDefault("42")).toBe(42);
+        });
+    });
+
+    describe("IsInteger", () => {
+        // negative
+        it("should return false when undefined given", () => {
+            expect(NumberUtils.IsInteger(undefined)).toBe(false);
+        });
+
+        it("should return false when null given", () => {
+            expect(NumberUtils.IsInteger(null)).toBe(false);
+        });
+
+        it("should return false when NaN given", () => {
+            expect(NumberUtils.IsInteger(NaN)).toBe(false);
+        });
+
+        it("should return false when array of numbers given", () => {
+            expect(NumberUtils.IsInteger([1, 2, 3])).toBe(false);
+        });
+
+        it("should return false when fraction given", () => {
+            expect(NumberUtils.IsInteger(0.1234)).toBe(false);
+        });
+
+        // positive
+        it("should return true when 0 given", () => {
+            expect(NumberUtils.IsInteger(0)).toBe(true);
+        });
+
+        it("should return true when positive integer given", () => {
+            expect(NumberUtils.IsInteger(5)).toBe(true);
+        });
+
+        it("should return true when negative integer given", () => {
+            expect(NumberUtils.IsInteger(-5)).toBe(true);
+        });
+    });
+
+    describe("GetDecimalPlaces", () => {
+        // negative
+        it("should return 0 when undefined given", () => {
+            expect(NumberUtils.GetDecimalPlaces(undefined)).toBe(0);
+        });
+
+        it("should return 0 when object given", () => {
+            expect(NumberUtils.GetDecimalPlaces({})).toBe(0);
+        });
+
+        // positive
+        it("should return 0 when integer given", () => {
+            expect(NumberUtils.GetDecimalPlaces(5)).toBe(0);
+        });
+
+        it("should return the expected decimals when positive fraction given", () => {
+            expect(NumberUtils.GetDecimalPlaces(0.1234)).toBe(4);
+        });
+
+        it("should return the expected decimals when negative fraction given", () => {
+            expect(NumberUtils.GetDecimalPlaces(-0.1234)).toBe(4);
+        });
+
+        it("should work with string arguments", () => {
+            expect(NumberUtils.GetDecimalPlaces("-0.1234")).toBe(4);
+        });
+    });
+
+    describe("IsNumber", () => {
+        // negative
+        it("should return false when undefined given", () => {
+            expect(NumberUtils.IsNumber(undefined)).toBe(false);
+        });
+
+        it("should return false when object given", () => {
+            expect(NumberUtils.IsNumber({})).toBe(false);
+        });
+
+        it("should return false when string-number given", () => {
+            expect(NumberUtils.IsNumber("42")).toBe(false);
+        });
+
+        // positive
+        it("should return true when 0 given", () => {
+            expect(NumberUtils.IsNumber(0)).toBe(true);
+        });
+
+        it("should return true when negative fraction given", () => {
+            expect(NumberUtils.IsNumber(-0.1234)).toBe(true);
+        });
+    });
+
+    describe("IsNaN", () => {
+        it("should return true when undefined given", () => {
+            expect(NumberUtils.IsNaN(undefined)).toBe(true);
+        });
+
+        it("should return true when null given", () => {
+            expect(NumberUtils.IsNaN(null)).toBe(true);
+        });
+
+        it("should return true when empty object given", () => {
+            expect(NumberUtils.IsNaN({})).toBe(true);
+        });
+
+        it("should return true when string given", () => {
+            expect(NumberUtils.IsNaN("str")).toBe(true);
+        });
+
+        it("should return true when empty array given", () => {
+            expect(NumberUtils.IsNaN([])).toBe(true);
+        });
+
+        it("should return true when array of numbers given", () => {
+            expect(NumberUtils.IsNaN([1, 2])).toBe(true);
+        });
+
+        it("should return false when number 0 given", () => {
+            expect(NumberUtils.IsNaN(0)).toBe(false);
+        });
+
+        it("should return false when negative fractal given", () => {
+            expect(NumberUtils.IsNaN(-7 / 3)).toBe(false);
+        });
+    });
+
+    describe("IsParsableNumber", () => {
+        // negative
+        it("should return false when undefined given", () => {
+            expect(NumberUtils.IsParsableNumber(undefined)).toBe(false);
+        });
+
+        it("should return false when object given", () => {
+            expect(NumberUtils.IsParsableNumber({})).toBe(false);
+        });
+
+        it("should return false when empty array given", () => {
+            expect(NumberUtils.IsParsableNumber([])).toBe(false);
+        });
+
+        it("should return false when unparsable string given", () => {
+            expect(NumberUtils.IsParsableNumber("foo")).toBe(false);
+        });
+
+        it("should return true when 0 given", () => {
+            expect(NumberUtils.IsParsableNumber(0)).toBe(true);
+        });
+
+        it("should return false when array of numbers given", () => {
+            expect(NumberUtils.IsParsableNumber([1, 2])).toBe(false);
+        });
+
+        // positive
+        it("should return true when negative fraction given", () => {
+            expect(NumberUtils.IsParsableNumber(-0.1234)).toBe(true);
+        });
+
+        it("should return true when parsable string given", () => {
+            expect(NumberUtils.IsParsableNumber("-0.1234")).toBe(true);
+        });
+
+        it("should return false when number string with weird appendix given", () => {
+            expect(NumberUtils.IsParsableNumber("10px")).toBe(true);
+        });
+    });
+
+    /*describe("IsStringNumber", () => {
+        // negative
+        it("should return false when undefined given", () => {
+            expect(NumberUtils.IsStringNumber(undefined)).toBe(false);
+        });
+
+        it("should return false when unparsable string given", () => {
+            expect(NumberUtils.IsStringNumber("foo")).toBe(false);
+        });
+
+        it("should return false when parsable string that is NOT a strict 'string number' given", () => {
+            expect(NumberUtils.IsStringNumber("10px")).toBe(false); // important difference with IsParsableNumber!
+        });
+
+        // positive
+        it("should return true when '0' given", () => {
+            expect(NumberUtils.IsStringNumber("0")).toBe(true);
+        });
+
+        it("should return true when positive integer string given", () => {
+            expect(NumberUtils.IsStringNumber("1")).toBe(true);
+        });
+
+        it("should return true when parsable string given", () => {
+            expect(NumberUtils.IsStringNumber("-0.1234")).toBe(true);
+        });
+    });
+
+    describe("ParseStringNumber", () => {
+        // negative
+        it("should return NaN when undefined given", () => {
+            expect(isNaN(NumberUtils.ParseStringNumber(undefined))).toBeTruthy();
+        });
+
+        it("should return NaN when unparsable string given", () => {
+            expect(isNaN(NumberUtils.ParseStringNumber("foo"))).toBeTruthy();
+        });
+
+        it("should return NaN when a '10px' given", () => {
+            expect(isNaN(NumberUtils.ParseStringNumber("10px"))).toBeTruthy(); // important difference with IsParsableNumber!
+        });
+
+        // positive
+        it("should parse '0' to 0", () => {
+            expect(NumberUtils.ParseStringNumber("0")).toBe(0);
+        });
+
+        it("should parse a negative fraction string number", () => {
+            expect(NumberUtils.ParseStringNumber("-0.1234")).toBe(-0.1234);
+        });
+    });
+
+    describe("RandomInt", () => {
+        // negative
+        it("should return NaN when given a lowerBoundInt of undefined", () => {
+            expect(isNaN(NumberUtils.RandomInt(10, 0))).toBeTruthy();
+        });
+
+        it("should return NaN when given an upperBoundInt of undefined", () => {
+            expect(isNaN(NumberUtils.RandomInt(10, undefined))).toBeTruthy();
+        });
+
+        it("should return NaN when given lowerBoundInt was larger than upperBoundInt", () => {
+            expect(isNaN(NumberUtils.RandomInt(undefined, 10))).toBeTruthy();
+        });
+
+        // positive
+        it("should return a number in [lowerBound, upperBound] when bounds are normal, positive integers", () => {
+            _testRandomInt(5, 10);
+        });
+
+        it("should work when bounds are negative", () => {
+            _testRandomInt(-10, -5);
+        });
+
+        it("should, with reasonable certainity, really truncate given lower and upper bounds first", () => {
+            _testRandomInt(-1.5, 1.5, -1, 1);
+        });
+    });*/
+
+    describe("PrecisionAndScaleToMaxValue", () => {
+        it("should return the correct results", () => {
+            expect(NumberUtils.PrecisionScaleToMaxValue(4, 2)).toBe(99.99);
+        })
+    });
+
+    describe("AddThousandsCommasTo", () => {
+
+    });
+
+    describe("NumIsComposedOfOtherPowTwoNum", () => {
+
+    });
+
+    describe("NrOrDefault", () => {
+
+    });
+
+    /*describe("CheckPrecisionAndScale", () => {
+        // negative
+        it("should handle undefined nrToCheck arg as expected", () => {
+            // when
+            let result: CheckPrecisionAndScaleResult = NumberUtils.CheckPrecisionAndScale(undefined, 1, 1);
+
+            // then
+            expect(result.isOk).toBeTruthy(1);
+            expect(isNaN(result.nearestOkNr)).toBeTruthy(2);
+        });
+
+        it("should handle undefined precision arg as expected", () => {
+            // when
+            let result: CheckPrecisionAndScaleResult = NumberUtils.CheckPrecisionAndScale(1, undefined, 1);
+
+            // then
+            expect(result.isOk).toBeTruthy(1);
+            expect(isNaN(result.nearestOkNr)).toBeTruthy(2);
+        });
+
+        it("should handle undefined scale arg as expected, and default to a scale of 0", () => {
+            // when
+            let result: CheckPrecisionAndScaleResult = NumberUtils.CheckPrecisionAndScale(1, 1, undefined);
+
+            // then
+            expect(result.isOk).toBeTruthy();
+            expect(result.nearestOkNr).toBe(1);
+        });
+
+        // positive
+        it("should return isOk true for a simple OK case", () => {
+
+        });
+
+        it("should return the original nrToCheck as nearestOkNr if it was OK, for a simple OK case", () => {
+
+        });
+
+        it("should return isOk true for a more complex OK case", () => {
+
+        });
+
+        it("should return the original nrToCheck as nearestOkNr if it was OK, for a more complex OK case", () => {
+
+        });
+
+        it("should return isOk false for a simple not-OK case", () => {
+
+        });
+
+        it("should return the expected nearestOkNr if it was not OK, for a simple case", () => {
+
+        });
+    });*/
+
+    describe("CheckWithinSteppedBounds", () => {
+
+    });
+
+    describe("GetNearestNumberWithinSteppedBounds", () => {
+
+    });
+
+    describe("GetTrueSteppedBoundsMax", () => {
+
+    });
+
+    // IsInteger
+    it('IsInteger returns false on wrong input', () => {
+        expect(NumberUtils.IsInteger({}) === false).toBeTruthy(1);
+        expect(NumberUtils.IsInteger([]) === false).toBeTruthy(2);
+        expect(NumberUtils.IsInteger("0.3") === false).toBeTruthy(3);
+        expect(NumberUtils.IsInteger(0.1) === false).toBeTruthy(4);
+    });
+    it ('IsInteger returns true on numbers with decimals that are all zero', () => {
+        expect(NumberUtils.IsInteger(0.0) ).toBeTruthy(1);
+        expect(NumberUtils.IsInteger("1.00") ).toBeTruthy(2);
+        expect(NumberUtils.IsInteger("-3.000") ).toBeTruthy(3);
+    });
+
+    // RandomInt
+    // xit('RandomInt handles faulty inputs like expected', () => {
+    // expect(!isNumber(NumberUtils.RandomInt(undefined, null))).toBeTruthy(1);
+    // expect(!isNumber(NumberUtils.RandomInt(1, null))).toBeTruthy(2);
+    // expect(!isNumber(NumberUtils.RandomInt(undefined, 1))).toBeTruthy(3);
+    //     expect(NumberUtils.RandomInt(0, 0) === 0).toBeTruthy(4);
+    //     expect(NumberUtils.RandomInt(-5, -5) === -5).toBeTruthy(5);
+    //     let expectNrForFailOutput: number = 6;
+    //     for (let i: number = 0; i < RAND_LOOP_COUNT; i++) {
+    //         let rand: number = NumberUtils.RandomInt(10, 5);
+    //         expect(NumberUtils.IsInteger(rand)).toBeTruthy(expectNrForFailOutput++);
+    //         expect(rand >= 5).toBeTruthy(expectNrForFailOutput++);
+    //         expect(rand <= 10).toBeTruthy(expectNrForFailOutput++);
+    //     }
+    // });
+    // xit('RandomInt handles correct integer and float inputs like expected', () => {
+    //     for (let i: number = 0; i < RAND_LOOP_COUNT; i++) {
+    //         let rand: number = NumberUtils.RandomInt(5, 10);
+    //         expect(NumberUtils.IsInteger(rand)).toBeTruthy(1);
+    //         expect(rand >= 5).toBeTruthy(2);
+    //         expect(rand <= 10).toBeTruthy(3);
+    //     }
+    //     for (let i: number = 0; i < RAND_LOOP_COUNT; i++) {
+    //         let rand: number = NumberUtils.RandomInt(-10, 0);
+    //         expect(NumberUtils.IsInteger(rand)).toBeTruthy();
+    //         expect(rand >= -10).toBeTruthy();
+    //         expect(rand <= 0).toBeTruthy();
+    //     }
+    //     for (let i: number = 0; i < RAND_LOOP_COUNT; i++) {
+    //         let rand: number = NumberUtils.RandomInt(5.4, 7.4);
+    //         expect(NumberUtils.IsInteger(rand)).toBeTruthy(1);
+    //         expect(rand >= 5).toBeTruthy(2);
+    //         expect(rand <= 7).toBeTruthy(3);
+    //     }
+    //     for (let i: number = 0; i < RAND_LOOP_COUNT; i++) {
+    //         let rand: number = NumberUtils.RandomInt(-10.1, 10.5);
+    //         expect(NumberUtils.IsInteger(rand)).toBeTruthy(1);
+    //         expect(rand >= -10).toBeTruthy(2);
+    //         expect(rand <= 11).toBeTruthy(3);
+    //     }
+    // });
+
+   /* // AddThousandsCommasTo
+    it('AddThousandsCommasTo handles faulty input as expected', () => {
+        expect(NumberUtils.AddThousandsCommasTo(undefined)).toEqual("");
+        expect(NumberUtils.AddThousandsCommasTo('blabla') === 'blabla').toBeTruthy(2);
+    });
+    it('AddThousandsCommasTo handles correct input as expected', () => {
+        expect(NumberUtils.AddThousandsCommasTo('1') === '1').toBeTruthy(1);
+        expect(NumberUtils.AddThousandsCommasTo('1000') === '1,000').toBeTruthy(2);
+        expect(NumberUtils.AddThousandsCommasTo('1000.00') === '1,000.00').toBeTruthy(3);
+        expect(NumberUtils.AddThousandsCommasTo('blabla1000.00') === 'blabla1,000.00').toBeTruthy(4);
+        expect(NumberUtils.AddThousandsCommasTo('1000.00blabla') === '1,000.00blabla').toBeTruthy(5);
+        expect(NumberUtils.AddThousandsCommasTo('1000.00blabla1000') === '1,000.00blabla1,000').toBeTruthy(6);
+    });
+
+    // NumIsComposedOfOtherPowTwoNum
+    it('NumIsComposedOfOtherPowTwoNum handles faulty input as expected', () => {
+        expect(NumberUtils.NumIsComposedOfOtherPowTwoNum(undefined, 1) === false).toBeTruthy(1);
+        expect(NumberUtils.NumIsComposedOfOtherPowTwoNum(1, undefined)).toBeTruthy(2);
+    });
+    it('NumIsComposedOfOtherPowTwoNum handles correct input as expected', () => {
+        expect(NumberUtils.NumIsComposedOfOtherPowTwoNum(1, 1)).toBeTruthy(1);
+        expect(NumberUtils.NumIsComposedOfOtherPowTwoNum(2, 1) === false).toBeTruthy(2);
+        expect(NumberUtils.NumIsComposedOfOtherPowTwoNum(3, 1)).toBeTruthy(3);
+        expect(NumberUtils.NumIsComposedOfOtherPowTwoNum(4, 1) === false).toBeTruthy(4);
+        expect(NumberUtils.NumIsComposedOfOtherPowTwoNum(5, 1)).toBeTruthy(5);
+        expect(NumberUtils.NumIsComposedOfOtherPowTwoNum(2, 2)).toBeTruthy(6);
+        expect(NumberUtils.NumIsComposedOfOtherPowTwoNum(3, 2)).toBeTruthy(7);
+        expect(NumberUtils.NumIsComposedOfOtherPowTwoNum(4, 2) === false).toBeTruthy(8);
+        expect(NumberUtils.NumIsComposedOfOtherPowTwoNum(5, 2) === false).toBeTruthy(9);
+        expect(NumberUtils.NumIsComposedOfOtherPowTwoNum(6, 2)).toBeTruthy(10);
+        expect(NumberUtils.NumIsComposedOfOtherPowTwoNum(1, 2) === false).toBeTruthy(11);
+        expect(NumberUtils.NumIsComposedOfOtherPowTwoNum(2, 1) === false).toBeTruthy(12);
+    });
+
+    // CheckPrecisionAndScaleOk
+    it('CheckPrecisionAndScale handles faulty input as expected', () => {
+        expect(NumberUtils.CheckPrecisionAndScale(undefined, undefined, undefined).isOk ).toBeTruthy(1);
+        expect(NumberUtils.CheckPrecisionAndScale(undefined, 1, undefined).isOk ).toBeTruthy(2);
+        expect(NumberUtils.CheckPrecisionAndScale(undefined, undefined, 1).isOk ).toBeTruthy(3);
+        // a precision of -1 is meaningless (== nr. of significant digits)
+        expect(NumberUtils.CheckPrecisionAndScale(1, -1, 0).isOk === false).toBeTruthy(4);
+        // a scale larger than the precision is meaningless
+        let result: CheckPrecisionAndScaleResult;
+        result = NumberUtils.CheckPrecisionAndScale(1, 2, 3);
+        expect(result.isOk === false && isNaN(result.nearestOkNr)).toBeTruthy(5);
+    });
+
+    it('CheckPrecisionAndScale handles valid input as expected', () => {
+        // precision only: OK
+        expect(NumberUtils.CheckPrecisionAndScale(0, 1, 0).isOk).toBeTruthy(1);
+        expect(NumberUtils.CheckPrecisionAndScale(1, 1, 0).isOk).toBeTruthy(2);
+        expect(NumberUtils.CheckPrecisionAndScale(-1, 1, 0).isOk).toBeTruthy(2);
+        expect(NumberUtils.CheckPrecisionAndScale(1.123, 2, 0).isOk).toBeTruthy(3); // scale is 0, extra decimals are allowed
+        expect(NumberUtils.CheckPrecisionAndScale(-1.123, 2, 0).isOk).toBeTruthy(3);
+        expect(NumberUtils.CheckPrecisionAndScale(9, 1, 0).isOk).toBeTruthy(4);
+        expect(NumberUtils.CheckPrecisionAndScale(9.00, 1, 0).isOk).toBeTruthy(5);
+        expect(NumberUtils.CheckPrecisionAndScale(9.00, 1, 0).isOk).toBeTruthy(6);
+        expect(NumberUtils.CheckPrecisionAndScale(88.11, 4, 0).isOk).toBeTruthy(7);
+        expect(NumberUtils.CheckPrecisionAndScale(-88.11, 4, 0).isOk).toBeTruthy(8);
+
+        // precision only: NOT OK
+        let result: CheckPrecisionAndScaleResult;
+        result = NumberUtils.CheckPrecisionAndScale(900, 1, 0);
+        expect(result.isOk === false).toBeTruthy(9);
+        expect(result.nearestOkNr === 9).toBeTruthy(10);
+
+        result = NumberUtils.CheckPrecisionAndScale(-900, 1, 0);
+        expect(result.isOk === false).toBeTruthy(11);
+        expect(result.nearestOkNr === -9).toBeTruthy(12);
+
+        result = NumberUtils.CheckPrecisionAndScale(900.00, 2, 0);
+        expect(result.isOk === false && result.nearestOkNr === 90).toBeTruthy(13);
+
+        result = NumberUtils.CheckPrecisionAndScale(88, 1, 0);
+        expect(result.isOk === false && result.nearestOkNr === 8).toBeTruthy(14);
+
+        result = NumberUtils.CheckPrecisionAndScale(88.11, 1, 0);
+        expect(result.isOk === false && result.nearestOkNr === 8.11).toBeTruthy(15); // we had to remove the significant part
+
+        result = NumberUtils.CheckPrecisionAndScale(-88.11, 1, 0);
+        expect(result.isOk === false && result.nearestOkNr === -8.11).toBeTruthy(16);
+
+        // both precision and scale: OK
+        expect(NumberUtils.CheckPrecisionAndScale(1, 2, 1).isOk).toBeTruthy();
+        expect(NumberUtils.CheckPrecisionAndScale(1.0, 2, 1).isOk).toBeTruthy();
+        expect(NumberUtils.CheckPrecisionAndScale(10, 3, 1).isOk).toBeTruthy();
+        expect(NumberUtils.CheckPrecisionAndScale(10.0, 3, 1).isOk).toBeTruthy();
+        expect(NumberUtils.CheckPrecisionAndScale(100.00, 5, 2).isOk).toBeTruthy();
+        expect(NumberUtils.CheckPrecisionAndScale(100.000, 6, 3).isOk).toBeTruthy();
+        expect(NumberUtils.CheckPrecisionAndScale(100.00, 8, 5).isOk).toBeTruthy();
+        expect(NumberUtils.CheckPrecisionAndScale(100.000, 100, 97).isOk).toBeTruthy();
+
+        // both precision and scale: NOT OK
+        result = NumberUtils.CheckPrecisionAndScale(10.0, 3, 2);
+        expect(result.isOk === false).toBeTruthy();
+        expect(result.nearestOkNr === 1.0).toBeTruthy(); // reminder: precision 3, scale 2 means 3 significant digits OFWHICH 2 decimals
+
+        result = NumberUtils.CheckPrecisionAndScale(10.123412, 3, 2);
+        expect(result.isOk === false).toBeTruthy();
+        expect(result.nearestOkNr === 1.123412).toBeTruthy();
+
+        result = NumberUtils.CheckPrecisionAndScale(100, 10, 8);
+        expect(result.isOk === false).toBeTruthy();
+        expect(result.nearestOkNr === 10).toBeTruthy();
+
+        result = NumberUtils.CheckPrecisionAndScale(-100.23409823104162984712591872560, 10, 8);
+        expect(result.isOk === false).toBeTruthy();
+        expect(result.nearestOkNr === -10.2340982310416298471259187256).toBeTruthy();
+    });
+
+    // helpers
+    function _testRandomInt(
+        givenLowerBound: number,
+        givenUpperBound: number,
+        expectedLowerBound: number = givenLowerBound,
+        expectedUpperBound: number = givenUpperBound
+    ): void {
+        for (let i: number = 0; i < UnitTestDataConstants.RandomLoopCount; i++) {
+            let rand: number = NumberUtils.RandomInt(givenLowerBound, givenUpperBound);
+            expect(NumberUtils.IsInteger(rand)).toBeTruthy("rand was not an integer");
+            expect(rand >= expectedLowerBound).toBeTruthy("rand was smaller than lowerBound");
+            expect(rand <= expectedUpperBound).toBeTruthy("rand was larger than upperBound");
+        }
+    }*/
+});