Zahlen mit Anzahl Nachkommastellen

[worst_case]

Hallo,

ich habe eine Zahl (single oder double) die mit einer Anzahl von Nachkommastellen angezeigt werden soll.
Die Zahl soll nicht gerundet, sondern nur Nachkommastellen abgeschnitten werden.

Zahl: 123,12
Angezeigt mit einer Nachkommastelle: 123,1
Angezeigt mit zwei Nachkommastellen: 123,12
Angezeigt mit drei Nachkommastellen: 123,120

Zahl: 123

Angezeigt mit einer Nachkommastelle: 123,0
Angezeigt mit zwei Nachkommastellen: 123,00
Angezeigt mit drei Nachkommastellen: 123,000

Wie könnte ich das lösen, bin für jeden Tipp dankbar ????

Danke !!!

[SeppJ]

Was du beschreibst, ist keine mathematische Operation, sondern eine Manipulation der speziellen Darstellung im Zehnersystem. Daher tu genau das: Schreib die Dezimaldarstellung in einen String (Bis zu einer hohen Genauigkeit, ca. 8 Stellen für Float oder 16 für double), und schneide diesen wie gewollt zurecht. Bereite dich auf Enttäuschung vor, denn deine Frage lässt vermuten, dass du falsche Annahmen darüber machst, was Zahlen sind. Wenn du beispielsweise denkst, dass der double 123.12 gleich dem Dezimalwert 123.12 wäre, dann wirst du überrascht sein über deine Ausgabe.

Falls du dich damit abgefunden hast, dass deine Anforderung vielleicht doch nicht so gut ist, kannst du auch Math.Truncate in Betracht ziehen: Multipliziere deinen Wert mit 10^(Anzahl gewünschter Stellen); Truncate; dann wieder durch 10^(Anzahl gewünschter Stellen) teilen. Das macht nicht ganz exakt das, was du beschreibst, aber vielleicht eher das, was du willst.

[Lennox]

In Java ginge das in zwei Schritten (erst in Long, dann in String umwandeln...). Das müsstest du also nur noch in das entsprechende C#-Pendant umwandeln:

public class NumbersTool {
  public static String formatNumber(double number, int decimalPlaces, char decimalSeparator) {
    if (decimalPlaces <= 0) {
      throw new IllegalArgumentException("decimalPlaces must be greater than 0");
    }
    if (decimalPlaces > 15) {
      throw new IllegalArgumentException("decimalPlaces must be less than or equal to 15");
    }
    double number1 = number * Math.pow(10, decimalPlaces);
    long number2 = (long) number1;
    String number3 = Long.toString(number2);
    if (number3.length() <= decimalPlaces) {
      number3 += "0".repeat(decimalPlaces - number3.length() + 1);
    }
    int split = number3.length() - decimalPlaces;
    return number3.substring(0, split) + decimalSeparator + number3.substring(split);
  }

  public static void main(String[] args) {
    double n1 = 123.12;
    System.out.println(formatNumber(n1, 1, ','));
    System.out.println(formatNumber(n1, 2, ','));
    System.out.println(formatNumber(n1, 3, ','));
    double n2 = 123;
    System.out.println(formatNumber(n2, 1, ','));
    System.out.println(formatNumber(n2, 2, ','));
    System.out.println(formatNumber(n2, 3, ','));
    // edge cases
    double n3 = 0;
    System.out.println(formatNumber(n3, 1, ','));
    System.out.println(formatNumber(n3, 2, ','));
    System.out.println(formatNumber(n3, 3, ','));
    double n4 = -1;
    System.out.println(formatNumber(n4, 1, ','));
    System.out.println(formatNumber(n4, 2, ','));
    System.out.println(formatNumber(n4, 3, ','));
  }
}

[Lennox]

@worst_case Es gibt leider zwei Fehler bei diesem Ansatz:

import static org.junit.jupiter.api.Assertions.*;

import org.junit.jupiter.api.Test;

