Quelle  test_URIFixup_info.js   Sprache: JAVA

const { AppConstants } = ChromeUtils.importESModule(
  "resource://gre/modules/AppConstants.sys.mjs"
);

const kForceDNSLookup = "browser.fixup.dns_first_for_single_words";

// TODO(bug 1522134), this test should also use
// combinations of the following flags.
var flagInputs = [
  Services.uriFixup.FIXUP_FLAG_ALLOW_KEYWORD_LOOKUP,
  Services.uriFixup.FIXUP_FLAG_ALLOW_KEYWORD_LOOKUP |
    Services.uriFixup.FIXUP_FLAG_PRIVATE_CONTEXT,
  Services.uriFixup.FIXUP_FLAGS_MAKE_ALTERNATE_URI,
  Services.uriFixup.FIXUP_FLAG_FIX_SCHEME_TYPOS,
  // This should not really generate a search, but it does, see Bug 1588118.
  Services.uriFixup.FIXUP_FLAG_FIX_SCHEME_TYPOS |
    Services.uriFixup.FIXUP_FLAG_PRIVATE_CONTEXT,
];

function schemeTypoOnly(flags) {
  return flags & Services.uriFixup.FIXUP_FLAG_FIX_SCHEME_TYPOS;
}

/*
  The following properties are supported for these test cases:
  {
    input: "", // Input string, required
    fixedURI: "", // Expected fixedURI
    alternateURI: "", // Expected alternateURI
    keywordLookup: false, // Whether a keyword lookup is expected
    protocolChange: false, // Whether a protocol change is expected
    inWhitelist: false, // Whether the input host is in the whitelist
    affectedByDNSForSingleWordHosts: false, // Whether the input host could be a host, but is normally assumed to be a keyword query
  }
*/
var testcases = [
  {
    input: "about:home",
    fixedURI: "about:home",
  },
  {
    input: "http://www.mozilla.org",
    fixedURI: "http://www.mozilla.org/",
  },
  {
    input: "http://127.0.0.1/",
    fixedURI: "http://127.0.0.1/",
  },
  {
    input: "file:///foo/bar",
    fixedURI: "file:///foo/bar",
  },
  {
    input: "://www.mozilla.org",
    fixedURI: "http://www.mozilla.org/",
    protocolChange: true,
  },
  {
    input: "www.mozilla.org",
    fixedURI: "http://www.mozilla.org/",
    protocolChange: true,
  },
  {
    input: "http://mozilla/",
    fixedURI: "http://mozilla/",
    alternateURI: "https://www.mozilla.com/",
  },
  {
    input: "http://test./",
    fixedURI: "http://test./",
    alternateURI: "https://www.test./",
  },
  {
    input: "127.0.0.1",
    fixedURI: "http://127.0.0.1/",
    protocolChange: true,
  },
  {
    input: "1.2.3.4/",
    fixedURI: "http://1.2.3.4/",
    protocolChange: true,
  },
  {
    input: "1.2.3.4/foo",
    fixedURI: "http://1.2.3.4/foo",
    protocolChange: true,
  },
  {
    input: "1.2.3.4:8000",
    fixedURI: "http://1.2.3.4:8000/",
    protocolChange: true,
  },
  {
    input: "1.2.3.4:8000/",
    fixedURI: "http://1.2.3.4:8000/",
    protocolChange: true,
  },
  {
    input: "1.2.3.4:8000/foo",
    fixedURI: "http://1.2.3.4:8000/foo",
    protocolChange: true,
  },
  {
    input: "192.168.10.110",
    fixedURI: "http://192.168.10.110/",
    protocolChange: true,
  },
  {
    input: "192.168.10.110/123",
    fixedURI: "http://192.168.10.110/123",
    protocolChange: true,
  },
  {
    input: "192.168.10.110/123foo",
    fixedURI: "http://192.168.10.110/123foo",
    protocolChange: true,
  },
  {
    input: "192.168.10.110:1234/123",
    fixedURI: "http://192.168.10.110:1234/123",
    protocolChange: true,
  },
  {
    input: "192.168.10.110:1234/123foo",
    fixedURI: "http://192.168.10.110:1234/123foo",
    protocolChange: true,
  },
  {
    input: "1.2.3",
    fixedURI: "http://1.2.0.3/",
    protocolChange: true,
  },
  {
    input: "1.2.3/",
    fixedURI: "http://1.2.0.3/",
    protocolChange: true,
  },
  {
    input: "1.2.3/foo",
    fixedURI: "http://1.2.0.3/foo",
    protocolChange: true,
  },
  {
    input: "1.2.3/123",
    fixedURI: "http://1.2.0.3/123",
    protocolChange: true,
  },
  {
    input: "1.2.3:8000",
    fixedURI: "http://1.2.0.3:8000/",
    protocolChange: true,
  },
  {
    input: "1.2.3:8000/",
    fixedURI: "http://1.2.0.3:8000/",
    protocolChange: true,
  },
  {
    input: "1.2.3:8000/foo",
    fixedURI: "http://1.2.0.3:8000/foo",
    protocolChange: true,
  },
  {
    input: "1.2.3:8000/123",
    fixedURI: "http://1.2.0.3:8000/123",
    protocolChange: true,
  },
  {
    input: "http://1.2.3",
    fixedURI: "http://1.2.0.3/",
  },
  {
    input: "http://1.2.3/",
    fixedURI: "http://1.2.0.3/",
  },
  {
    input: "http://1.2.3/foo",
    fixedURI: "http://1.2.0.3/foo",
  },
  {
    input: "[::1]",
    fixedURI: "http://[::1]/",
    protocolChange: true,
  },
  {
    input: "[::1]/",
    fixedURI: "http://[::1]/",
    protocolChange: true,
  },
  {
    input: "[::1]:8000",
    fixedURI: "http://[::1]:8000/",
    protocolChange: true,
  },
  {
    input: "[::1]:8000/",
    fixedURI: "http://[::1]:8000/",
    protocolChange: true,
  },
  {
    input: "[[::1]]/",
    keywordLookup: true,
  },
  {
    input: "[fe80:cd00:0:cde:1257:0:211e:729c]",
    fixedURI: "http://[fe80:cd00:0:cde:1257:0:211e:729c]/",
    protocolChange: true,
  },
  {
    input: "[64:ff9b::8.8.8.8]",
    fixedURI: "http://[64:ff9b::808:808]/",
    protocolChange: true,
  },
  {
    input: "[64:ff9b::8.8.8.8]/~moz",
    fixedURI: "http://[64:ff9b::808:808]/~moz",
    protocolChange: true,
  },
  {
    input: "[::1][::1]",
    keywordLookup: true,
  },
  {
    input: "[::1][100",
    keywordLookup: true,
  },
  {
    input: "[::1]]",
    keywordLookup: true,
  },
  {
    input: "1234",
    fixedURI: "http://0.0.4.210/",
    keywordLookup: true,
    protocolChange: true,
    affectedByDNSForSingleWordHosts: true,
  },
  {
    input: "whitelisted/foo.txt",
    fixedURI: "http://whitelisted/foo.txt",
    alternateURI: "https://www.whitelisted.com/foo.txt",
    protocolChange: true,
  },
  {
    input: "mozilla",
    fixedURI: "http://mozilla/",
    alternateURI: "https://www.mozilla.com/",
    keywordLookup: true,
    protocolChange: true,
    affectedByDNSForSingleWordHosts: true,
  },
  {
    input: "test.",
    fixedURI: "http://test./",
    alternateURI: "https://www.test./",
    keywordLookup: true,
    protocolChange: true,
    affectedByDNSForSingleWordHosts: true,
  },
  {
    input: ".test",
    fixedURI: "http://.test/",
    alternateURI: "https://www.test/",
    keywordLookup: true,
    protocolChange: true,
    affectedByDNSForSingleWordHosts: true,
  },
  {
    input: "mozilla is amazing",
    keywordLookup: true,
  },
  {
    input: "search ?mozilla",
    keywordLookup: true,
  },
  {
    input: "mozilla .com",
    keywordLookup: true,
  },
  {
    input: "what if firefox?",
    keywordLookup: true,
  },
  {
    input: "london's map",
    keywordLookup: true,
  },
  {
    input: "mozilla ",
    fixedURI: "http://mozilla/",
    alternateURI: "https://www.mozilla.com/",
    keywordLookup: true,
    protocolChange: true,
    affectedByDNSForSingleWordHosts: true,
  },
  {
    input: " mozilla ",
    fixedURI: "http://mozilla/",
    alternateURI: "https://www.mozilla.com/",
    keywordLookup: true,
    protocolChange: true,
    affectedByDNSForSingleWordHosts: true,
  },
  {
    input: "mozilla \\",
    keywordLookup: true,
  },
  {
    input: "mozilla \\ foo.txt",
    keywordLookup: true,
  },
  {
    input: "mozilla \\\r foo.txt",
    keywordLookup: true,
  },
  {
    input: "mozilla\n",
    fixedURI: "http://mozilla/",
    alternateURI: "https://www.mozilla.com/",
    keywordLookup: true,
    protocolChange: true,
    affectedByDNSForSingleWordHosts: true,
  },
  {
    input: "mozilla \r\n",
    fixedURI: "http://mozilla/",
    alternateURI: "https://www.mozilla.com/",
    keywordLookup: true,
    protocolChange: true,
    affectedByDNSForSingleWordHosts: true,
  },
  {
    input: "moz\r\nfirefox\nos\r",
    fixedURI: "http://mozfirefoxos/",
    alternateURI: "https://www.mozfirefoxos.com/",
    keywordLookup: true,
    protocolChange: true,
    affectedByDNSForSingleWordHosts: true,
  },
  {
    input: "moz\r\n firefox\n",
    keywordLookup: true,
  },
  {
    input: "",
    keywordLookup: true,
  },
  {
    input: "[]",
    keywordLookup: true,
  },
  {
    input: "http://whitelisted/",
    fixedURI: "http://whitelisted/",
    alternateURI: "https://www.whitelisted.com/",
    inWhitelist: true,
  },
  {
    input: "whitelisted",
    fixedURI: "http://whitelisted/",
    alternateURI: "https://www.whitelisted.com/",
    protocolChange: true,
    inWhitelist: true,
  },
  {
    input: "whitelisted.",
    fixedURI: "http://whitelisted./",
    alternateURI: "https://www.whitelisted./",
    protocolChange: true,
    inWhitelist: true,
  },
  {
    input: "mochi.test",
    fixedURI: "http://mochi.test/",
    alternateURI: "https://www.mochi.test/",
    protocolChange: true,
    inWhitelist: true,
  },
  // local.domain is a whitelisted suffix...
  {
    input: "some.local.domain",
    fixedURI: "http://some.local.domain/",
    protocolChange: true,
    inWhitelist: true,
  },
  // ...but .domain is not.
  {
    input: "some.domain",
    fixedURI: "http://some.domain/",
    alternateURI: "https://www.some.domain/",
    keywordLookup: true,
    protocolChange: true,
    affectedByDNSForSingleWordHosts: true,
  },
  {
    input: "café.com",
    fixedURI: "http://xn--caf-dma.com/",
    alternateURI: "https://www.xn--caf-dma.com/",
    protocolChange: true,
  },
  {
    input: "mozilla.nonexistent",
    fixedURI: "http://mozilla.nonexistent/",
    alternateURI: "https://www.mozilla.nonexistent/",
    keywordLookup: true,
    protocolChange: true,
    affectedByDNSForSingleWordHosts: true,
  },
  {
    input: "mochi.ocm",
    fixedURI: "http://mochi.com/",
    alternateURI: "https://www.mochi.com/",
    protocolChange: true,
  },
  {
    input: "47.6182,-122.830",
    keywordLookup: true,
  },
  {
    input: "-47.6182,-23.51",
    keywordLookup: true,
  },
  {
    input: "-22.14,23.51-",
    fixedURI: "http://-22.14,23.51-/",
    keywordLookup: true,
    protocolChange: true,
    affectedByDNSForSingleWordHosts: true,
  },
  {
    input: "32.7",
    fixedURI: "http://32.0.0.7/",
    keywordLookup: true,
    protocolChange: true,
    affectedByDNSForSingleWordHosts: true,
  },
  {
    input: "5+2",
    fixedURI: "http://5+2/",
    alternateURI: "https://www.5+2.com/",
    keywordLookup: true,
    protocolChange: true,
    affectedByDNSForSingleWordHosts: true,
  },
  {
    input: "5/2",
    fixedURI: "http://0.0.0.5/2",
    keywordLookup: true,
    protocolChange: true,
    affectedByDNSForSingleWordHosts: true,
  },
  {
    input: "moz ?.::%27",
    keywordLookup: true,
  },
  {
    input: "mozilla.com/?q=search",
    fixedURI: "http://mozilla.com/?q=search",
    alternateURI: "https://www.mozilla.com/?q=search",
    protocolChange: true,
  },
  {
    input: "mozilla.com?q=search",
    fixedURI: "http://mozilla.com/?q=search",
    alternateURI: "https://www.mozilla.com/?q=search",
    protocolChange: true,
  },
  {
    input: "mozilla.com ?q=search",
    keywordLookup: true,
  },
  {
    input: "mozilla.com.?q=search",
    fixedURI: "http://mozilla.com./?q=search",
    protocolChange: true,
  },
  {
    input: "mozilla.com'?q=search",
    fixedURI: "http://mozilla.com/?q=search",
    alternateURI: "https://www.mozilla.com/?q=search",
    protocolChange: true,
  },
  {
    input: "mozilla.com':search",
    keywordLookup: true,
  },
  {
    input: "[mozilla]",
    keywordLookup: true,
  },
  {
    input: "':?",
    fixedURI: "http://'/?",
    alternateURI: "https://www.'.com/?",
    keywordLookup: true,
    protocolChange: true,
    affectedByDNSForSingleWordHosts: true,
  },
  {
    input: "whitelisted?.com",
    fixedURI: "http://whitelisted/?.com",
    alternateURI: "https://www.whitelisted.com/?.com",
    protocolChange: true,
  },
  {
    input: "?'.com",
    keywordLookup: true,
  },
  {
    input: ".com",
    keywordLookup: true,
    affectedByDNSForSingleWordHosts: true,
    fixedURI: "http://.com/",
    alternateURI: "https://www.com/",
    protocolChange: true,
  },
  {
    input: "' ?.com",
    keywordLookup: true,
  },
  {
    input: "?mozilla",
    keywordLookup: true,
  },
  {
    input: "??mozilla",
    keywordLookup: true,
  },
  {
    input: "mozilla/",
    fixedURI: "http://mozilla/",
    alternateURI: "https://www.mozilla.com/",
    protocolChange: true,
  },
  {
    input: "mozilla",
    fixedURI: "http://mozilla/",
    alternateURI: "https://www.mozilla.com/",
    protocolChange: true,
    keywordLookup: true,
    affectedByDNSForSingleWordHosts: true,
  },
  {
    input: "mozilla5/2",
    fixedURI: "http://mozilla5/2",
    alternateURI: "https://www.mozilla5.com/2",
    protocolChange: true,
    keywordLookup: true,
    affectedByDNSForSingleWordHosts: true,
  },
  {
    input: "mozilla/foo",
    fixedURI: "http://mozilla/foo",
    alternateURI: "https://www.mozilla.com/foo",
    protocolChange: true,
    keywordLookup: true,
    affectedByDNSForSingleWordHosts: true,
  },
  {
    input: "mozilla\\",
    fixedURI: "http://mozilla/",
    alternateURI: "https://www.mozilla.com/",
    keywordLookup: true,
    protocolChange: true,
    affectedByDNSForSingleWordHosts: true,
  },
  {
    input: "localhost",
    fixedURI: "http://localhost/",
    keywordLookup: true,
    protocolChange: true,
    affectedByDNSForSingleWordHosts: true,
  },
  {
    input: "http",
    fixedURI: "http://http/",
    keywordLookup: true,
    protocolChange: true,
    affectedByDNSForSingleWordHosts: true,
  },
  {
    input: "https",
    fixedURI: "http://https/",
    keywordLookup: true,
    protocolChange: true,
    affectedByDNSForSingleWordHosts: true,
  },
  {
    input: "localhost:8080",
    fixedURI: "http://localhost:8080/",
    protocolChange: true,
  },
  {
    input: "plonk:8080",
    fixedURI: "http://plonk:8080/",
    protocolChange: true,
  },
  {
    input: "plonk:8080?test",
    fixedURI: "http://plonk:8080/?test",
    protocolChange: true,
  },
  {
    input: "plonk:8080#test",
    fixedURI: "http://plonk:8080/#test",
    protocolChange: true,
  },
  {
    input: "plonk/ #",
    fixedURI: "http://plonk/%20#",
    alternateURI: "https://www.plonk.com/%20#",
    protocolChange: true,
    keywordLookup: false,
  },
  {
    input: "blah.com.",
    fixedURI: "http://blah.com./",
    protocolChange: true,
  },
  {
    input:
      "\u10E0\u10D4\u10D2\u10D8\u10E1\u10E2\u10E0\u10D0\u10EA\u10D8\u10D0.\u10D2\u10D4",
    fixedURI: "http://xn--lodaehvb5cdik4g.xn--node/",
    alternateURI: "https://www.xn--lodaehvb5cdik4g.xn--node/",
    protocolChange: true,
  },
  {
    input: " \t mozilla.org/\t \t ",
    fixedURI: "http://mozilla.org/",
    alternateURI: "https://www.mozilla.org/",
    protocolChange: true,
  },
  {
    input: " moz\ti\tlla.org ",
    keywordLookup: true,
  },
  {
    input: "mozilla/",
    fixedURI: "http://mozilla/",
    alternateURI: "https://www.mozilla.com/",
    protocolChange: true,
  },
  {
    input: "mozilla/ test /",
    fixedURI: "http://mozilla/%20test%20/",
    alternateURI: "https://www.mozilla.com/%20test%20/",
    protocolChange: true,
  },
  {
    input: "mozilla /test/",
    keywordLookup: true,
  },
  {
    input: "pserver:8080",
    fixedURI: "http://pserver:8080/",
    protocolChange: true,
  },
  {
    input: "http;mozilla",
    fixedURI: "http://http;mozilla/",
    alternateURI: "https://www.http;mozilla.com/",
    keywordLookup: true,
    protocolChange: true,
    affectedByDNSForSingleWordHosts: true,
  },
  {
    input: "http//mozilla.org",
    fixedURI: "http://mozilla.org/",
    shouldRunTest: flags =>
      flags & Services.uriFixup.FIXUP_FLAG_FIX_SCHEME_TYPOS,
  },
  {
    input: "http//mozilla.org",
    fixedURI: "http://http//mozilla.org",
    keywordLookup: true,
    protocolChange: true,
    affectedByDNSForSingleWordHosts: true,
    shouldRunTest: flags =>
      !(flags & Services.uriFixup.FIXUP_FLAG_FIX_SCHEME_TYPOS),
  },
  {
    input: "www.mozilla",
    fixedURI: "http://www.mozilla/",
    protocolChange: true,
  },
  {
    input: "https://sub.www..mozilla...org/",
    fixedURI: "https://sub.www.mozilla.org/",
  },
  {
    input: "sub.www..mozilla...org/",
    fixedURI: "http://sub.www.mozilla.org/",
    protocolChange: true,
  },
  {
    input: "sub.www..mozilla...org",
    fixedURI: "http://sub.www.mozilla.org/",
    protocolChange: true,
  },
  {
    input: "www...mozilla",
    fixedURI: "http://www.mozilla/",
    keywordLookup: true,
    protocolChange: true,
    shouldRunTest: flags =>
      !gSingleWordDNSLookup &&
      flags & Services.uriFixup.FIXUP_FLAG_ALLOW_KEYWORD_LOOKUP,
  },
  {
    input: "www...mozilla",
    fixedURI: "http://www.mozilla/",
    protocolChange: true,
    shouldRunTest: flags =>
      gSingleWordDNSLookup ||
      !(flags & Services.uriFixup.FIXUP_FLAG_ALLOW_KEYWORD_LOOKUP),
  },
  {
    input: "mozilla...org",
    fixedURI: "http://mozilla.org/",
    protocolChange: true,
  },
  {
    input: "モジラ...org",
    fixedURI: "http://xn--yck6dwa.org/",
    protocolChange: true,
  },
  {
    input: "user@localhost",
    fixedURI: "http://user@localhost/",
    protocolChange: true,
    shouldRunTest: () => gSingleWordDNSLookup,
  },
  {
    input: "user@localhost",
    fixedURI: "http://user@localhost/",
    keywordLookup: true,
    protocolChange: true,
    shouldRunTest: () => !gSingleWordDNSLookup,
  },
  {
    input: "user@192.168.0.1",
    fixedURI: "http://user@192.168.0.1/",
    protocolChange: true,
  },
  {
    input: "user@dummy-host",
    fixedURI: "http://user@dummy-host/",
    protocolChange: true,
    shouldRunTest: () => gSingleWordDNSLookup,
  },
  {
    input: "user@dummy-host",
    fixedURI: "http://user@dummy-host/",
    keywordLookup: true,
    protocolChange: true,
    shouldRunTest: () => !gSingleWordDNSLookup,
  },
  {
    input: "user:pass@dummy-host",
    fixedURI: "http://user:pass@dummy-host/",
    protocolChange: true,
  },
  {
    input: ":pass@dummy-host",
    fixedURI: "http://:pass@dummy-host/",
    protocolChange: true,
  },
  {
    input: "user@dummy-host/path",
    fixedURI: "http://user@dummy-host/path",
    protocolChange: true,
    shouldRunTest: () => gSingleWordDNSLookup,
  },
  {
    input: "jar:file:///omni.ja!/",
    fixedURI: "jar:file:///omni.ja!/",
  },
  {
    input: "example.comm.",
    fixedURI: "http://example.comm./",
    protocolChange: true,
  },
  {
    input: "example。com。",
    fixedURI: "http://example.com./",
    protocolChange: true,
  },
  {
    input: "example。comm。",
    fixedURI: "http://example.comm./",
    protocolChange: true,
    keywordLookup: true,
    affectedByDNSForSingleWordHosts: true,
  },

  {
    input: "0.0.0.0",
    fixedURI: "http://127.0.0.1/",
    protocolChange: true,
    shouldRunTest: schemeTypoOnly,
  },
  {
    input: "0.0.0.0/",
    fixedURI: "http://127.0.0.1/",
    protocolChange: true,
    shouldRunTest: schemeTypoOnly,
  },
  {
    input: "0.0.0.0:8080",
    fixedURI: "http://127.0.0.1:8080/",
    protocolChange: true,
    shouldRunTest: schemeTypoOnly,
  },
  {
    input: "0.0.0.0:8080/blah?blah",
    fixedURI: "http://127.0.0.1:8080/blah?blah",
    protocolChange: true,
    shouldRunTest: schemeTypoOnly,
  },
  {
    input: "http://0.0.0.0",
    fixedURI: "http://127.0.0.1/",
    shouldRunTest: schemeTypoOnly,
  },
  {
    input: "http://0.0.0.0/",
    fixedURI: "http://127.0.0.1/",
    shouldRunTest: schemeTypoOnly,
  },
  {
    input: "http://0.0.0.0:8080",
    fixedURI: "http://127.0.0.1:8080/",
    shouldRunTest: schemeTypoOnly,
  },
  {
    input: "http://0.0.0.0:8080/blah?blah",
    fixedURI: "http://127.0.0.1:8080/blah?blah",
    shouldRunTest: schemeTypoOnly,
  },
  {
    input: "https://0.0.0.0",
    fixedURI: "https://127.0.0.1/",
    shouldRunTest: schemeTypoOnly,
  },
  {
    input: "https://0.0.0.0/",
    fixedURI: "https://127.0.0.1/",
    shouldRunTest: schemeTypoOnly,
  },
  {
    input: "https://0.0.0.0:8080",
    fixedURI: "https://127.0.0.1:8080/",
    shouldRunTest: schemeTypoOnly,
  },
  {
    input: "https://0.0.0.0:8080/blah?blah",
    fixedURI: "https://127.0.0.1:8080/blah?blah",
    shouldRunTest: schemeTypoOnly,
  },

  {
    input: "[::]",
    fixedURI: "http://[::1]/",
    protocolChange: true,
    shouldRunTest: schemeTypoOnly,
  },
  {
    input: "[::]/",
    fixedURI: "http://[::1]/",
    protocolChange: true,
    shouldRunTest: schemeTypoOnly,
  },
  {
    input: "[::]:8080",
    fixedURI: "http://[::1]:8080/",
    protocolChange: true,
    shouldRunTest: schemeTypoOnly,
  },
  {
    input: "[::]:8080/blah?blah",
    fixedURI: "http://[::1]:8080/blah?blah",
    protocolChange: true,
    shouldRunTest: schemeTypoOnly,
  },
  {
    input: "http://[::]",
    fixedURI: "http://[::1]/",
    shouldRunTest: schemeTypoOnly,
  },
  {
    input: "http://[::]/",
    fixedURI: "http://[::1]/",
    shouldRunTest: schemeTypoOnly,
  },
  {
    input: "http://[::]:8080",
    fixedURI: "http://[::1]:8080/",
    shouldRunTest: schemeTypoOnly,
  },
  {
    input: "http://[::]:8080/blah?blah",
    fixedURI: "http://[::1]:8080/blah?blah",
    shouldRunTest: schemeTypoOnly,
  },
  {
    input: "https://[::]",
    fixedURI: "https://[::1]/",
    shouldRunTest: schemeTypoOnly,
  },
  {
    input: "https://[::]/",
    fixedURI: "https://[::1]/",
    shouldRunTest: schemeTypoOnly,
  },
  {
    input: "https://[::]:8080",
    fixedURI: "https://[::1]:8080/",
    shouldRunTest: schemeTypoOnly,
  },
  {
    input: "https://[::]:8080/blah?blah",
    fixedURI: "https://[::1]:8080/blah?blah",
    shouldRunTest: schemeTypoOnly,
  },
];

