SSL test_natural-sort.js Sprache: JAVA

/* Any copyright is dedicated to the Public Domain.
   http://creativecommons.org/publicdomain/zero/1.0/ */

"use strict";

const l10n = new Localization(["devtools/client/storage.ftl"], true);
const sessionString = l10n.formatValueSync("storage-expires-session");
const {
  naturalSortCaseSensitive,
  naturalSortCaseInsensitive,
} = require("resource://devtools/shared/natural-sort.js");

function run_test() {
  test("different values types", function () {
    runTest(["a", 1], [1, "a"], "number always comes first");
    runTest(
      ["1", 1],
      ["1", 1],
      "number vs numeric string - should remain unchanged (error in chrome)"
    );
    runTest(
      ["02", 3, 2, "01"],
      ["01", "02", 2, 3],
      "padding numeric string vs number"
    );
  });

  test("datetime", function () {
    runTest(
      ["10/12/2008", "10/11/2008", "10/11/2007", "10/12/2007"],
      ["10/11/2007", "10/12/2007", "10/11/2008", "10/12/2008"],
      "similar dates"
    );
    runTest(
      ["01/01/2008", "01/10/2008", "01/01/1992", "01/01/1991"],
      ["01/01/1991", "01/01/1992", "01/01/2008", "01/10/2008"],
      "similar dates"
    );
    // Years should expand to 0100, 2001, 2010
    runTest(
      ["1/1/100", "1/1/1", "1/1/10"],
      ["1/1/100", "1/1/1", "1/1/10"],
      "dates with short year formatting"
    );
    runTest(
      [
        "Wed Jan 01 2010 00:00:00 GMT-0800 (Pacific Standard Time)",
        "Thu Dec 31 2009 00:00:00 GMT-0800 (Pacific Standard Time)",
        "Wed Jan 01 2010 00:00:00 GMT-0500 (Eastern Standard Time)",
      ],
      [
        "Thu Dec 31 2009 00:00:00 GMT-0800 (Pacific Standard Time)",
        "Wed Jan 01 2010 00:00:00 GMT-0500 (Eastern Standard Time)",
        "Wed Jan 01 2010 00:00:00 GMT-0800 (Pacific Standard Time)",
      ],
      "javascript toString(), different timezones"
    );
    runTest(
      [
        "Saturday, July 3, 2010",
        "Monday, August 2, 2010",
        "Monday, May 3, 2010",
      ],
      [
        "Monday, May 3, 2010",
        "Saturday, July 3, 2010",
        "Monday, August 2, 2010",
      ],
      "Date.toString(), Date.toLocaleString()"
    );
    runTest(
      [
        "Mon, 15 Jun 2009 20:45:30 GMT",
        "Mon, 3 May 2010 17:45:30 GMT",
        "Mon, 15 Jun 2009 17:45:30 GMT",
      ],
      [
        "Mon, 15 Jun 2009 17:45:30 GMT",
        "Mon, 15 Jun 2009 20:45:30 GMT",
        "Mon, 3 May 2010 17:45:30 GMT",
      ],
      "Date.toUTCString()"
    );
    runTest(
      [
        "Saturday, July 3, 2010 1:45 PM",
        "Saturday, July 3, 2010 1:45 AM",
        "Monday, August 2, 2010 1:45 PM",
        "Monday, May 3, 2010 1:45 PM",
      ],
      [
        "Monday, May 3, 2010 1:45 PM",
        "Saturday, July 3, 2010 1:45 AM",
        "Saturday, July 3, 2010 1:45 PM",
        "Monday, August 2, 2010 1:45 PM",
      ],
      ""
    );
    runTest(
      [
        "Saturday, July 3, 2010 1:45:30 PM",
        "Saturday, July 3, 2010 1:45:29 PM",
        "Monday, August 2, 2010 1:45:01 PM",
        "Monday, May 3, 2010 1:45:00 PM",
      ],
      [
        "Monday, May 3, 2010 1:45:00 PM",
        "Saturday, July 3, 2010 1:45:29 PM",
        "Saturday, July 3, 2010 1:45:30 PM",
        "Monday, August 2, 2010 1:45:01 PM",
      ],
      ""
    );
    runTest(
      ["2/15/2009 1:45 PM", "1/15/2009 1:45 PM", "2/15/2009 1:45 AM"],
      ["1/15/2009 1:45 PM", "2/15/2009 1:45 AM", "2/15/2009 1:45 PM"],
      ""
    );
    runTest(
      [
        "2010-06-15T13:45:30",
        "2009-06-15T13:45:30",
        "2009-06-15T01:45:30.2",
        "2009-01-15T01:45:30",
      ],
      [
        "2009-01-15T01:45:30",
        "2009-06-15T01:45:30.2",
        "2009-06-15T13:45:30",
        "2010-06-15T13:45:30",
      ],
      "ISO8601 Dates"
    );
    runTest(
      ["2010-06-15 13:45:30", "2009-06-15 13:45:30", "2009-01-15 01:45:30"],
      ["2009-01-15 01:45:30", "2009-06-15 13:45:30", "2010-06-15 13:45:30"],
      "ISO8601-ish YYYY-MM-DDThh:mm:ss - which does not parse into a Date instance"
    );
    runTest(
      [
        "Mon, 15 Jun 2009 20:45:30 GMT",
        "Mon, 15 Jun 2009 20:45:30 PDT",
        "Mon, 15 Jun 2009 20:45:30 EST",
      ],
      [
        "Mon, 15 Jun 2009 20:45:30 GMT",
        "Mon, 15 Jun 2009 20:45:30 EST",
        "Mon, 15 Jun 2009 20:45:30 PDT",
      ],
      "RFC1123 testing different timezones"
    );
    runTest(
      ["1245098730000", "14330728000", "1245098728000"],
      ["14330728000", "1245098728000", "1245098730000"],
      "unix epoch, Date.getTime()"
    );
    runTest(
      [
        new Date("2001-01-10"),
        "2015-01-01",
        new Date("2001-01-01"),
        "1998-01-01",
      ],
      [
        "1998-01-01",
        new Date("2001-01-01"),
        new Date("2001-01-10"),
        "2015-01-01",
      ],
      "mixed Date types"
    );
    runTest(
      [
        "Tue, 29 Jun 2021 11:31:17 GMT",
        "Sun, 14 Jun 2009 11:11:15 GMT",
        sessionString,
        "Mon, 15 Jun 2009 20:45:30 GMT",
      ],
      [
        sessionString,
        "Sun, 14 Jun 2009 11:11:15 GMT",
        "Mon, 15 Jun 2009 20:45:30 GMT",
        "Tue, 29 Jun 2021 11:31:17 GMT",
      ],
      `"${sessionString}" amongst date strings`
    );
    runTest(
      [
        "Wed, 04 Sep 2024 09:11:44 GMT",
        sessionString,
        "Tue, 06 Sep 2022 09:11:44 GMT",
        sessionString,
        "Mon, 05 Sep 2022 09:12:41 GMT",
      ],
      [
        sessionString,
        sessionString,
        "Mon, 05 Sep 2022 09:12:41 GMT",
        "Tue, 06 Sep 2022 09:11:44 GMT",
        "Wed, 04 Sep 2024 09:11:44 GMT",
      ],
      `"${sessionString}" amongst date strings (complex)`
    );

    runTest(
      [
        "Madras",
        "Jalfrezi",
        "Rogan Josh",
        "Vindaloo",
        "Tikka Masala",
        sessionString,
        "Masala",
        "Korma",
      ],
      [
        "Jalfrezi",
        "Korma",
        "Madras",
        "Masala",
        "Rogan Josh",
        sessionString,
        "Tikka Masala",
        "Vindaloo",
      ],
      `"${sessionString}" amongst strings`
    );
  });

  test("version number strings", function () {
    runTest(
      ["1.0.2", "1.0.1", "1.0.0", "1.0.9"],
      ["1.0.0", "1.0.1", "1.0.2", "1.0.9"],
      "close version numbers"
    );
    runTest(
      ["1.1.100", "1.1.1", "1.1.10", "1.1.54"],
      ["1.1.1", "1.1.10", "1.1.54", "1.1.100"],
      "more version numbers"
    );
    runTest(
      ["1.0.03", "1.0.003", "1.0.002", "1.0.0001"],
      ["1.0.0001", "1.0.002", "1.0.003", "1.0.03"],
      "multi-digit branch release"
    );
    runTest(
      [
        "1.1beta",
        "1.1.2alpha3",
        "1.0.2alpha3",
        "1.0.2alpha1",
        "1.0.1alpha4",
        "2.1.2",
        "2.1.1",
      ],
      [
        "1.0.1alpha4",
        "1.0.2alpha1",
        "1.0.2alpha3",
        "1.1.2alpha3",
        "1.1beta",
        "2.1.1",
        "2.1.2",
      ],
      "close version numbers"
    );
    runTest(
      [
        "myrelease-1.1.3",
        "myrelease-1.2.3",
        "myrelease-1.1.4",
        "myrelease-1.1.1",
        "myrelease-1.0.5",
      ],
      [
        "myrelease-1.0.5",
        "myrelease-1.1.1",
        "myrelease-1.1.3",
        "myrelease-1.1.4",
        "myrelease-1.2.3",
      ],
      "string first"
    );
    runTest(
      [
        "1.1.3",
        "a-release-1.1.3",
        "b-release-1.1.3",
        "1.2.3",
        "a-release-1.2.3",
        "b-release-1.2.3",
        "1.1.4",
        "a-release-1.1.4",
        "b-release-1.1.4",
        "1.1.1",
        "a-release-1.1.1",
        "b-release-1.1.1",
        "1.0.5",
        "a-release-1.0.5",
        "b-release-1.0.5",
      ],
      [
        "1.0.5",
        "1.1.1",
        "1.1.3",
        "1.1.4",
        "1.2.3",
        "a-release-1.0.5",
        "a-release-1.1.1",
        "a-release-1.1.3",
        "a-release-1.1.4",
        "a-release-1.2.3",
        "b-release-1.0.5",
        "b-release-1.1.1",
        "b-release-1.1.3",
        "b-release-1.1.4",
        "b-release-1.2.3",
      ],
      "string first, different names"
    );
    runTest(
      ["zstring", "astring", "release-1.1.3"],
      ["astring", "release-1.1.3", "zstring"],
      "string first, mixed with regular strings"
    );
  });

  test("numerics", function () {
    runTest(["10", 9, 2, "1", "4"], ["1", 2, "4", 9, "10"], "string vs number");
    runTest(
      ["0001", "002", "001"],
      ["0001", "001", "002"],
      "0 left-padded numbers"
    );
    runTest(
      [2, 1, "1", "0001", "002", "02", "001"],
      [1, "1", "0001", "001", 2, "002", "02"],
      "0 left-padded numbers and regular numbers"
    );
    runTest(
      ["10.0401", 10.022, 10.042, "10.021999"],
      ["10.021999", 10.022, "10.0401", 10.042],
      "decimal string vs decimal, different precision"
    );
    runTest(
      ["10.04", 10.02, 10.03, "10.01"],
      ["10.01", 10.02, 10.03, "10.04"],
      "decimal string vs decimal, same precision"
    );
    runTest(
      ["10.04f", "10.039F", "10.038d", "10.037D"],
      ["10.037D", "10.038d", "10.039F", "10.04f"],
      "float/decimal with 'F' or 'D' notation"
    );
    runTest(
      ["10.004Z", "10.039T", "10.038ooo", "10.037g"],
      ["10.004Z", "10.037g", "10.038ooo", "10.039T"],
      "not foat/decimal notation"
    );
    runTest(
      ["1.528535047e5", "1.528535047e7", "1.52e15", "1.528535047e3", "1.59e-3"],
      ["1.59e-3", "1.528535047e3", "1.528535047e5", "1.528535047e7", "1.52e15"],
      "scientific notation"
    );
    runTest(
      ["-1", "-2", "4", "-3", "0", "-5"],
      ["-5", "-3", "-2", "-1", "0", "4"],
      "negative numbers as strings"
    );
    runTest(
      [-1, "-2", 4, -3, "0", "-5"],
      ["-5", -3, "-2", -1, "0", 4],
      "negative numbers as strings - mixed input type, string + numeric"
    );
    runTest(
      [-2.01, -2.1, 4.144, 4.1, -2.001, -5],
      [-5, -2.1, -2.01, -2.001, 4.1, 4.144],
      "negative floats - all numeric"
    );
  });

  test("IP addresses", function () {
    runTest(
      [
        "192.168.0.100",
        "192.168.0.1",
        "192.168.1.1",
        "192.168.0.250",
        "192.168.1.123",
        "10.0.0.2",
        "10.0.0.1",
      ],
      [
        "10.0.0.1",
        "10.0.0.2",
        "192.168.0.1",
        "192.168.0.100",
        "192.168.0.250",
        "192.168.1.1",
        "192.168.1.123",
      ]
    );
  });

  test("filenames", function () {
    runTest(
      ["img12.png", "img10.png", "img2.png", "img1.png"],
      ["img1.png", "img2.png", "img10.png", "img12.png"],
      "simple image filenames"
    );
    runTest(
      [
        "car.mov",
        "01alpha.sgi",
        "001alpha.sgi",
        "my.string_41299.tif",
        "organic2.0001.sgi",
      ],
      [
        "001alpha.sgi",
        "01alpha.sgi",
        "car.mov",
        "my.string_41299.tif",
        "organic2.0001.sgi",
      ],
      "complex filenames"
    );
    runTest(
      [
        "./system/kernel/js/01_ui.core.js",
        "./system/kernel/js/00_jquery-1.3.2.js",
        "./system/kernel/js/02_my.desktop.js",
      ],
      [
        "./system/kernel/js/00_jquery-1.3.2.js",
        "./system/kernel/js/01_ui.core.js",
        "./system/kernel/js/02_my.desktop.js",
      ],
      "unix filenames"
    );
  });

  test("space(s) as first character(s)", function () {
    runTest(["alpha", " 1", " 3", " 2", 0], [0, " 1", " 2", " 3", "alpha"]);
  });

  test("empty strings and space character", function () {
    runTest(
      ["10023", "999", "", 2, 5.663, 5.6629],
      ["", 2, 5.6629, 5.663, "999", "10023"]
    );
    runTest([0, "0", ""], [0, "0", ""]);
  });

  test("hex", function () {
    runTest(["0xA", "0x9", "0x99"], ["0x9", "0xA", "0x99"], "real hex numbers");
    runTest(
      ["0xZZ", "0xVVV", "0xVEV", "0xUU"],
      ["0xUU", "0xVEV", "0xVVV", "0xZZ"],
      "fake hex numbers"
    );
  });

  test("unicode", function () {
    runTest(
      ["\u0044", "\u0055", "\u0054", "\u0043"],
      ["\u0043", "\u0044", "\u0054", "\u0055"],
      "basic latin"
    );
  });

  test("sparse array sort", function () {
    const sarray = [3, 2];
    const sarrayOutput = [1, 2, 3];

    sarray[10] = 1;
    for (let i = 0; i < 8; i++) {
      sarrayOutput.push(undefined);
    }
    runTest(sarray, sarrayOutput, "simple sparse array");
  });

  test("case insensitive support", function () {
    runTest(
      ["A", "b", "C", "d", "E", "f"],
      ["A", "b", "C", "d", "E", "f"],
      "case sensitive pre-sorted array",
      true
    );
    runTest(
      ["A", "C", "E", "b", "d", "f"],
      ["A", "b", "C", "d", "E", "f"],
      "case sensitive un-sorted array",
      true
    );
    runTest(
      ["A", "C", "E", "b", "d", "f"],
      ["A", "C", "E", "b", "d", "f"],
      "case sensitive pre-sorted array"
    );
    runTest(
      ["A", "b", "C", "d", "E", "f"],
      ["A", "C", "E", "b", "d", "f"],
      "case sensitive un-sorted array"
    );
  });

  test("rosetta code natural sort small test set", function () {
    runTest(
      [
        "ignore leading spaces: 2-2",
        " ignore leading spaces: 2-1",
        " ignore leading spaces: 2+0",
        " ignore leading spaces: 2+1",
      ],
      [
        " ignore leading spaces: 2+0",
        " ignore leading spaces: 2+1",
        " ignore leading spaces: 2-1",
        "ignore leading spaces: 2-2",
      ],
      "Ignoring leading spaces"
    );
    runTest(
      [
        "ignore m.a.s spaces: 2-2",
        "ignore m.a.s spaces: 2-1",
        "ignore m.a.s spaces: 2+0",
        "ignore m.a.s spaces: 2+1",
      ],
      [
        "ignore m.a.s spaces: 2+0",
        "ignore m.a.s spaces: 2+1",
        "ignore m.a.s spaces: 2-1",
        "ignore m.a.s spaces: 2-2",
      ],
      "Ignoring multiple adjacent spaces (m.a.s)"
    );
    runTest(
      [
        "Equiv. spaces: 3-3",
        "Equiv.\rspaces: 3-2",
        "Equiv.\x0cspaces: 3-1",
        "Equiv.\x0bspaces: 3+0",
        "Equiv.\nspaces: 3+1",
        "Equiv.\tspaces: 3+2",
      ],
      [
        "Equiv.\x0bspaces: 3+0",
        "Equiv.\nspaces: 3+1",
        "Equiv.\tspaces: 3+2",
        "Equiv.\x0cspaces: 3-1",
        "Equiv.\rspaces: 3-2",
        "Equiv. spaces: 3-3",
      ],
      "Equivalent whitespace characters"
    );
    runTest(
      [
        "cASE INDEPENENT: 3-2",
        "caSE INDEPENENT: 3-1",
        "casE INDEPENENT: 3+0",
        "case INDEPENENT: 3+1",
      ],
      [
        "casE INDEPENENT: 3+0",
        "case INDEPENENT: 3+1",
        "caSE INDEPENENT: 3-1",
        "cASE INDEPENENT: 3-2",
      ],
      "Case Indepenent sort (naturalSort.insensitive = true)",
      true
    );
    runTest(
      [
        "foo100bar99baz0.txt",
        "foo100bar10baz0.txt",
        "foo1000bar99baz10.txt",
        "foo1000bar99baz9.txt",
      ],
      [
        "foo100bar10baz0.txt",
        "foo100bar99baz0.txt",
        "foo1000bar99baz9.txt",
        "foo1000bar99baz10.txt",
      ],
      "Numeric fields as numerics"
    );
    runTest(
      [
        "The Wind in the Willows",
        "The 40th step more",
        "The 39 steps",
        "Wanda",
      ],
      [
        "The 39 steps",
        "The 40th step more",
        "The Wind in the Willows",
        "Wanda",
      ],
      "Title sorts"
    );
    runTest(
      [
        "Equiv. \xfd accents: 2-2",
        "Equiv. \xdd accents: 2-1",
        "Equiv. y accents: 2+0",
        "Equiv. Y accents: 2+1",
      ],
      [
        "Equiv. y accents: 2+0",
        "Equiv. Y accents: 2+1",
        "Equiv. \xfd accents: 2-2",
        "Equiv. \xdd accents: 2-1",
      ],
      "Equivalent accented characters (and case) (naturalSort.insensitive = true)",
      true
    );
    // This is not a valuable unicode ordering test
    // runTest(
    //   ['Start with an \u0292: 2-2', 'Start with an \u017f: 2-1', 'Start with an \xdf: 2+0', 'Start with an s: 2+1'],
    //   ['Start with an s: 2+1', 'Start with an \xdf: 2+0', 'Start with an \u017f: 2-1', 'Start with an \u0292: 2-2'],
    //   'Character replacements');
  });

  test("contributed tests", function () {
    runTest(
      [
        "T78",
        "U17",
        "U10",
        "U12",
        "U14",
        "745",
        "U7",
        "485",
        "S16",
        "S2",
        "S22",
        "1081",
        "S25",
        "1055",
        "779",
        "776",
        "771",
        "44",
        "4",
        "87",
        "1091",
        "42",
        "480",
        "952",
        "951",
        "756",
        "1000",
        "824",
        "770",
        "666",
        "633",
        "619",
        "1",
        "991",
        "77H",
        "PIER-7",
        "47",
        "29",
        "9",
        "77L",
        "433",
      ],
      [
        "1",
        "4",
        "9",
        "29",
        "42",
        "44",
        "47",
        "77H",
        "77L",
        "87",
        "433",
        "480",
        "485",
        "619",
        "633",
        "666",
        "745",
        "756",
        "770",
        "771",
        "776",
        "779",
        "824",
        "951",
        "952",
        "991",
        "1000",
        "1055",
        "1081",
        "1091",
        "PIER-7",
        "S2",
        "S16",
        "S22",
        "S25",
        "T78",
        "U7",
        "U10",
        "U12",
        "U14",
        "U17",
      ],
      "contributed by Bob Zeiner (Chrome not stable sort)"
    );
    runTest(
      [
        "FSI stop, Position: 5",
        "Mail Group stop, Position: 5",
        "Mail Group stop, Position: 5",
        "FSI stop, Position: 6",
        "FSI stop, Position: 6",
        "Newsstand stop, Position: 4",
        "Newsstand stop, Position: 4",
        "FSI stop, Position: 5",
      ],
      [
        "FSI stop, Position: 5",
        "FSI stop, Position: 5",
        "FSI stop, Position: 6",
        "FSI stop, Position: 6",
        "Mail Group stop, Position: 5",
        "Mail Group stop, Position: 5",
        "Newsstand stop, Position: 4",
        "Newsstand stop, Position: 4",
      ],
      "contributed by Scott"
    );
    runTest(
      [2, 10, 1, "azd", undefined, "asd"],
      [1, 2, 10, "asd", "azd", undefined],
      "issue #2 - undefined support - jarvinen pekka"
    );
    runTest(
      [undefined, undefined, undefined, 1, undefined],
      [1, undefined, undefined, undefined],
      "issue #2 - undefined support - jarvinen pekka"
    );
    runTest(
      ["-1", "-2", "4", "-3", "0", "-5"],
      ["-5", "-3", "-2", "-1", "0", "4"],
      "issue #3 - invalid numeric string sorting - guilermo.dev"
    );
    // native sort implementations are not guaranteed to be stable (i.e. Chrome)
    // runTest(
    //  ['9','11','22','99','A','aaaa','bbbb','Aaaa','aAaa','aa','AA','Aa','aA','BB','bB','aaA','AaA','aaa'],
    //  ['9', '11', '22', '99', 'A', 'aa', 'AA', 'Aa', 'aA', 'aaA', 'AaA', 'aaa', 'aaaa', 'Aaaa', 'aAaa', 'BB', 'bB', 'bbbb'],
    //  'issue #5 - invalid sort order - Howie Schecter (naturalSort.insensitive = true)'m true);
    runTest(
      [
        "9",
        "11",
        "22",
        "99",
        "A",
        "aaaa",
        "bbbb",
        "Aaaa",
        "aAaa",
        "aa",
        "AA",
        "Aa",
        "aA",
        "BB",
        "bB",
        "aaA",
        "AaA",
        "aaa",
      ],
      [
        "9",
        "11",
        "22",
        "99",
        "A",
        "AA",
        "Aa",
        "AaA",
        "Aaaa",
        "BB",
        "aA",
        "aAaa",
        "aa",
        "aaA",
        "aaa",
        "aaaa",
        "bB",
        "bbbb",
      ],
      "issue #5 - invalid sort order - Howie Schecter (naturalSort.insensitive = false)"
    );
    runTest(
      [
        "5D",
        "1A",
        "2D",
        "33A",
        "5E",
        "33K",
        "33D",
        "5S",
        "2C",
        "5C",
        "5F",
        "1D",
        "2M",
      ],
      [
        "1A",
        "1D",
        "2C",
        "2D",
        "2M",
        "5C",
        "5D",
        "5E",
        "5F",
        "5S",
        "33A",
        "33D",
        "33K",
      ],
      "alphanumeric - number first"
    );
    runTest(
      ["img 99", "img199", "imga99", "imgz99"],
      ["img 99", "img199", "imga99", "imgz99"],
      "issue #16 - Sorting incorrect when there is a space - adrien-be"
    );
    runTest(
      ["img199", "img 99", "imga99", "imgz 99", "imgb99", "imgz199"],
      ["img 99", "img199", "imga99", "imgb99", "imgz 99", "imgz199"],
      "issue #16 - expanded test"
    );
    runTest(
      ["1", "02", "3"],
      ["1", "02", "3"],
      "issue #18 - Any zeros that precede a number messes up the sorting - menixator"
    );
    // strings are coerced as floats/ints if possible and sorted accordingly - e.g. they are not chunked
    runTest(
      ["1.100", "1.1", "1.10", "1.54"],
      ["1.100", "1.1", "1.10", "1.54"],
      "issue #13 - ['1.100', '1.10', '1.1', '1.54'] etc do not sort properly... - rubenstolk"
    );
    runTest(
      ["v1.100", "v1.1", "v1.10", "v1.54"],
      ["v1.1", "v1.10", "v1.54", "v1.100"],
      "issue #13 - ['v1.100', 'v1.10', 'v1.1', 'v1.54'] etc do not sort properly... - rubenstolk (bypass float coercion)"
    );
    runTest(
      [
        "MySnmp 1234567891234567891234567891234567891234567891234567891234567891234567891234567891234567891234567891234567891234567891234567891234567",
        "MySnmp 4234567891234567891234567891234567891234567891234567891234567891234567891234567891234567891234567891234567891234567891234567891234567",
        "MySnmp 2234567891234567891234567891234567891234567891234567891234567891234567891234567891234567891234567891234567891234567891234567891234567",
        "MySnmp 3234567891234567891234567891234567891234567891234567891234567891234567891234567891234567891234567891234567891234567891234567891234567",
      ],
      [
        "MySnmp 1234567891234567891234567891234567891234567891234567891234567891234567891234567891234567891234567891234567891234567891234567891234567",
        "MySnmp 2234567891234567891234567891234567891234567891234567891234567891234567891234567891234567891234567891234567891234567891234567891234567",
        "MySnmp 3234567891234567891234567891234567891234567891234567891234567891234567891234567891234567891234567891234567891234567891234567891234567",
        "MySnmp 4234567891234567891234567891234567891234567891234567891234567891234567891234567891234567891234567891234567891234567891234567891234567",
      ],
      "issue #14 - Very large numbers make sorting very slow - Mottie"
    );
    runTest(
      ["bar.1-2", "bar.1"],
      ["bar.1", "bar.1-2"],
      "issue #21 - javascript error"
    );
    runTest(
      ["SomeString", "SomeString 1"],
      ["SomeString", "SomeString 1"],
      "PR #19 - ['SomeString', 'SomeString 1'] bombing on 'undefined is not an object' - dannycochran"
    );
    runTest(
      [
        "Udet",
        "\xDCbelacker",
        "Uell",
        "\xDClle",
        "Ueve",
        "\xDCxk\xFCll",
        "Uffenbach",
      ],
      [
        "\xDCbelacker",
        "Udet",
        "Uell",
        "Ueve",
        "Uffenbach",
        "\xDClle",
        "\xDCxk\xFCll",
      ],
      "issue #9 - Sorting umlauts characters \xC4, \xD6, \xDC - diogoalves"
    );
    runTest(
      ["2.2 sec", "1.9 sec", "1.53 sec"],
      ["1.53 sec", "1.9 sec", "2.2 sec"],
      "https://github.com/overset/javascript-natural-sort/issues/13 - ['2.2 sec','1.9 sec','1.53 sec'] - padded by spaces - harisb"
    );
    runTest(
      ["2.2sec", "1.9sec", "1.53sec"],
      ["1.53sec", "1.9sec", "2.2sec"],
      "https://github.com/overset/javascript-natural-sort/issues/13 - ['2.2sec','1.9sec','1.53sec'] - no padding - harisb"
    );
  });
}

function test(description, testFunc) {
  info(description);
  testFunc();
}

function runTest(testArray, expected, description, caseInsensitive = false) {
  let actual = null;

  if (caseInsensitive) {
    actual = testArray.sort((a, b) =>
      naturalSortCaseInsensitive(a, b, sessionString)
    );
  } else {
    actual = testArray.sort((a, b) =>
      naturalSortCaseSensitive(a, b, sessionString)
    );
  }

  compareOptions(actual, expected, description);
}

// deepEqual() doesn't work well for testing arrays containing `undefined` so
// we need to use a custom method.
function compareOptions(actual, expected, description) {
  let match = true;
  for (let i = 0; i < actual.length; i++) {
    if (actual[i] + "" !== expected[i] + "") {
      ok(
        false,
        `${description}\nElement ${i} does not match:\n[${i}] ${actual[i]}\n[${i}] ${expected[i]}`
      );
      match = false;
      break;
    }
  }
  if (match) {
    ok(true, description);
  }
}

quality97%

¤ Dauer der Verarbeitung: 0.30 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.