class NumbersToolTest {
  @Test
  void formatNumber_1_shortNumbers() {
    assertEquals("123,1", NumbersTool.formatNumber(123.12, 1, ','));
    assertEquals("123,12", NumbersTool.formatNumber(123.12, 2, ','));
    assertEquals("123,120", NumbersTool.formatNumber(123.12, 3, ','));
    assertEquals("123,1200", NumbersTool.formatNumber(123.12, 4, ','));
    assertEquals("123,12000", NumbersTool.formatNumber(123.12, 5, ','));
    assertEquals("123,120000", NumbersTool.formatNumber(123.12, 6, ','));
    assertEquals("123,1200000", NumbersTool.formatNumber(123.12, 7, ','));
    assertEquals("123,12000000", NumbersTool.formatNumber(123.12, 8, ','));
    assertEquals("123,120000000", NumbersTool.formatNumber(123.12, 9, ','));
    assertEquals("123,1200000000", NumbersTool.formatNumber(123.12, 10, ','));
    assertEquals("123,12000000000", NumbersTool.formatNumber(123.12, 11, ','));
    assertEquals("123,120000000000", NumbersTool.formatNumber(123.12, 12, ','));
    assertEquals("123,1200000000000", NumbersTool.formatNumber(123.12, 13, ','));
    assertEquals("123,12000000000000", NumbersTool.formatNumber(123.12, 14, ','));
    assertEquals("123,120000000000000", NumbersTool.formatNumber(123.12, 15, ','));

    assertEquals("123,0", NumbersTool.formatNumber(123, 1, ','));
    assertEquals("123,00", NumbersTool.formatNumber(123, 2, ','));
    assertEquals("123,000", NumbersTool.formatNumber(123, 3, ','));
    assertEquals("123,0000", NumbersTool.formatNumber(123, 4, ','));
    assertEquals("123,00000", NumbersTool.formatNumber(123, 5, ','));
    assertEquals("123,000000", NumbersTool.formatNumber(123, 6, ','));
    assertEquals("123,0000000", NumbersTool.formatNumber(123, 7, ','));
    assertEquals("123,00000000", NumbersTool.formatNumber(123, 8, ','));
    assertEquals("123,000000000", NumbersTool.formatNumber(123, 9, ','));
    assertEquals("123,0000000000", NumbersTool.formatNumber(123, 10, ','));
    assertEquals("123,00000000000", NumbersTool.formatNumber(123, 11, ','));
    assertEquals("123,000000000000", NumbersTool.formatNumber(123, 12, ','));
    assertEquals("123,0000000000000", NumbersTool.formatNumber(123, 13, ','));
    assertEquals("123,00000000000000", NumbersTool.formatNumber(123, 14, ','));
    assertEquals("123,000000000000000", NumbersTool.formatNumber(123, 15, ','));

    assertThrows(IllegalArgumentException.class, () -> NumbersTool.formatNumber(123.12, -1, ','));
    assertThrows(IllegalArgumentException.class, () -> NumbersTool.formatNumber(123.12, 0, ','));
    assertThrows(IllegalArgumentException.class, () -> NumbersTool.formatNumber(123.12, 16, ','));
  }

  @Test
  void formatNumber_2_longNumber() {
    double n = Math.PI; // 3.14159265358979323846
    assertEquals("3,1", NumbersTool.formatNumber(n, 1, ','));
    assertEquals("3,14", NumbersTool.formatNumber(n, 2, ','));
    assertEquals("3,141", NumbersTool.formatNumber(n, 3, ','));
    assertEquals("3,1415", NumbersTool.formatNumber(n, 4, ','));
    assertEquals("3,14159", NumbersTool.formatNumber(n, 5, ','));
    assertEquals("3,141592", NumbersTool.formatNumber(n, 6, ','));
    assertEquals("3,1415926", NumbersTool.formatNumber(n, 7, ','));
    assertEquals("3,14159265", NumbersTool.formatNumber(n, 8, ','));
    assertEquals("3,141592653", NumbersTool.formatNumber(n, 9, ','));
    assertEquals("3,1415926535", NumbersTool.formatNumber(n, 10, ','));
    assertEquals("3,14159265358", NumbersTool.formatNumber(n, 11, ','));
    assertEquals("3,141592653589", NumbersTool.formatNumber(n, 12, ','));
    assertEquals("3,1415926535897", NumbersTool.formatNumber(n, 13, ','));
    assertEquals("3,14159265358979", NumbersTool.formatNumber(n, 14, ','));
    assertEquals("3,141592653589793", NumbersTool.formatNumber(n, 15, ','));

    assertThrows(IllegalArgumentException.class, () -> NumbersTool.formatNumber(n, -1, ','));
    assertThrows(IllegalArgumentException.class, () -> NumbersTool.formatNumber(n, 0, ','));
    assertThrows(IllegalArgumentException.class, () -> NumbersTool.formatNumber(n, 16, ','));
  }