if (AppConstants.platform == "win") {
  testcases.push({
    input: "C:\\some\\file.txt",
    fixedURI: "file:///C:/some/file.txt",
    protocolChange: true,
  });
  testcases.push({
    input: "//mozilla",
    fixedURI: "http://mozilla/",
    alternateURI: "https://www.mozilla.com/",
    protocolChange: true,
  });
  testcases.push({
    input: "/a",
    fixedURI: "http://a/",
    alternateURI: "https://www.a.com/",
    keywordLookup: true,
    protocolChange: true,
    affectedByDNSForSingleWordHosts: true,
  });
} else {
  const homeDir = Services.dirsvc.get("Home", Ci.nsIFile).path;
  const homeBase = AppConstants.platform == "macosx" ? "/Users" : "/home";

  testcases.push({
    input: "~",
    fixedURI: `file://${homeDir}`,
    protocolChange: true,
  });
  testcases.push({
    input: "~/foo",
    fixedURI: `file://${homeDir}/foo`,
    protocolChange: true,
  });
  testcases.push({
    input: "~foo",
    fixedURI: `file://${homeBase}/foo`,
    protocolChange: true,
  });
  testcases.push({
    input: "~foo/bar",
    fixedURI: `file://${homeBase}/foo/bar`,
    protocolChange: true,
  });
  testcases.push({
    input: "/some/file.txt",
    fixedURI: "file:///some/file.txt",
    protocolChange: true,
  });
  testcases.push({
    input: "//mozilla",
    fixedURI: "file:////mozilla",
    protocolChange: true,
  });
  testcases.push({
    input: "/a",
    fixedURI: "file:///a",
    protocolChange: true,
  });
}

