@keplr-wallet/unit 0.9.9 → 0.9.11-rc.2

package/src/int-pretty.spec.ts

@@ -3,82 +3,100 @@ import { Int } from "./int";
 import { Dec } from "./decimal";
 
 describe("Test IntPretty", () => {
-  it("Test the precision of IntPretty", () => {
+  it("Test creation of IntPretty", () => {
+    expect(new IntPretty(new Dec("1.1")).toDec().equals(new Dec("1.1"))).toBe(
+      true
+    );
+    expect(new IntPretty(new Dec("1.1")).maxDecimals(2).toString()).toBe(
+      "1.10"
+    );
+
+    expect(new IntPretty("1.1").toDec().equals(new Dec("1.1"))).toBe(true);
+    expect(new IntPretty("1.1").maxDecimals(2).toString()).toBe("1.10");
+
+    expect(new IntPretty(1.1).toDec().equals(new Dec("1.1"))).toBe(true);
+    expect(new IntPretty(1.1).maxDecimals(2).toString()).toBe("1.10");
+
+    expect(new IntPretty(new Int(1)).toDec().equals(new Dec("1.0"))).toBe(true);
+    expect(new IntPretty(new Int(1)).maxDecimals(2).toString()).toBe("1.00");
+  });
+
+  it("Test the maxDecimals of IntPretty", () => {
     const params: {
       arg: Dec | Int;
-      precision: number;
+      maxDecimals: number;
       dec: Dec;
       str: string;
     }[] = [
       {
         arg: new Int(0),
-        precision: 0,
+        maxDecimals: 0,
         dec: new Dec(0),
         str: "0",
       },
       {
         arg: new Dec(0),
-        precision: 0,
+        maxDecimals: 0,
         dec: new Dec(0),
         str: "0",
       },
       {
         arg: new Int(100),
-        precision: 0,
+        maxDecimals: 0,
         dec: new Dec(100),
         str: "100",
       },
       {
         arg: new Dec(100),
-        precision: 0,
+        maxDecimals: 0,
         dec: new Dec(100),
         str: "100",
       },
       {
         arg: new Dec("0.01"),
-        precision: 2,
+        maxDecimals: 2,
         dec: new Dec("0.01"),
         str: "0.01",
       },
       {
         arg: new Dec("-0.01"),
-        precision: 2,
+        maxDecimals: 2,
         dec: new Dec("-0.01"),
         str: "-0.01",
       },
       {
         arg: new Dec("1.01"),
-        precision: 2,
+        maxDecimals: 2,
         dec: new Dec("1.01"),
         str: "1.01",
       },
       {
         arg: new Dec("-1.01"),
-        precision: 2,
+        maxDecimals: 2,
         dec: new Dec("-1.01"),
         str: "-1.01",
       },
       {
         arg: new Dec("10.01"),
-        precision: 2,
+        maxDecimals: 2,
         dec: new Dec("10.01"),
         str: "10.01",
       },
       {
         arg: new Dec("-10.01"),
-        precision: 2,
+        maxDecimals: 2,
         dec: new Dec("-10.01"),
         str: "-10.01",
       },
       {
         arg: new Dec("10.0100"),
-        precision: 2,
+        maxDecimals: 2,
         dec: new Dec("10.01"),
         str: "10.01",
       },
       {
         arg: new Dec("-10.0100"),
-        precision: 2,
+        maxDecimals: 2,
         dec: new Dec("-10.01"),
         str: "-10.01",
       },
@@ -86,122 +104,178 @@ describe("Test IntPretty", () => {
 
     for (const param of params) {
       const pretty = new IntPretty(param.arg);
-      expect(pretty.options.precision).toBe(param.precision);
+      expect(pretty.options.maxDecimals).toBe(param.maxDecimals);
       expect(pretty.toDec().equals(param.dec)).toBeTruthy();
       expect(pretty.toString()).toBe(param.str);
     }
   });
 
   it("Test modifying the precision of IntPretty", () => {
-    let pretty = new IntPretty(new Dec("10.001"));
-    expect(pretty.options.precision).toBe(3);
-    expect(pretty.toString()).toBe("10.001");
-
-    let newPretty = pretty.precision(4);
-    expect(newPretty.options.precision).toBe(4);
-    // Max decimals not changed
-    expect(newPretty.toString()).toBe("1.000");
-    expect(newPretty.maxDecimals(4).toString()).toBe("1.0001");
-
-    newPretty = pretty.increasePrecision(1);
-    expect(newPretty.options.precision).toBe(4);
-    expect(newPretty.toString()).toBe("1.000");
-    expect(newPretty.maxDecimals(4).toString()).toBe("1.0001");
+    const tests: {
+      base: Dec;
+      delta: number;
+      right: boolean;
+      res: Dec;
+      resStr: string;
+      otherTest?: (int: IntPretty) => void;
+    }[] = [
+      {
+        base: new Dec("10.001"),
+        delta: 0,
+        right: false,
+        res: new Dec("10.001"),
+        resStr: "10.001",
+        otherTest: (int) => {
+          expect(int.maxDecimals(4).toString()).toBe("10.0010");
+        },
+      },
+      {
+        base: new Dec("10.001"),
+        delta: 1,
+        right: false,
+        res: new Dec("1.0001"),
+        resStr: "1.000",
+        otherTest: (int) => {
+          expect(int.maxDecimals(4).toString()).toBe("1.0001");
+        },
+      },
+      {
+        base: new Dec("10.001"),
+        delta: 1,
+        right: true,
+        res: new Dec("100.010"),
+        resStr: "100.010",
+        otherTest: (int) => {
+          expect(int.maxDecimals(4).toString()).toBe("100.0100");
+        },
+      },
+      {
+        base: new Dec("10.001"),
+        delta: 6,
+        right: true,
+        res: new Dec("10001000"),
+        resStr: "10,001,000.000",
+      },
+      {
+        base: new Dec("0"),
+        delta: 3,
+        right: false,
+        res: new Dec("0"),
+        resStr: "0",
+      },
+      {
+        base: new Dec("0"),
+        delta: 3,
+        right: true,
+        res: new Dec("0"),
+        resStr: "0",
+      },
+      {
+        base: new Dec("100.01"),
+        delta: 20,
+        right: true,
+        res: new Dec("10001000000000000000000"),
+        resStr: "10,001,000,000,000,000,000,000.00",
+      },
+      {
+        base: new Dec("100.01"),
+        delta: 20,
+        right: false,
+        res: new Dec("0.000000000000000001"),
+        resStr: "0.00",
+        otherTest: (int) => {
+          expect(int.trim(true).toString()).toBe("0");
+        },
+      },
+    ];
 
-    newPretty = pretty.precision(2);
-    expect(newPretty.options.precision).toBe(2);
-    expect(newPretty.toString()).toBe("100.010");
+    for (const test of tests) {
+      let pretty = new IntPretty(test.base);
 
-    newPretty = pretty.decreasePrecision(1);
-    expect(newPretty.options.precision).toBe(2);
-    expect(newPretty.toString()).toBe("100.010");
+      if (test.right) {
+        pretty = pretty.moveDecimalPointRight(test.delta);
+      } else {
+        pretty = pretty.moveDecimalPointLeft(test.delta);
+      }
 
-    newPretty = pretty.decreasePrecision(6);
-    expect(newPretty.options.precision).toBe(-3);
-    expect(newPretty.toString()).toBe("10,001,000.000");
+      expect(pretty.toDec().equals(test.res)).toBeTruthy();
+      expect(pretty.toString()).toBe(test.resStr);
 
-    pretty = new IntPretty(new Int(0));
-    expect(pretty.decreasePrecision(3).toString()).toBe("0");
-    expect(pretty.increasePrecision(3).toString()).toBe("0");
+      if (test.otherTest) {
+        test.otherTest(pretty);
+      }
+    }
 
-    expect(() => {
-      pretty.precision(-18);
-    }).not.toThrow();
+    for (const test of tests) {
+      let pretty = new IntPretty(test.base);
 
-    expect(() => {
-      pretty.precision(18);
-    }).not.toThrow();
+      if (test.right) {
+        pretty = pretty.decreasePrecision(test.delta);
+      } else {
+        pretty = pretty.increasePrecision(test.delta);
+      }
 
-    expect(() => {
-      pretty.precision(-19);
-    }).toThrow();
+      expect(pretty.toDec().equals(test.res)).toBeTruthy();
+      expect(pretty.toString()).toBe(test.resStr);
 
-    expect(() => {
-      pretty.precision(19);
-    }).toThrow();
+      if (test.otherTest) {
+        test.otherTest(pretty);
+      }
+    }
   });
 
   it("Test the add calcutation of IntPretty", () => {
     const params: {
       base: Dec | Int;
       target: Dec | Int;
-      precision: number;
       dec: Dec;
       str: string;
     }[] = [
       {
         base: new Int(0),
         target: new Int(0),
-        precision: 0,
         dec: new Dec(0),
         str: "0",
       },
       {
         base: new Dec(0),
         target: new Int(0),
-        precision: 0,
         dec: new Dec(0),
         str: "0",
       },
       {
         base: new Int(0),
         target: new Dec(0),
-        precision: 0,
         dec: new Dec(0),
         str: "0",
       },
       {
         base: new Int(1),
         target: new Dec(1),
-        precision: 0,
         dec: new Dec(2),
         str: "2",
       },
       {
         base: new Int(1),
         target: new Dec(-1),
-        precision: 0,
         dec: new Dec(0),
         str: "0",
       },
       {
         base: new Int(100),
         target: new Dec(-1),
-        precision: 0,
         dec: new Dec("99"),
         str: "99",
       },
       {
         base: new Dec("100.001"),
         target: new Dec(-1),
-        precision: 3,
         dec: new Dec("99.001"),
         str: "99.001",
       },
       {
         base: new Dec("100.00100"),
         target: new Dec("-1.001"),
-        precision: 0,
         dec: new Dec("99"),
         // Max decimals should be remain
         str: "99.000",
@@ -209,7 +283,6 @@ describe("Test IntPretty", () => {
       {
         base: new Dec("100.00100"),
         target: new Dec("-0.00100"),
-        precision: 0,
         dec: new Dec("100"),
         // Max decimals should be remain
         str: "100.000",
@@ -217,7 +290,6 @@ describe("Test IntPretty", () => {
       {
         base: new Dec("0.00100"),
         target: new Dec("-1.00100"),
-        precision: 0,
         dec: new Dec("-1"),
         // Max decimals should be remain
         str: "-1.000",
@@ -225,7 +297,6 @@ describe("Test IntPretty", () => {
       {
         base: new Dec("100.00100"),
         target: new Dec("1.01"),
-        precision: 3,
         dec: new Dec("101.011"),
         str: "101.011",
       },
@@ -233,7 +304,6 @@ describe("Test IntPretty", () => {
 
     for (const param of params) {
       const pretty = new IntPretty(param.base).add(new IntPretty(param.target));
-      expect(pretty.options.precision).toBe(param.precision);
       expect(pretty.toDec().equals(param.dec)).toBeTruthy();
       expect(pretty.toString()).toBe(param.str);
     }
@@ -243,63 +313,54 @@ describe("Test IntPretty", () => {
     const params: {
       base: Dec | Int;
       target: Dec | Int;
-      precision: number;
       dec: Dec;
       str: string;
     }[] = [
       {
         base: new Int(0),
         target: new Int(0),
-        precision: 0,
         dec: new Dec(0),
         str: "0",
       },
       {
         base: new Dec(0),
         target: new Int(0),
-        precision: 0,
         dec: new Dec(0),
         str: "0",
       },
       {
         base: new Int(0),
         target: new Dec(0),
-        precision: 0,
         dec: new Dec(0),
         str: "0",
       },
       {
         base: new Int(1),
         target: new Dec(1),
-        precision: 0,
         dec: new Dec(0),
         str: "0",
       },
       {
         base: new Int(1),
         target: new Dec(-1),
-        precision: 0,
         dec: new Dec(2),
         str: "2",
       },
       {
         base: new Int(100),
         target: new Dec(-1),
-        precision: 0,
         dec: new Dec("101"),
         str: "101",
       },
       {
         base: new Dec("100.001"),
         target: new Dec(-1),
-        precision: 3,
         dec: new Dec("101.001"),
         str: "101.001",
       },
       {
         base: new Dec("100.00100"),
         target: new Dec("1.001"),
-        precision: 0,
         dec: new Dec("99"),
         // Max decimals should be remain
         str: "99.000",
@@ -307,7 +368,6 @@ describe("Test IntPretty", () => {
       {
         base: new Dec("100.00100"),
         target: new Dec("0.00100"),
-        precision: 0,
         dec: new Dec("100"),
         // Max decimals should be remain
         str: "100.000",
@@ -315,14 +375,12 @@ describe("Test IntPretty", () => {
       {
         base: new Dec("0.00100"),
         target: new Dec("-1.00100"),
-        precision: 3,
         dec: new Dec("1.002"),
         str: "1.002",
       },
       {
         base: new Dec("100.00100"),
         target: new Dec("-1.01"),
-        precision: 3,
         dec: new Dec("101.011"),
         str: "101.011",
       },
@@ -330,7 +388,6 @@ describe("Test IntPretty", () => {
 
     for (const param of params) {
       const pretty = new IntPretty(param.base).sub(new IntPretty(param.target));
-      expect(pretty.options.precision).toBe(param.precision);
       expect(pretty.toDec().equals(param.dec)).toBeTruthy();
       expect(pretty.toString()).toBe(param.str);
     }
@@ -340,63 +397,54 @@ describe("Test IntPretty", () => {
     const params: {
       base: Dec | Int;
       target: Dec | Int;
-      precision: number;
       dec: Dec;
       str: string;
     }[] = [
       {
         base: new Int(0),
         target: new Int(0),
-        precision: 0,
         dec: new Dec(0),
         str: "0",
       },
       {
         base: new Dec(0),
         target: new Int(0),
-        precision: 0,
         dec: new Dec(0),
         str: "0",
       },
       {
         base: new Int(0),
         target: new Dec(0),
-        precision: 0,
         dec: new Dec(0),
         str: "0",
       },
       {
         base: new Int(1),
         target: new Dec(1),
-        precision: 0,
         dec: new Dec(1),
         str: "1",
       },
       {
         base: new Int(1),
         target: new Dec(-1),
-        precision: 0,
         dec: new Dec(-1),
         str: "-1",
       },
       {
         base: new Int(100),
         target: new Dec(-1),
-        precision: 0,
         dec: new Dec("-100"),
         str: "-100",
       },
       {
         base: new Dec("100.001"),
         target: new Dec(-1),
-        precision: 3,
         dec: new Dec("-100.001"),
         str: "-100.001",
       },
       {
         base: new Dec("100.00100"),
         target: new Dec("1.001"),
-        precision: 6,
         dec: new Dec("100.101001"),
         // Max decimals should be remain
         str: "100.101",
@@ -404,7 +452,6 @@ describe("Test IntPretty", () => {
       {
         base: new Dec("100.00100"),
         target: new Dec("0.00100"),
-        precision: 6,
         dec: new Dec("0.100001"),
         // Max decimals should be remain
         str: "0.100",
@@ -412,7 +459,6 @@ describe("Test IntPretty", () => {
       {
         base: new Dec("100.00100"),
         target: new Dec("-1.00100"),
-        precision: 6,
         dec: new Dec("-100.101001"),
         // Max decimals should be remain
         str: "-100.101",
@@ -420,7 +466,6 @@ describe("Test IntPretty", () => {
       {
         base: new Dec("100.00100"),
         target: new Dec("-0.00100"),
-        precision: 6,
         dec: new Dec("-0.100001"),
         // Max decimals should be remain
         str: "-0.100",
@@ -429,7 +474,6 @@ describe("Test IntPretty", () => {
 
     for (const param of params) {
       const pretty = new IntPretty(param.base).mul(new IntPretty(param.target));
-      expect(pretty.options.precision).toBe(param.precision);
       expect(pretty.toDec().equals(param.dec)).toBeTruthy();
       expect(pretty.toString()).toBe(param.str);
     }
@@ -443,49 +487,42 @@ describe("Test IntPretty", () => {
     const params: {
       base: Dec | Int;
       target: Dec | Int;
-      precision: number;
       dec: Dec;
       str: string;
     }[] = [
       {
         base: new Int(1),
         target: new Dec(1),
-        precision: 0,
         dec: new Dec(1),
         str: "1",
       },
       {
         base: new Int(1),
         target: new Dec(-1),
-        precision: 0,
         dec: new Dec(-1),
         str: "-1",
       },
       {
         base: new Int(100),
         target: new Dec(-1),
-        precision: 0,
         dec: new Dec("-100"),
         str: "-100",
       },
       {
         base: new Dec("100.001"),
         target: new Dec(-1),
-        precision: 3,
         dec: new Dec("-100.001"),
         str: "-100.001",
       },
       {
         base: new Dec("300.00300"),
         target: new Dec("3"),
-        precision: 3,
         dec: new Dec("100.001"),
         str: "100.001",
       },
       {
         base: new Dec("100.00500"),
         target: new Dec("0.02"),
-        precision: 2,
         dec: new Dec("5000.25"),
         // Max decimals should be remain
         str: "5,000.250",
@@ -493,7 +530,6 @@ describe("Test IntPretty", () => {
       {
         base: new Dec("300.00300"),
         target: new Dec("4"),
-        precision: 5,
         dec: new Dec("75.00075"),
         // Max decimals should be remain
         str: "75.000",
@@ -502,7 +538,6 @@ describe("Test IntPretty", () => {
 
     for (const param of params) {
       const pretty = new IntPretty(param.base).quo(new IntPretty(param.target));
-      expect(pretty.options.precision).toBe(param.precision);
       expect(pretty.toDec().equals(param.dec)).toBeTruthy();
       expect(pretty.toString()).toBe(param.str);
     }
@@ -525,4 +560,164 @@ describe("Test IntPretty", () => {
     expect(pretty.maxDecimals(9).trim(true).toString()).toBe("0.0123456");
     expect(pretty.shrink(true).toString()).toBe("0.0123456");
   });
+
+  it("Test inequalitySymbol of IntPretty", () => {
+    const tests: {
+      base: IntPretty;
+      maxDecimals: number;
+      inequalitySymbolSeparator: string;
+      resStr: string;
+    }[] = [
+      {
+        base: new IntPretty(new Dec("0")),
+        maxDecimals: 3,
+        inequalitySymbolSeparator: " ",
+        resStr: "0.000",
+      },
+      {
+        base: new IntPretty(new Dec("-0")),
+        maxDecimals: 3,
+        inequalitySymbolSeparator: " ",
+        resStr: "0.000",
+      },
+      {
+        base: new IntPretty(new Dec("0.1")),
+        maxDecimals: 3,
+        inequalitySymbolSeparator: " ",
+        resStr: "0.100",
+      },
+      {
+        base: new IntPretty(new Dec("1234.123456")),
+        maxDecimals: 3,
+        inequalitySymbolSeparator: " ",
+        resStr: "1,234.123",
+      },
+      {
+        base: new IntPretty(new Dec("0.123456")),
+        maxDecimals: 3,
+        inequalitySymbolSeparator: " ",
+        resStr: "0.123",
+      },
+      {
+        base: new IntPretty(new Dec("0.123456")).moveDecimalPointLeft(2),
+        maxDecimals: 3,
+        inequalitySymbolSeparator: " ",
+        resStr: "0.001",
+      },
+      {
+        base: new IntPretty(new Dec("0.123456")).moveDecimalPointLeft(3),
+        maxDecimals: 3,
+        inequalitySymbolSeparator: " ",
+        resStr: "< 0.001",
+      },
+      {
+        base: new IntPretty(new Dec("0.123456")),
+        maxDecimals: 0,
+        inequalitySymbolSeparator: " ",
+        resStr: "< 1",
+      },
+      {
+        base: new IntPretty(new Dec("1.123456")),
+        maxDecimals: 0,
+        inequalitySymbolSeparator: " ",
+        resStr: "1",
+      },
+      {
+        base: new IntPretty(new Dec("0.0001")),
+        maxDecimals: 3,
+        inequalitySymbolSeparator: " ",
+        resStr: "< 0.001",
+      },
+      {
+        base: new IntPretty(new Dec("0.0001")),
+        maxDecimals: 3,
+        inequalitySymbolSeparator: "",
+        resStr: "<0.001",
+      },
+      {
+        base: new IntPretty(new Dec("0.001")),
+        maxDecimals: 3,
+        inequalitySymbolSeparator: " ",
+        resStr: "0.001",
+      },
+      {
+        base: new IntPretty(new Dec("-1234.123456")),
+        maxDecimals: 3,
+        inequalitySymbolSeparator: " ",
+        resStr: "-1,234.123",
+      },
+      {
+        base: new IntPretty(new Dec("-0.123456")),
+        maxDecimals: 3,
+        inequalitySymbolSeparator: " ",
+        resStr: "-0.123",
+      },
+      {
+        base: new IntPretty(new Dec("-0.0001")),
+        maxDecimals: 3,
+        inequalitySymbolSeparator: " ",
+        resStr: "> -0.001",
+      },
+      {
+        base: new IntPretty(new Dec("-0.0001")),
+        maxDecimals: 3,
+        inequalitySymbolSeparator: "",
+        resStr: ">-0.001",
+      },
+      {
+        base: new IntPretty(new Dec("-0.001")),
+        maxDecimals: 3,
+        inequalitySymbolSeparator: " ",
+        resStr: "-0.001",
+      },
+      {
+        base: new IntPretty(new Dec("-0.123456")),
+        maxDecimals: 0,
+        inequalitySymbolSeparator: " ",
+        resStr: "> -1",
+      },
+      {
+        base: new IntPretty(new Dec("-1.123456")),
+        maxDecimals: 0,
+        inequalitySymbolSeparator: " ",
+        resStr: "-1",
+      },
+    ];
+
+    for (const test of tests) {
+      expect(
+        test.base
+          .maxDecimals(test.maxDecimals)
+          .inequalitySymbol(true)
+          .inequalitySymbolSeparator(test.inequalitySymbolSeparator)
+          .toString()
+      ).toBe(test.resStr);
+    }
+  });
+
+  it("Test toStringWithSymbols() of IntPretty", () => {
+    expect(
+      new IntPretty(new Dec(-123.45)).toStringWithSymbols("$", "SUFFIX")
+    ).toBe("-$123.45SUFFIX");
+
+    expect(
+      new IntPretty(new Dec(-123.45))
+        .maxDecimals(0)
+        .toStringWithSymbols("$", "SUFFIX")
+    ).toBe("-$123SUFFIX");
+
+    expect(
+      new IntPretty(new Dec(-0.045))
+        .maxDecimals(1)
+        .inequalitySymbol(true)
+        .toStringWithSymbols("$", "SUFFIX")
+    ).toBe("> -$0.1SUFFIX");
+
+    expect(
+      new IntPretty(new Dec(0.045))
+        .maxDecimals(1)
+        .inequalitySymbol(true)
+        .toStringWithSymbols("$", "SUFFIX")
+    ).toBe("< $0.1SUFFIX");
+  });
 });