  @Test
  void formatNumber_3_negativeNumber() {
    double n = -1.9911;
    assertEquals("-1,9", NumbersTool.formatNumber(n, 1, ','));
    assertEquals("-1,99", NumbersTool.formatNumber(n, 2, ','));
    assertEquals("-1,991", NumbersTool.formatNumber(n, 3, ','));
    assertEquals("-1,9911", NumbersTool.formatNumber(n, 4, ','));
    assertEquals("-1,99110", NumbersTool.formatNumber(n, 5, ','));
    assertEquals("-1,991100", NumbersTool.formatNumber(n, 6, ','));
    assertEquals("-1,9911000", NumbersTool.formatNumber(n, 7, ','));
    assertEquals("-1,99110000", NumbersTool.formatNumber(n, 8, ','));
    assertEquals("-1,991100000", NumbersTool.formatNumber(n, 9, ','));
    assertEquals("-1,9911000000", NumbersTool.formatNumber(n, 10, ','));
    assertEquals("-1,99110000000", NumbersTool.formatNumber(n, 11, ','));
    assertEquals("-1,991100000000", NumbersTool.formatNumber(n, 12, ','));
    assertEquals("-1,9911000000000", NumbersTool.formatNumber(n, 13, ','));
    assertEquals("-1,99110000000000", NumbersTool.formatNumber(n, 14, ','));
    assertEquals("-1,991100000000000", NumbersTool.formatNumber(n, 15, ','));

    assertThrows(IllegalArgumentException.class, () -> NumbersTool.formatNumber(n, -1, ','));
    assertThrows(IllegalArgumentException.class, () -> NumbersTool.formatNumber(n, 0, ','));
    assertThrows(IllegalArgumentException.class, () -> NumbersTool.formatNumber(n, 16, ','));
  }

  @Test
  void formatNumber_4_zero() {
    double n = 0;
    assertEquals("0,0", NumbersTool.formatNumber(n, 1, ','));
    assertEquals("0,00", NumbersTool.formatNumber(n, 2, ','));
    assertEquals("0,000", NumbersTool.formatNumber(n, 3, ','));
    assertEquals("0,0000", NumbersTool.formatNumber(n, 4, ','));
    assertEquals("0,00000", NumbersTool.formatNumber(n, 5, ','));
    assertEquals("0,000000", NumbersTool.formatNumber(n, 6, ','));
    assertEquals("0,0000000", NumbersTool.formatNumber(n, 7, ','));
    assertEquals("0,00000000", NumbersTool.formatNumber(n, 8, ','));
    assertEquals("0,000000000", NumbersTool.formatNumber(n, 9, ','));
    assertEquals("0,0000000000", NumbersTool.formatNumber(n, 10, ','));
    assertEquals("0,00000000000", NumbersTool.formatNumber(n, 11, ','));
    assertEquals("0,000000000000", NumbersTool.formatNumber(n, 12, ','));
    assertEquals("0,0000000000000", NumbersTool.formatNumber(n, 13, ','));
    assertEquals("0,00000000000000", NumbersTool.formatNumber(n, 14, ','));
    assertEquals("0,000000000000000", NumbersTool.formatNumber(n, 15, ','));

    assertThrows(IllegalArgumentException.class, () -> NumbersTool.formatNumber(n, -1, ','));
    assertThrows(IllegalArgumentException.class, () -> NumbersTool.formatNumber(n, 0, ','));
    assertThrows(IllegalArgumentException.class, () -> NumbersTool.formatNumber(n, 16, ','));
  }