function sanitize(input) {
  return input.replace(/\r|\n/g, "").trim();
}

add_task(async function setup() {
  var prefList = [
    "browser.fixup.typo.scheme",
    "keyword.enabled",
    "browser.fixup.domainwhitelist.whitelisted",
    "browser.fixup.domainsuffixwhitelist.test",
    "browser.fixup.domainsuffixwhitelist.local.domain",
    "browser.search.separatePrivateDefault",
    "browser.search.separatePrivateDefault.ui.enabled",
  ];
  for (let pref of prefList) {
    Services.prefs.setBoolPref(pref, true);
  }

  await setupSearchService();
  await addTestEngines();

  await Services.search.setDefault(
    Services.search.getEngineByName(kSearchEngineID),
    Ci.nsISearchService.CHANGE_REASON_UNKNOWN
  );
  await Services.search.setDefaultPrivate(
    Services.search.getEngineByName(kPrivateSearchEngineID),
    Ci.nsISearchService.CHANGE_REASON_UNKNOWN
  );
});

var gSingleWordDNSLookup = false;
add_task(async function run_test() {
  // Only keywordlookup things should be affected by requiring a DNS lookup for single-word hosts:
  info(
    "Check only keyword lookup testcases should be affected by requiring DNS for single hosts"
  );
  let affectedTests = testcases.filter(
    t => !t.keywordLookup && t.affectedByDNSForSingleWordHosts
  );
  if (affectedTests.length) {
    for (let testcase of affectedTests) {
      info("Affected: " + testcase.input);
    }
  }
  Assert.equal(affectedTests.length, 0);
  await do_single_test_run();
  gSingleWordDNSLookup = true;
  await do_single_test_run();
  gSingleWordDNSLookup = false;
  await Services.search.setDefault(
    Services.search.getEngineByName(kPostSearchEngineID),
    Ci.nsISearchService.CHANGE_REASON_UNKNOWN
  );
  await do_single_test_run();
});

