@sankhyalabs/core 5.20.0-dev.8 → 5.20.0-dev.80

package/test/util/ElementUtils.spec.ts

@@ -0,0 +1,34 @@
+import { calcMarginSize } from '../../src/utils/ElementUtils';
+import { OverflowDirection } from '../../src';
+
+describe('calcMarginSize', () => {
+  it('should calculate correctly the size of horizontal margin', () => {
+    const element = document.createElement('div');
+    element.style.marginLeft = '10px';
+    element.style.marginRight = '15px';
+    document.body.appendChild(element);
+
+    const size = calcMarginSize(element, OverflowDirection.HORIZONTAL);
+    expect(size).toBe(25);
+  });
+
+  it('should calculate correctly the size of vertical margin', () => {
+    const element = document.createElement('div');
+    element.style.marginTop = '5px';
+    element.style.marginBottom = '20px';
+    document.body.appendChild(element);
+
+    const size = calcMarginSize(element, OverflowDirection.VERTICAL);
+    expect(size).toBe(25);
+  });
+
+  it('should threat values defined as zero', () => {
+    const element = document.createElement('div');
+    document.body.appendChild(element);
+
+    const horizontalSize = calcMarginSize(element, OverflowDirection.HORIZONTAL);
+    const verticalSize = calcMarginSize(element, OverflowDirection.VERTICAL);
+    expect(horizontalSize).toBe(0);
+    expect(verticalSize).toBe(0);
+  });
+});

package/test/util/NumberUtils.spec.ts

@@ -1,182 +1,104 @@
 import { NumberUtils } from '../../src/utils/NumberUtils';