  @Test
  void formatNumber_5_edgeCaseLargeDecimalPlaces() {
    double n = 1.0 / 3.0; // 0.3333333333333333...

    // expected: 0,3
    // but was : 3,0
    assertEquals("0,3", NumbersTool.formatNumber(n, 1, ','));

    assertEquals("0,33", NumbersTool.formatNumber(n, 2, ','));
    assertEquals("0,333", NumbersTool.formatNumber(n, 3, ','));
    assertEquals("0,3333", NumbersTool.formatNumber(n, 4, ','));
    assertEquals("0,33333", NumbersTool.formatNumber(n, 5, ','));
    assertEquals("0,333333", NumbersTool.formatNumber(n, 6, ','));
    assertEquals("0,3333333", NumbersTool.formatNumber(n, 7, ','));
    assertEquals("0,33333333", NumbersTool.formatNumber(n, 8, ','));
    assertEquals("0,333333333", NumbersTool.formatNumber(n, 9, ','));
    assertEquals("0,3333333333", NumbersTool.formatNumber(n, 10, ','));
    assertEquals("0,33333333333", NumbersTool.formatNumber(n, 11, ','));
    assertEquals("0,333333333333", NumbersTool.formatNumber(n, 12, ','));
    assertEquals("0,3333333333333", NumbersTool.formatNumber(n, 13, ','));
    assertEquals("0,33333333333333", NumbersTool.formatNumber(n, 14, ','));
    assertEquals("0,333333333333333", NumbersTool.formatNumber(n, 15, ','));

    assertThrows(IllegalArgumentException.class, () -> NumbersTool.formatNumber(n, -1, ','));
    assertThrows(IllegalArgumentException.class, () -> NumbersTool.formatNumber(n, 0, ','));
    assertThrows(IllegalArgumentException.class, () -> NumbersTool.formatNumber(n, 16, ','));
  }

  @Test
  void formatNumber_6_edgeCaseVerySmallNumber() {
    double n = 0.000000123456789;
    assertEquals("0,0", NumbersTool.formatNumber(n, 1, ','));
    assertEquals("0,00", NumbersTool.formatNumber(n, 2, ','));
    assertEquals("0,000", NumbersTool.formatNumber(n, 3, ','));
    assertEquals("0,0000", NumbersTool.formatNumber(n, 4, ','));

    // expected: 0,0000001
    // but was : 1,0000000
    assertEquals("0,00000", NumbersTool.formatNumber(n, 5, ','));

    assertEquals("0,000000", NumbersTool.formatNumber(n, 6, ','));
    assertEquals("0,0000001", NumbersTool.formatNumber(n, 7, ','));
    assertEquals("0,00000012", NumbersTool.formatNumber(n, 8, ','));
    assertEquals("0,000000123", NumbersTool.formatNumber(n, 9, ','));
    assertEquals("0,0000001235", NumbersTool.formatNumber(n, 10, ','));
    assertEquals("0,00000012346", NumbersTool.formatNumber(n, 11, ','));
    assertEquals("0,000000123457", NumbersTool.formatNumber(n, 12, ','));
    assertEquals("0,0000001234568", NumbersTool.formatNumber(n, 13, ','));
    assertEquals("0,00000012345679", NumbersTool.formatNumber(n, 14, ','));
    assertEquals("0,000000123456789", NumbersTool.formatNumber(n, 15, ','));

    assertThrows(IllegalArgumentException.class, () -> NumbersTool.formatNumber(n, -1, ','));
    assertThrows(IllegalArgumentException.class, () -> NumbersTool.formatNumber(n, 0, ','));
    assertThrows(IllegalArgumentException.class, () -> NumbersTool.formatNumber(n, 16, ','));
  }
}