async function do_single_test_run() {
  Services.prefs.setBoolPref(kForceDNSLookup, gSingleWordDNSLookup);
  let relevantTests = gSingleWordDNSLookup
    ? testcases.filter(t => t.keywordLookup)
    : testcases;

  let engine = await Services.search.getDefault();
  let engineUrl =
    engine.name == kPostSearchEngineID
      ? kPostSearchEngineURL
      : kSearchEngineURL;
  let privateEngine = await Services.search.getDefaultPrivate();
  let privateEngineUrl = kPrivateSearchEngineURL;

  for (let {
    input: testInput,
    fixedURI: expectedFixedURI,
    alternateURI: alternativeURI,
    keywordLookup: expectKeywordLookup,
    protocolChange: expectProtocolChange,
    inWhitelist: inWhitelist,
    affectedByDNSForSingleWordHosts: affectedByDNSForSingleWordHosts,
    shouldRunTest,
  } of relevantTests) {
    // Explicitly force these into a boolean
    expectKeywordLookup = !!expectKeywordLookup;
    expectProtocolChange = !!expectProtocolChange;
    inWhitelist = !!inWhitelist;
    affectedByDNSForSingleWordHosts = !!affectedByDNSForSingleWordHosts;

    expectKeywordLookup =
      expectKeywordLookup &&
      (!affectedByDNSForSingleWordHosts || !gSingleWordDNSLookup);

    for (let flags of flagInputs) {
      info(
        'Checking "' +
          testInput +
          '" with flags ' +
          flags +
          " (DNS lookup for single words: " +
          (gSingleWordDNSLookup ? "yes" : "no") +
          ")"
      );

      if (shouldRunTest && !shouldRunTest(flags)) {
        continue;
      }

      let URIInfo;
      try {
        URIInfo = Services.uriFixup.getFixupURIInfo(testInput, flags);
      } catch (ex) {
        // Both APIs should return an error in the same cases.
        info("Caught exception: " + ex);
        Assert.equal(expectedFixedURI, null);
        continue;
      }

      // Check the fixedURI:
      let makeAlternativeURI =
        flags & Services.uriFixup.FIXUP_FLAGS_MAKE_ALTERNATE_URI;

      if (makeAlternativeURI && alternativeURI != null) {
        Assert.equal(
          URIInfo.fixedURI.spec,
          alternativeURI,
          "should have gotten alternate URI"
        );
      } else {
        Assert.equal(
          URIInfo.fixedURI && URIInfo.fixedURI.spec,
          expectedFixedURI,
          "should get correct fixed URI"
        );
      }

      // Check booleans on input:
      let couldDoKeywordLookup =
        flags & Services.uriFixup.FIXUP_FLAG_ALLOW_KEYWORD_LOOKUP;
      Assert.equal(
        !!URIInfo.keywordProviderName,
        couldDoKeywordLookup && expectKeywordLookup,
        "keyword lookup as expected"
      );

      let expectProtocolChangeAfterAlternate = false;
      // If alternativeURI was created, the protocol of the URI
      // might have been changed to browser.fixup.alternate.protocol
      // If the protocol is not the same as what was in expectedFixedURI,
      // the protocol must've changed in the fixup process.
      if (
        makeAlternativeURI &&
        alternativeURI != null &&
        !expectedFixedURI.startsWith(URIInfo.fixedURI.scheme)
      ) {
        expectProtocolChangeAfterAlternate = true;
      }

      Assert.equal(
        URIInfo.fixupChangedProtocol,
        expectProtocolChange || expectProtocolChangeAfterAlternate,
        "protocol change as expected"
      );
      Assert.equal(
        URIInfo.fixupCreatedAlternateURI,
        makeAlternativeURI && alternativeURI != null,
        "alternative URI as expected"
      );

      // Check the preferred URI
      if (couldDoKeywordLookup) {
        if (expectKeywordLookup) {
          if (!inWhitelist) {
            let urlparamInput = encodeURIComponent(sanitize(testInput)).replace(
              /%20/g,
              "+"
            );
            // If the input starts with `?`, then URIInfo.preferredURI.spec will omit it
            // In order to test this behaviour, remove `?` only if it is the first character
            if (urlparamInput.startsWith("%3F")) {
              urlparamInput = urlparamInput.replace("%3F", "");
            }
            let isPrivate =
              flags & Services.uriFixup.FIXUP_FLAG_PRIVATE_CONTEXT;
            let searchEngineUrl = isPrivate ? privateEngineUrl : engineUrl;
            let searchURL = searchEngineUrl.replace(
              "{searchTerms}",
              urlparamInput
            );
            let spec = URIInfo.preferredURI.spec.replace(/%27/g, "'");
            Assert.equal(spec, searchURL, "should get correct search URI");
            let providerName = isPrivate ? privateEngine.name : engine.name;
            Assert.equal(
              URIInfo.keywordProviderName,
              providerName,
              "should get correct provider name"
            );
            // Also check keywordToURI() uses the right engine.
            let kwInfo = Services.uriFixup.keywordToURI(
              urlparamInput,
              isPrivate
            );
            Assert.equal(kwInfo.providerName, URIInfo.providerName);
            if (providerName == kPostSearchEngineID) {
              Assert.ok(kwInfo.postData);
              let submission = engine.getSubmission(urlparamInput);
              let enginePostData = NetUtil.readInputStreamToString(
                submission.postData,
                submission.postData.available()
              );
              let postData = NetUtil.readInputStreamToString(
                kwInfo.postData,
                kwInfo.postData.available()
              );
              Assert.equal(postData, enginePostData);
            }
          } else {
            Assert.equal(
              URIInfo.preferredURI,
              null,
              "not expecting a preferred URI"
            );
          }
        } else {
          Assert.equal(
            URIInfo.preferredURI.spec,
            URIInfo.fixedURI.spec,
            "fixed URI should match"
          );
        }
      } else {
        // In these cases, we should never be doing a keyword lookup and
        // the fixed URI should be preferred:
        let prefURI = URIInfo.preferredURI && URIInfo.preferredURI.spec;
        let fixedURI = URIInfo.fixedURI && URIInfo.fixedURI.spec;
        Assert.equal(prefURI, fixedURI, "fixed URI should be same as expected");
      }
      Assert.equal(
        sanitize(testInput),
        URIInfo.originalInput,
        "should mirror original input"
      );
    }
  }
}