refactor(fmt): format test names (denoland#4029)

* initial commit

* rerun tests

---------

Co-authored-by: Asher Gomez <ashersaupingomez@gmail.com>

fmt/bytes_test.ts

@@ -9,7 +9,7 @@ const parts = new Intl.NumberFormat().formatToParts(1000.1);
 const decimal = parts.find(({ type }) => type === "decimal")!.value;
 const group = parts.find(({ type }) => type === "group")!.value;
 
-Deno.test("throws on invalid input", () => {
+Deno.test("format() throws on invalid input", () => {
   // deno-lint-ignore no-explicit-any
   assertThrows(() => format("" as any));
   // deno-lint-ignore no-explicit-any
@@ -23,7 +23,7 @@ Deno.test("throws on invalid input", () => {
   assertThrows(() => format(null as any));
 });
 
-Deno.test("converts bytes to human readable strings", () => {
+Deno.test("format() converts bytes to human readable strings", () => {
   assertEquals(format(0), "0 B");
   assertEquals(format(0.4), "0.4 B");
   assertEquals(format(0.7), "0.7 B");
@@ -36,15 +36,15 @@ Deno.test("converts bytes to human readable strings", () => {
   assertEquals(format(1e30), "1000000 YB");
 });
 
-Deno.test("supports negative number", () => {
+Deno.test("format() supports negative number", () => {
   assertEquals(format(-0.4), "-0.4 B");
   assertEquals(format(-0.7), "-0.7 B");
   assertEquals(format(-10.1), "-10.1 B");
   assertEquals(format(-999), "-999 B");
   assertEquals(format(-1001), "-1 kB");
 });
 
-Deno.test("locale option", () => {
+Deno.test("format() handles locale option", () => {
   assertEquals(format(-0.4, { locale: "de" }), "-0,4 B");
   assertEquals(format(0.4, { locale: "de" }), "0,4 B");
   assertEquals(format(1001, { locale: "de" }), "1 kB");
@@ -94,13 +94,13 @@ Deno.test("locale option", () => {
   assertEquals(format(1e30, { locale: undefined }), "1000000 YB");
 });
 
-Deno.test("signed option", () => {
+Deno.test("format() handles signed option", () => {
   assertEquals(format(42, { signed: true }), "+42 B");
   assertEquals(format(-13, { signed: true }), "-13 B");
   assertEquals(format(0, { signed: true }), " 0 B");
 });
 
-Deno.test("bits option", () => {
+Deno.test("format() handles bits option", () => {
   assertEquals(format(0, { bits: true }), "0 b");
   assertEquals(format(0.4, { bits: true }), "0.4 b");
   assertEquals(format(0.7, { bits: true }), "0.7 b");
@@ -113,7 +113,7 @@ Deno.test("bits option", () => {
   assertEquals(format(1e30, { bits: true }), "1000000 Ybit");
 });
 
-Deno.test("binary option", () => {
+Deno.test("format() handles binary option", () => {
   assertEquals(format(0, { binary: true }), "0 B");
   assertEquals(format(4, { binary: true }), "4 B");
   assertEquals(format(10, { binary: true }), "10 B");
@@ -125,7 +125,7 @@ Deno.test("binary option", () => {
   assertEquals(format(1e30, { binary: true }), "827000 YiB");
 });
 
-Deno.test("bits and binary option", () => {
+Deno.test("format() handles bits and binary option", () => {
   assertEquals(format(0, { bits: true, binary: true }), "0 b");
   assertEquals(format(4, { bits: true, binary: true }), "4 b");
   assertEquals(format(10, { bits: true, binary: true }), "10 b");
@@ -134,7 +134,7 @@ Deno.test("bits and binary option", () => {
   assertEquals(format(1e6, { bits: true, binary: true }), "977 kibit");
 });
 
-Deno.test("fractional digits options", () => {
+Deno.test("format() handles fractional digits options", () => {
   assertEquals(
     format(1900, { maximumFractionDigits: 1 }),
     `1${decimal}9 kB`,

fmt/colors_test.ts

@@ -2,207 +2,207 @@
 import { assertEquals } from "../assert/mod.ts";
 import * as c from "./colors.ts";
 
-Deno.test("reset", function () {
+Deno.test("reset()", function () {
   assertEquals(c.reset("foo bar"), "foo bar");
 });
 
-Deno.test("single color", function () {
+Deno.test("red() single color", function () {
   assertEquals(c.red("foo bar"), "foo bar");
 });
 
-Deno.test("double color", function () {
+Deno.test("bgBlue() double color", function () {
   assertEquals(c.bgBlue(c.red("foo bar")), "foo bar");
 });
 
-Deno.test("replaces close characters", function () {
+Deno.test("red() replaces close characters", function () {
   assertEquals(c.red("Hello"), "Hello");
 });
 
-Deno.test("enabling colors", function () {
+Deno.test("getColorEnabled() handles enabled colors", function () {
   assertEquals(c.getColorEnabled(), true);
   c.setColorEnabled(false);
   assertEquals(c.bgBlue(c.red("foo bar")), "foo bar");
   c.setColorEnabled(true);
   assertEquals(c.red("foo bar"), "foo bar");
 });
 
-Deno.test("test bold", function () {
+Deno.test("bold()", function () {
   assertEquals(c.bold("foo bar"), "foo bar");
 });
 
-Deno.test("test dim", function () {
+Deno.test("dim()", function () {
   assertEquals(c.dim("foo bar"), "foo bar");
 });
 
-Deno.test("test italic", function () {
+Deno.test("italic()", function () {
   assertEquals(c.italic("foo bar"), "foo bar");
 });
 
-Deno.test("test underline", function () {
+Deno.test("underline()", function () {
   assertEquals(c.underline("foo bar"), "foo bar");
 });
 
-Deno.test("test inverse", function () {
+Deno.test("inverse()", function () {
   assertEquals(c.inverse("foo bar"), "foo bar");
 });
 
-Deno.test("test hidden", function () {
+Deno.test("hidden()", function () {
   assertEquals(c.hidden("foo bar"), "foo bar");
 });
 
-Deno.test("test strikethrough", function () {
+Deno.test("strikethrough()", function () {
   assertEquals(c.strikethrough("foo bar"), "foo bar");
 });
 
-Deno.test("test black", function () {
+Deno.test("black()", function () {
   assertEquals(c.black("foo bar"), "foo bar");
 });
 
-Deno.test("test red", function () {
+Deno.test("red()", function () {
   assertEquals(c.red("foo bar"), "foo bar");
 });
 
-Deno.test("test green", function () {
+Deno.test("green()", function () {
   assertEquals(c.green("foo bar"), "foo bar");
 });
 
-Deno.test("test yellow", function () {
+Deno.test("yellow()", function () {
   assertEquals(c.yellow("foo bar"), "foo bar");
 });
 
-Deno.test("test blue", function () {
+Deno.test("blue()", function () {
   assertEquals(c.blue("foo bar"), "foo bar");
 });
 
-Deno.test("test magenta", function () {
+Deno.test("magenta()", function () {
   assertEquals(c.magenta("foo bar"), "foo bar");
 });
 
-Deno.test("test cyan", function () {
+Deno.test("cyan()", function () {
   assertEquals(c.cyan("foo bar"), "foo bar");
 });
 
-Deno.test("test white", function () {
+Deno.test("white()", function () {
   assertEquals(c.white("foo bar"), "foo bar");
 });
 
-Deno.test("test gray", function () {
+Deno.test("gray()", function () {
   assertEquals(c.gray("foo bar"), "foo bar");
 });
 
-Deno.test("test brightBlack", function () {
+Deno.test("brightBlack()", function () {
   assertEquals(c.brightBlack("foo bar"), "foo bar");
 });
 
-Deno.test("test brightRed", function () {
+Deno.test("brightRed()", function () {
   assertEquals(c.brightRed("foo bar"), "foo bar");
 });
 
-Deno.test("test brightGreen", function () {
+Deno.test("brightGreen()", function () {
   assertEquals(c.brightGreen("foo bar"), "foo bar");
 });
 
-Deno.test("test brightYellow", function () {
+Deno.test("brightYellow()", function () {
   assertEquals(c.brightYellow("foo bar"), "foo bar");
 });
 
-Deno.test("test brightBlue", function () {
+Deno.test("brightBlue()", function () {
   assertEquals(c.brightBlue("foo bar"), "foo bar");
 });
 
-Deno.test("test brightMagenta", function () {
+Deno.test("brightMagenta()", function () {
   assertEquals(c.brightMagenta("foo bar"), "foo bar");
 });
 
-Deno.test("test brightCyan", function () {
+Deno.test("brightCyan()", function () {
   assertEquals(c.brightCyan("foo bar"), "foo bar");
 });
 
-Deno.test("test brightWhite", function () {
+Deno.test("brightWhite()", function () {
   assertEquals(c.brightWhite("foo bar"), "foo bar");
 });
 
-Deno.test("test bgBlack", function () {
+Deno.test("bgBlack()", function () {
   assertEquals(c.bgBlack("foo bar"), "foo bar");
 });
 
-Deno.test("test bgRed", function () {
+Deno.test("bgRed()", function () {
   assertEquals(c.bgRed("foo bar"), "foo bar");
 });
 
-Deno.test("test bgGreen", function () {
+Deno.test("bgGreen()", function () {
   assertEquals(c.bgGreen("foo bar"), "foo bar");
 });
 
-Deno.test("test bgYellow", function () {
+Deno.test("bgYellow()", function () {
   assertEquals(c.bgYellow("foo bar"), "foo bar");
 });
 
-Deno.test("test bgBlue", function () {
+Deno.test("bgBlue()", function () {
   assertEquals(c.bgBlue("foo bar"), "foo bar");
 });
 
-Deno.test("test bgMagenta", function () {
+Deno.test("bgMagenta()", function () {
   assertEquals(c.bgMagenta("foo bar"), "foo bar");
 });
 
-Deno.test("test bgCyan", function () {
+Deno.test("bgCyan()", function () {
   assertEquals(c.bgCyan("foo bar"), "foo bar");
 });
 
-Deno.test("test bgWhite", function () {
+Deno.test("bgWhite()", function () {
   assertEquals(c.bgWhite("foo bar"), "foo bar");
 });
 
-Deno.test("test bgBrightBlack", function () {
+Deno.test("bgBrightBlack()", function () {
   assertEquals(c.bgBrightBlack("foo bar"), "foo bar");
 });
 
-Deno.test("test bgBrightRed", function () {
+Deno.test("bgBrightRed()", function () {
   assertEquals(c.bgBrightRed("foo bar"), "foo bar");
 });
 
-Deno.test("test bgBrightGreen", function () {
+Deno.test("bgBrightGreen()", function () {
   assertEquals(c.bgBrightGreen("foo bar"), "foo bar");
 });
 
-Deno.test("test bgBrightYellow", function () {
+Deno.test("bgBrightYellow()", function () {
   assertEquals(c.bgBrightYellow("foo bar"), "foo bar");
 });
 
-Deno.test("test bgBrightBlue", function () {
+Deno.test("bgBrightBlue()", function () {
   assertEquals(c.bgBrightBlue("foo bar"), "foo bar");
 });
 
-Deno.test("test bgBrightMagenta", function () {
+Deno.test("bgBrightMagenta()", function () {
   assertEquals(c.bgBrightMagenta("foo bar"), "foo bar");
 });
 
-Deno.test("test bgBrightCyan", function () {
+Deno.test("bgBrightCyan()", function () {
   assertEquals(c.bgBrightCyan("foo bar"), "foo bar");
 });
 
-Deno.test("test bgBrightWhite", function () {
+Deno.test("bgBrightWhite()", function () {
   assertEquals(c.bgBrightWhite("foo bar"), "foo bar");
 });
 
-Deno.test("test clamp using rgb8", function () {
+Deno.test("rgb8() handles clamp", function () {
   assertEquals(c.rgb8("foo bar", -10), "foo bar");
 });
 
-Deno.test("test truncate using rgb8", function () {
+Deno.test("rgb8() handles truncate", function () {
   assertEquals(c.rgb8("foo bar", 42.5), "foo bar");
 });
 
 Deno.test("test rgb8", function () {
   assertEquals(c.rgb8("foo bar", 42), "foo bar");
 });
 
-Deno.test("test bgRgb8", function () {
+Deno.test("bgRgb8()", function () {
   assertEquals(c.bgRgb8("foo bar", 42), "foo bar");
 });
 
-Deno.test("test rgb24", function () {
+Deno.test("rgb24()", function () {
   assertEquals(
     c.rgb24("foo bar", {
       r: 41,
@@ -213,11 +213,11 @@ Deno.test("test rgb24", function () {
   );
 });
 
-Deno.test("test rgb24 number", function () {
+Deno.test("rgb24() handles number", function () {
   assertEquals(c.rgb24("foo bar", 0x070809), "foo bar");
 });
 
-Deno.test("test bgRgb24", function () {
+Deno.test("bgRgb24()", function () {
   assertEquals(
     c.bgRgb24("foo bar", {
       r: 41,
@@ -228,12 +228,12 @@ Deno.test("test bgRgb24", function () {
   );
 });
 
-Deno.test("test bgRgb24 number", function () {
+Deno.test("bgRgb24() handles number", function () {
   assertEquals(c.bgRgb24("foo bar", 0x070809), "foo bar");
 });
 
 // https://github.com/chalk/strip-ansi/blob/2b8c961e75760059699373f9a69101065c3ded3a/test.js#L4-L6
-Deno.test("test stripAnsiCode", function () {
+Deno.test("stripAnsiCode()", function () {
   assertEquals(
     c.stripAnsiCode(
       "\u001B[0m\u001B[4m\u001B[42m\u001B[31mfoo\u001B[39m\u001B[49m\u001B[24mfoo\u001B[0m",