Ist mir erst gar nicht aufgefallen...

[Lennox]

Besser bekomme ich das nicht hin... Ich denke, man darf nur maximal 13 Nachkommastellen zulassen, oder man sollte "BigDecimal" verwenden, falls C# die auch hat...

public class NumbersTool {
  public static String formatNumber(double number, int decimalPlaces, char decimalSeparator) {
    if (decimalPlaces <= 0) {
      throw new IllegalArgumentException("decimalPlaces must be greater than 0");
    }
    if (decimalPlaces > 15) {
      throw new IllegalArgumentException("decimalPlaces must be less than or equal to 15");
    }
    double number1 =
        number > 0
            ? Math.nextUp(number * Math.pow(10, decimalPlaces))
            : Math.nextDown(number * Math.pow(10, decimalPlaces));
    long number2 = (long) number1;
    if (number2 == 1) {
      return "0" + decimalSeparator + "0".repeat(decimalPlaces - 1) + "1";
    }
    String number3 = Long.toString(number2);
    if (number3.length() < decimalPlaces) {
      if (number2 < 10) {
        number3 += "0".repeat(decimalPlaces - number3.length() + 1);
      } else {
        number3 = "0".repeat(decimalPlaces - number3.length()) + number3;
      }
    }
    int split = number3.length() - decimalPlaces;
    if (split == 0) {
      return "0" + decimalSeparator + number3;
    }
    return number3.substring(0, split) + decimalSeparator + number3.substring(split);
  }

  public static void main(String[] args) {
    double n1 = 123.12;
    System.out.println(formatNumber(n1, 1, ','));
    System.out.println(formatNumber(n1, 2, ','));
    System.out.println(formatNumber(n1, 3, ','));
    double n2 = 123;
    System.out.println(formatNumber(n2, 1, ','));
    System.out.println(formatNumber(n2, 2, ','));
    System.out.println(formatNumber(n2, 3, ','));
  }
}

import static org.junit.jupiter.api.Assertions.*;

import org.junit.jupiter.api.Test;

class NumbersToolTest {
  @Test
  void formatNumber_1_shortNumbers() {
    assertEquals("123,1", NumbersTool.formatNumber(123.12, 1, ','));
    assertEquals("123,12", NumbersTool.formatNumber(123.12, 2, ','));
    assertEquals("123,120", NumbersTool.formatNumber(123.12, 3, ','));
    assertEquals("123,1200", NumbersTool.formatNumber(123.12, 4, ','));
    assertEquals("123,12000", NumbersTool.formatNumber(123.12, 5, ','));
    assertEquals("123,120000", NumbersTool.formatNumber(123.12, 6, ','));
    assertEquals("123,1200000", NumbersTool.formatNumber(123.12, 7, ','));
    assertEquals("123,12000000", NumbersTool.formatNumber(123.12, 8, ','));
    assertEquals("123,120000000", NumbersTool.formatNumber(123.12, 9, ','));
    assertEquals("123,1200000000", NumbersTool.formatNumber(123.12, 10, ','));
    assertEquals("123,12000000000", NumbersTool.formatNumber(123.12, 11, ','));
    assertEquals("123,120000000000", NumbersTool.formatNumber(123.12, 12, ','));
    assertEquals("123,1200000000000", NumbersTool.formatNumber(123.12, 13, ','));
    // !!!
    assertEquals("123,12000000000000", NumbersTool.formatNumber(123.12, 14, ','));
    // !!!
    assertEquals("123,120000000000000", NumbersTool.formatNumber(123.12, 15, ','));

    assertEquals("123,0", NumbersTool.formatNumber(123, 1, ','));
    assertEquals("123,00", NumbersTool.formatNumber(123, 2, ','));
    assertEquals("123,000", NumbersTool.formatNumber(123, 3, ','));
    assertEquals("123,0000", NumbersTool.formatNumber(123, 4, ','));
    assertEquals("123,00000", NumbersTool.formatNumber(123, 5, ','));
    assertEquals("123,000000", NumbersTool.formatNumber(123, 6, ','));
    assertEquals("123,0000000", NumbersTool.formatNumber(123, 7, ','));
    assertEquals("123,00000000", NumbersTool.formatNumber(123, 8, ','));
    assertEquals("123,000000000", NumbersTool.formatNumber(123, 9, ','));
    assertEquals("123,0000000000", NumbersTool.formatNumber(123, 10, ','));
    assertEquals("123,00000000000", NumbersTool.formatNumber(123, 11, ','));
    assertEquals("123,000000000000", NumbersTool.formatNumber(123, 12, ','));
    assertEquals("123,0000000000000", NumbersTool.formatNumber(123, 13, ','));
    // !!!
    assertEquals("123,00000000000000", NumbersTool.formatNumber(123, 14, ','));
    // !!!
    assertEquals("123,000000000000000", NumbersTool.formatNumber(123, 15, ','));

    assertThrows(IllegalArgumentException.class, () -> NumbersTool.formatNumber(123.12, -1, ','));
    assertThrows(IllegalArgumentException.class, () -> NumbersTool.formatNumber(123.12, 0, ','));
    assertThrows(IllegalArgumentException.class, () -> NumbersTool.formatNumber(123.12, 16, ','));
  }

