trisquel-icecat/icecat/intl/l10n/test/test_l10nregistry_fuzzed.js

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

/**
 * This test is a fuzzing test for the L10nRegistry API. It was written to find
 * a hard to reproduce bug in the L10nRegistry code. If it fails, place the seed
 * from the failing run in the code directly below to make it consistently reproducible.
 */
let seed = Math.floor(Math.random() * 1e9);

console.log(`Starting a fuzzing run with seed: ${seed}.`);
console.log("To reproduce this test locally, re-run it locally with:");
console.log(`let seed = ${seed};`);

/**
 * A simple non-robust psuedo-random number generator.
 *
 * It is implemented using a Lehmer random number generator.
 * https://en.wikipedia.org/wiki/16,807
 *
 * @returns {number} Ranged [0, 1)
 */
function prng() {
  const multiplier = 16807;
  const prime = 2147483647;
  seed = seed * multiplier % prime
  return (seed - 1) / prime
}

/**
 * Generate a name like "mock-dmsxfodrqboljmxdeayt".
 * @returns {string}
 */
function generateRandomName() {
  let name = 'mock-'
  const letters = "abcdefghijklmnopqrstuvwxyz";
  for (let i = 0; i < 20; i++) {
    name += letters[Math.floor(prng() * letters.length)];
  }
  return name;
}

/**
 * Picks one item from an array.
 *
 * @param {Array<T>}
 * @returns {T}
 */
function pickOne(list) {
  return list[Math.floor(prng() * list.length)]
}

/**
 * Picks a random subset from an array.
 *
 * @param {Array<T>}
 * @returns {Array<T>}
 */
function pickN(list, count) {
  list = list.slice();
  const result = [];
  for (let i = 0; i < count && i < list.length; i++) {
    // Pick a random item.
    const index = Math.floor(prng() * list.length);

    // Swap item to the end.
    const a = list[index];
    const b = list[list.length - 1];
    list[index] = b;
    list[list.length - 1] = a

    // Now that the random item is on the end, pop it off and add it to the results.
    result.push(list.pop());
  }

  return result
}

/**
 * Generate a random number
 * @param {number} min
 * @param {number} max
 * @returns {number}
 */
function random(min, max) {
  const delta = max - min;
  return min + delta * prng();
}

/**
 * Generate a random number generator with a distribution more towards the lower end.
 * @param {number} min
 * @param {number} max
 * @returns {number}
 */
function randomPow(min, max) {
  const delta = max - min;
  const r = prng()
  return min + delta * r * r;
}

add_task(async function test_fuzzing_sources() {
    const iterations = 100;
    const maxSources = 10;
  
    const metasources = ["app", "langpack", ""];
    const availableLocales = ["en", "en-US", "pl", "en-CA", "es-AR", "es-ES"];

    const l10nReg = new L10nRegistry();

    for (let i = 0; i < iterations; i++) {
      console.log("----------------------------------------------------------------------");
      console.log("Iteration", i);
      let sourceCount = randomPow(0, maxSources);

      const mocks = [];
      const fs = [];

      const locales = new Set();
      const filenames = new Set();

      for (let j = 0; j < sourceCount; j++) {
        const locale = pickOne(availableLocales);
        locales.add(locale);

        let metasource = pickOne(metasources);
        if (metasource === "langpack") {
          metasource = `${metasource}-${locale}`
        }
  
        const dir = generateRandomName();
        const filename = generateRandomName() + j + ".ftl";
        const path = `${dir}/${locale}/${filename}`
        const name = metasource || "app";
        const source = "key = value";

        filenames.add(filename);

        console.log("Add source", { name, metasource, path, source });
        fs.push({ path, source });

        mocks.push([
          name, // name
          metasource, // metasource,
          [locale], // locales,
          dir + "/{locale}/",
          fs
        ])
      }

      l10nReg.registerSources(mocks.map(args => L10nFileSource.createMock(...args)));

      const bundleLocales = pickN([...locales], random(1, 4));
      const bundleFilenames = pickN([...filenames], random(1, 10));

      console.log("generateBundles", {bundleLocales, bundleFilenames});
      const bundles = l10nReg.generateBundles(
        bundleLocales,
        bundleFilenames
      );

      function next() {
        console.log("Getting next bundle");
        const bundle = bundles.next()
        console.log("Next bundle obtained", bundle);
        return bundle;
      }

      const ops = [
        // Increase the frequency of next being called.
        next,
        next,
        next,
        () => {
          const newMocks = [];
          for (const mock of pickN(mocks, random(0, 3))) {
            const newMock = mock.slice();
            newMocks.push(newMock)
          }
          console.log("l10nReg.updateSources");
          l10nReg.updateSources(newMocks.map(mock => L10nFileSource.createMock(...mock)));
        },
        () => {
          console.log("l10nReg.clearSources");
          l10nReg.clearSources();
        }
      ];

      console.log("Start the operation loop");
      while (true) {
        console.log("Next operation");
        const op = pickOne(ops);
        const result = await op();
        if (result?.done) {
          // The iterator completed.
          break;
        }
      }

      console.log("Clear sources");
      l10nReg.clearSources();
    }

    ok(true, "The L10nRegistry fuzzing did not crash.")
});