-
-describe('StringUtils', function () {
-
-
-  // => STRING_TO_NUMBER
-  // ----------------------------------------------------------------------------------------
-
-  const arrayDataTest = [
-    { valueInput: '100', valueOutput: 100 },
-    { valueInput: '100,12', valueOutput: 100.12 },
-    { valueInput: '11500,12', valueOutput: 11500.12 },
-    { valueInput: '11500', valueOutput: 11500 },
-    { valueInput: '1.000', valueOutput: 1 },
-    { valueInput: '11.500,003', valueOutput: 11500.003 },
-    { valueInput: '-100', valueOutput: -100 },
-    { valueInput: '-100,12', valueOutput: -100.12 },
-    { valueInput: '-11500,1', valueOutput: -11500.1 },
-    { valueInput: '-11500', valueOutput: -11500 },
-    { valueInput: '-11.500,003', valueOutput: -11500.003 },
-    { valueInput: 'R$100', valueOutput: 100 },
-    { valueInput: 'R$100,12', valueOutput: 100.12 },
-    { valueInput: 'R$11500,12', valueOutput: 11500.12 },
-    { valueInput: 'R$11500', valueOutput: 11500 },
-    { valueInput: 'R$11.500,003', valueOutput: 11500.003 },
-    { valueInput: '-R$100', valueOutput: -100 },
-    { valueInput: '-R$100,12', valueOutput: -100.12 },
-    { valueInput: '-R$11500,12', valueOutput: -11500.12 },
-    { valueInput: '-R$11500', valueOutput: -11500 },
-    { valueInput: '-R$11.500,003', valueOutput: -11500.003 },
-    { valueInput: '', valueOutput: NaN },
-    { valueInput: 'OrdinaryString', valueOutput: NaN },
-    { valueInput: '100.167.80', valueOutput: NaN },
-    { valueInput: 'uahsuhas,auhsuhasu', valueOutput: NaN },
-    { valueInput: '100,100,100', valueOutput: NaN },
-    { valueInput: 'OrdinaryString,.OrdinaryString', valueOutput: NaN },
-    { valueInput: 'OrdinaryString.,OrdinaryString', valueOutput: NaN },
-    { valueInput: '.121212', valueOutput: 0.121212 },
-    { valueInput: ',121212', valueOutput: 0.121212 },
-    { valueInput: '1,232,333.345', valueOutput: NaN },
-    { valueInput: '1232333,345', valueOutput: 1232333.345 },
-  ]
-
-  it('stringToNumber', function () {
-    let result: number;
-    arrayDataTest.forEach(e => {
-      result = NumberUtils.stringToNumber(e.valueInput);
-      expect(result).toBe(e.valueOutput);
-    })
-  });
-
-
+import {
+  changeFormatCases,
+  formatCases,
+  safeFormatCases,
+  keepOnlyDecimalSeparatorCases,
+  roundTestCases,
+  stringToNumberCases,
+  getValueOrDefaultCases,
+  getValueOrZeroCases,
+  compareCases,
+} from '../testCases/NumberUtilsTestCases';
 
 
-  // FORMAT
-  // ----------------------------------------------------------------------------------------
+describe('NumberUtils', function() {
 
+  describe('stringToNumber', () => {
 
-  const casesStrValue = [
+    stringToNumberCases.forEach(e => {
+      it(`should return ${e.valueOutput} when value is ${e.valueInput}`, () => {
+        expect(NumberUtils.stringToNumber(e.valueInput)).toBe(e.valueOutput);
+      });
+    });
 
-    { precision: 4, prettyprecision: 2, strvalue: '1.200.999,3333', strvalueOutPut: '1.200.999,3333' },
-    { precision: 2, prettyprecision: 1, strvalue: '1.000', strvalueOutPut: '1,0' },
-    { precision: 2, prettyprecision: 1, strvalue: '1200999,99', strvalueOutPut: '1.200.999,99' },
-    { precision: 4, prettyprecision: 2, strvalue: '1,232,333.345', strvalueOutPut: 'NaN' },
-    { precision: 2, prettyprecision: 1, strvalue: '1,23', strvalueOutPut: '1,23' },
-    { precision: 4, prettyprecision: 2, strvalue: '1.200.999', strvalueOutPut: 'NaN' },
-    { precision: 4, prettyprecision: 0, strvalue: '1200.00001', strvalueOutPut: '1.200' },
-    { precision: 4, prettyprecision: 0, strvalue: 'String', strvalueOutPut: 'NaN' },
-    { precision: 4, prettyprecision: 0, strvalue: '', strvalueOutPut: 'NaN' },
-
-    { precision: 4, prettyprecision: undefined, strvalue: '1.200.999,3333', strvalueOutPut: '1.200.999,3333' },
-    { precision: 2, prettyprecision: undefined, strvalue: '1.000', strvalueOutPut: '1,00' },
-    { precision: 2, prettyprecision: undefined, strvalue: '1200999,99', strvalueOutPut: '1.200.999,99' },
-    { precision: 4, prettyprecision: undefined, strvalue: '1,232,333.345', strvalueOutPut: 'NaN' },
-    { precision: 2, prettyprecision: undefined, strvalue: '1,23', strvalueOutPut: '1,23' },
-    { precision: 4, prettyprecision: undefined, strvalue: '1.200.999', strvalueOutPut: 'NaN' },
-    { precision: 4, prettyprecision: undefined, strvalue: 'NaN', strvalueOutPut: 'NaN' },
-
-
-    { precision: 1, prettyprecision: -1, strvalue: '111,199', strvalueOutPut: '111,2' },
-    { precision: 1, prettyprecision: -1, strvalue: '111,1000', strvalueOutPut: '111,1' },
-    { precision: 1, prettyprecision: 1.3, strvalue: '111,100', strvalueOutPut: '111,1' },
-    { precision: -1, prettyprecision: 1, strvalue: '111,1009', strvalueOutPut: '111,1009' },
-    { precision: -1, prettyprecision: 1, strvalue: '111,1000', strvalueOutPut: '111,1' },
-    { precision: 1.2, prettyprecision: 1, strvalue: '111,1009', strvalueOutPut: '111,1009' },
+  });
 
 
-    { precision: 2, prettyprecision: -1, strvalue: '111,199', strvalueOutPut: '111,20' },
-    { precision: 2, prettyprecision: -1, strvalue: '111,1000', strvalueOutPut: '111,10' },
-    { precision: -2, prettyprecision: 1, strvalue: '111,1009', strvalueOutPut: '111,1009' },
-    { precision: -2, prettyprecision: 1, strvalue: '111,1000', strvalueOutPut: '111,1' },
+  describe('format', () => {
 
+    formatCases.forEach(e => {
+      it(`should return ${e.strvalueOutPut} when: [ value: ${e.strvalue}, precision: ${e.precision}, prettyPrecision: ${e.prettyprecision} ]`, () => {
+        expect(NumberUtils.format(e.strvalue, e.precision, e.prettyprecision)).toBe(e.strvalueOutPut);
+      });
+    });
 
-  ];
+  });
 
 
-  it('format', function () {
-    let result: string = '';
-    casesStrValue.forEach(e => {
-      result = NumberUtils.format(e.strvalue, e.precision, e.prettyprecision);
-      expect(result).toBe(e.strvalueOutPut);
-    })
+  describe('changeFormat', () => {
+    changeFormatCases.forEach(e => {
+      it(`should return ${e.outPutValue} when value is ${e.inputValue}`, () => {
+        expect(NumberUtils.changeFormat(e.inputValue)).toBe(e.outPutValue);
+      });
+    });
 
   });
 
 
+  describe('keepOnlyDecimalSeparator', () => {
 
+    keepOnlyDecimalSeparatorCases.forEach(e => {
+      it(`should return ${e.outPutValue} when: [ value: ${e.inputValue}, formatNumber: ${e.formatnumber} ]`, () => {
+        expect(NumberUtils.keepOnlyDecimalSeparator(e.inputValue, e.formatnumber)).toBe(e.outPutValue);
+      });
+    });
 
-  // keepOnlyDecimalSeparator
-  // ----------------------------------------------------------------------------------------
-  const testCasesTo_changeFormat = [
-
-    { inputValue: '1.200.999', outPutValue: '1,200,999' },
-    { inputValue: '1.000,99', outPutValue: '1,000.99' },
-    { inputValue: '1200999,99', outPutValue: '1200999.99' },
-    { inputValue: 'R$ 1,232,333.345', outPutValue: 'R$ 1.232.333,345' },
-    { inputValue: 'R$ 1.232.333,345', outPutValue: 'R$ 1,232,333.345' },
-
-  ]
+  });
 
-  it('format without formatnumber parameter', function () {
-    let result: string = '';
-    testCasesTo_changeFormat.forEach(e => {
-      result = NumberUtils.changeFormat(e.inputValue);
-      expect(result).toBe(e.outPutValue);
-    })
 
+  describe('round', () => {
+    roundTestCases.forEach(e => {
+      it(`should return ${e.outPutValue} when: [ value: ${e.inputValue}, decimal: ${e.decimal} ]`, () => {
+        expect(NumberUtils.round(e.inputValue, e.decimal)).toBe(e.outPutValue);
+      });
+    });
   });
 
 
-  // keepOnlyDecimalSeparator
-  // ----------------------------------------------------------------------------------------
-  const testCasesTo_keepOnlyDecimalSeparator = [
+  describe('safeFormat', () => {
+    safeFormatCases.forEach(e => {
+      it(`should return ${e.strvalueOutPut} when: [ value: ${e.strvalue}, precision: ${e.precision}, prettyPrecision: ${e.prettyprecision} ]`, () => {
+        expect(NumberUtils.safeFormat(e.strvalue, e.precision, e.prettyprecision)).toBe(e.strvalueOutPut);
+      });
+    });
+  });
 
-    { formatnumber: 'pt-BR', inputValue: '1.200.999', outPutValue: '1200999' },
-    { formatnumber: 'pt-BR', inputValue: '1000,99', outPutValue: '1000,99' },
-    { formatnumber: 'pt-BR', inputValue: '1200999,99', outPutValue: '1200999,99' },
-    { formatnumber: 'pt-BR', inputValue: 'R$ 1.232.333,345', outPutValue: 'R$ 1232333,345' },
 
-    { formatnumber: 'en-US', inputValue: '1,200,999', outPutValue: '1200999' },
-    { formatnumber: 'en-US', inputValue: '1,000.99', outPutValue: '1000.99' },
-    { formatnumber: 'en-US', inputValue: '1200999.99', outPutValue: '1200999.99' },
-    { formatnumber: 'en-US', inputValue: 'EUR 1,232,333.345', outPutValue: 'EUR 1232333.345' },
+  describe('getValueOrDefault', () => {
+    getValueOrDefaultCases.forEach(e => {
+      it(`should return ${e.expected} when value is ${e.value}`, () => {
+        expect(NumberUtils.getValueOrDefault(e.value, e.defaultValue)).toBe(e.expected);
+      });
+    });
+  });
 
 
-  ]
+  describe('getValueOrZero', () => {
+    getValueOrZeroCases.forEach(e => {
+      it(`should return ${e.expected} when value is ${e.value}`, () => {
+        expect(NumberUtils.getValueOrZero(e.value)).toBe(e.expected);
+      });
+    });
+  });
 
-  it('format without formatnumber parameter', function () {
-    let result: string = '';
-    testCasesTo_keepOnlyDecimalSeparator.forEach(e => {
-      result = NumberUtils.keepOnlyDecimalSeparator(e.inputValue, e.formatnumber);
-      expect(result).toBe(e.outPutValue);
-    })
 
-  });
-  
-
-  const testCasesTo_round = [
-    { decimal: undefined, inputValue: 100.12, outPutValue: 100.12 },
-    { decimal: 1, inputValue: 100.12, outPutValue: 100.1 },
-    { decimal: 2, inputValue: 100.12, outPutValue: 100.12 },
-    { decimal: 3, inputValue: 100.12, outPutValue: 100.12 },
-    { decimal: 1, inputValue: 100.15, outPutValue: 100.2 },
-    { decimal: 2, inputValue: 100.15, outPutValue: 100.15 },
-    { decimal: 3, inputValue: 100.15, outPutValue: 100.15 },
-    { decimal: 1, inputValue: 100.16, outPutValue: 100.2 },
-    { decimal: 2, inputValue: 100.16, outPutValue: 100.16 },
-    { decimal: 3, inputValue: 100.16, outPutValue: 100.16 },
-    { decimal: 12, inputValue: 2118000000000.0002, outPutValue: 2118000000000.0002 },
-    { decimal: 5, inputValue: 123.45, outPutValue: 123.45 },
-    { decimal: 0, inputValue: 123.45, outPutValue: 123 },
-  ]
-
-  it('format round number', function () {
-    let result: number;
-    testCasesTo_round.forEach(e => {
-      result = NumberUtils.round(e.inputValue, e.decimal);
-      expect(result).toBe(e.outPutValue);
-    })
+  describe('compare', () => {
+    compareCases.forEach(({ a, b, expected }) => {
+      it(`should return ${expected} when comparing ${a} and ${b}`, () => {
+        expect(NumberUtils.compare(a, b)).toBe(expected);
+      });
+    });
   });
 
 });