  @Test
  void formatNumber_2_longNumber() {
    double n = Math.PI; // 3.14159265358979323846
    assertEquals("3,1", NumbersTool.formatNumber(n, 1, ','));
    assertEquals("3,14", NumbersTool.formatNumber(n, 2, ','));
    assertEquals("3,141", NumbersTool.formatNumber(n, 3, ','));
    assertEquals("3,1415", NumbersTool.formatNumber(n, 4, ','));
    assertEquals("3,14159", NumbersTool.formatNumber(n, 5, ','));
    assertEquals("3,141592", NumbersTool.formatNumber(n, 6, ','));
    assertEquals("3,1415926", NumbersTool.formatNumber(n, 7, ','));
    assertEquals("3,14159265", NumbersTool.formatNumber(n, 8, ','));
    assertEquals("3,141592653", NumbersTool.formatNumber(n, 9, ','));
    assertEquals("3,1415926535", NumbersTool.formatNumber(n, 10, ','));
    assertEquals("3,14159265358", NumbersTool.formatNumber(n, 11, ','));
    assertEquals("3,141592653589", NumbersTool.formatNumber(n, 12, ','));
    assertEquals("3,1415926535897", NumbersTool.formatNumber(n, 13, ','));
    assertEquals("3,14159265358979", NumbersTool.formatNumber(n, 14, ','));
    assertEquals("3,141592653589793", NumbersTool.formatNumber(n, 15, ','));

    assertThrows(IllegalArgumentException.class, () -> NumbersTool.formatNumber(n, -1, ','));
    assertThrows(IllegalArgumentException.class, () -> NumbersTool.formatNumber(n, 0, ','));
    assertThrows(IllegalArgumentException.class, () -> NumbersTool.formatNumber(n, 16, ','));
  }

  @Test
  void formatNumber_3_negativeNumber() {
    double n = -1.9911;
    assertEquals("-1,9", NumbersTool.formatNumber(n, 1, ','));
    assertEquals("-1,99", NumbersTool.formatNumber(n, 2, ','));
    assertEquals("-1,991", NumbersTool.formatNumber(n, 3, ','));
    assertEquals("-1,9911", NumbersTool.formatNumber(n, 4, ','));
    assertEquals("-1,99110", NumbersTool.formatNumber(n, 5, ','));
    assertEquals("-1,991100", NumbersTool.formatNumber(n, 6, ','));
    assertEquals("-1,9911000", NumbersTool.formatNumber(n, 7, ','));
    assertEquals("-1,99110000", NumbersTool.formatNumber(n, 8, ','));
    assertEquals("-1,991100000", NumbersTool.formatNumber(n, 9, ','));
    assertEquals("-1,9911000000", NumbersTool.formatNumber(n, 10, ','));
    assertEquals("-1,99110000000", NumbersTool.formatNumber(n, 11, ','));
    assertEquals("-1,991100000000", NumbersTool.formatNumber(n, 12, ','));
    assertEquals("-1,9911000000000", NumbersTool.formatNumber(n, 13, ','));
    assertEquals("-1,99110000000000", NumbersTool.formatNumber(n, 14, ','));
    assertEquals("-1,991100000000000", NumbersTool.formatNumber(n, 15, ','));

    assertThrows(IllegalArgumentException.class, () -> NumbersTool.formatNumber(n, -1, ','));
    assertThrows(IllegalArgumentException.class, () -> NumbersTool.formatNumber(n, 0, ','));
    assertThrows(IllegalArgumentException.class, () -> NumbersTool.formatNumber(n, 16, ','));
  }

  @Test
  void formatNumber_4_zero() {
    double n = 0;
    assertEquals("0,0", NumbersTool.formatNumber(n, 1, ','));
    assertEquals("0,00", NumbersTool.formatNumber(n, 2, ','));
    assertEquals("0,000", NumbersTool.formatNumber(n, 3, ','));
    assertEquals("0,0000", NumbersTool.formatNumber(n, 4, ','));
    assertEquals("0,00000", NumbersTool.formatNumber(n, 5, ','));
    assertEquals("0,000000", NumbersTool.formatNumber(n, 6, ','));
    assertEquals("0,0000000", NumbersTool.formatNumber(n, 7, ','));
    assertEquals("0,00000000", NumbersTool.formatNumber(n, 8, ','));
    assertEquals("0,000000000", NumbersTool.formatNumber(n, 9, ','));
    assertEquals("0,0000000000", NumbersTool.formatNumber(n, 10, ','));
    assertEquals("0,00000000000", NumbersTool.formatNumber(n, 11, ','));
    assertEquals("0,000000000000", NumbersTool.formatNumber(n, 12, ','));
    assertEquals("0,0000000000000", NumbersTool.formatNumber(n, 13, ','));
    assertEquals("0,00000000000000", NumbersTool.formatNumber(n, 14, ','));
    assertEquals("0,000000000000000", NumbersTool.formatNumber(n, 15, ','));

    assertThrows(IllegalArgumentException.class, () -> NumbersTool.formatNumber(n, -1, ','));
    assertThrows(IllegalArgumentException.class, () -> NumbersTool.formatNumber(n, 0, ','));
    assertThrows(IllegalArgumentException.class, () -> NumbersTool.formatNumber(n, 16, ','));
  }

  @Test
  void formatNumber_5_edgeCaseLargeDecimalPlaces() {
    double n = 1.0 / 3.0; // 0.3333333333333333...
    assertEquals("0,3", NumbersTool.formatNumber(n, 1, ','));
    assertEquals("0,33", NumbersTool.formatNumber(n, 2, ','));
    assertEquals("0,333", NumbersTool.formatNumber(n, 3, ','));
    assertEquals("0,3333", NumbersTool.formatNumber(n, 4, ','));
    assertEquals("0,33333", NumbersTool.formatNumber(n, 5, ','));
    assertEquals("0,333333", NumbersTool.formatNumber(n, 6, ','));
    assertEquals("0,3333333", NumbersTool.formatNumber(n, 7, ','));
    assertEquals("0,33333333", NumbersTool.formatNumber(n, 8, ','));
    assertEquals("0,333333333", NumbersTool.formatNumber(n, 9, ','));
    assertEquals("0,3333333333", NumbersTool.formatNumber(n, 10, ','));
    assertEquals("0,33333333333", NumbersTool.formatNumber(n, 11, ','));
    assertEquals("0,333333333333", NumbersTool.formatNumber(n, 12, ','));
    assertEquals("0,3333333333333", NumbersTool.formatNumber(n, 13, ','));
    assertEquals("0,33333333333333", NumbersTool.formatNumber(n, 14, ','));
    assertEquals("0,333333333333333", NumbersTool.formatNumber(n, 15, ','));

    assertThrows(IllegalArgumentException.class, () -> NumbersTool.formatNumber(n, -1, ','));
    assertThrows(IllegalArgumentException.class, () -> NumbersTool.formatNumber(n, 0, ','));
    assertThrows(IllegalArgumentException.class, () -> NumbersTool.formatNumber(n, 16, ','));
  }

  @Test
  void formatNumber_6_edgeCaseVerySmallNumber() {
    double n = 0.000000123456789;
    assertEquals("0,0", NumbersTool.formatNumber(n, 1, ','));
    assertEquals("0,00", NumbersTool.formatNumber(n, 2, ','));
    assertEquals("0,000", NumbersTool.formatNumber(n, 3, ','));
    assertEquals("0,0000", NumbersTool.formatNumber(n, 4, ','));
    assertEquals("0,00000", NumbersTool.formatNumber(n, 5, ','));
    assertEquals("0,000000", NumbersTool.formatNumber(n, 6, ','));
    assertEquals("0,0000001", NumbersTool.formatNumber(n, 7, ','));
    assertEquals("0,00000012", NumbersTool.formatNumber(n, 8, ','));
    assertEquals("0,000000123", NumbersTool.formatNumber(n, 9, ','));
    assertEquals("0,0000001234", NumbersTool.formatNumber(n, 10, ','));
    assertEquals("0,00000012345", NumbersTool.formatNumber(n, 11, ','));
    assertEquals("0,000000123456", NumbersTool.formatNumber(n, 12, ','));
    assertEquals("0,0000001234567", NumbersTool.formatNumber(n, 13, ','));
    assertEquals("0,00000012345678", NumbersTool.formatNumber(n, 14, ','));
    assertEquals("0,000000123456789", NumbersTool.formatNumber(n, 15, ','));

    assertThrows(IllegalArgumentException.class, () -> NumbersTool.formatNumber(n, -1, ','));
    assertThrows(IllegalArgumentException.class, () -> NumbersTool.formatNumber(n, 0, ','));
    assertThrows(IllegalArgumentException.class, () -> NumbersTool.formatNumber(n, 16, ','));
  }

  @Test
  void formatNumber_7_edgeCaseRounding() {
    double n = 2.675; // known floating point issue
    assertEquals("2,6", NumbersTool.formatNumber(n, 1, ','));
    assertEquals("2,67", NumbersTool.formatNumber(n, 2, ','));
    assertEquals("2,675", NumbersTool.formatNumber(n, 3, ','));
    assertEquals("2,6750", NumbersTool.formatNumber(n, 4, ','));
    assertEquals("2,67500", NumbersTool.formatNumber(n, 5, ','));
    assertEquals("2,675000", NumbersTool.formatNumber(n, 6, ','));
    assertEquals("2,6750000", NumbersTool.formatNumber(n, 7, ','));
    assertEquals("2,67500000", NumbersTool.formatNumber(n, 8, ','));
    assertEquals("2,675000000", NumbersTool.formatNumber(n, 9, ','));
    assertEquals("2,6750000000", NumbersTool.formatNumber(n, 10, ','));
    assertEquals("2,67500000000", NumbersTool.formatNumber(n, 11, ','));
    assertEquals("2,675000000000", NumbersTool.formatNumber(n, 12, ','));
    assertEquals("2,6750000000000", NumbersTool.formatNumber(n, 13, ','));
    assertEquals("2,67500000000000", NumbersTool.formatNumber(n, 14, ','));
    assertEquals("2,675000000000000", NumbersTool.formatNumber(n, 15, ','));

    assertThrows(IllegalArgumentException.class, () -> NumbersTool.formatNumber(n, -1, ','));
    assertThrows(IllegalArgumentException.class, () -> NumbersTool.formatNumber(n, 0, ','));
    assertThrows(IllegalArgumentException.class, () -> NumbersTool.formatNumber(n, 16, ','));
  }
}

Die mit "!!!" markierten Asserts schlagen fehl.