/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
/* vim:set ts=2 sw=2 sts=2 et: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

/**
 * Tests Places query serialization.  Associated bug is
 * https://bugzilla.mozilla.org/show_bug.cgi?id=370197
 *
 * The simple idea behind this test is to try out different combinations of
 * query switches and ensure that queries are the same before serialization
 * as they are after de-serialization.
 *
 * In the code below, "switch" refers to a query option -- "option" in a broad
 * sense, not nsINavHistoryQueryOptions specifically (which is why we refer to
 * them as switches, not options).  Both nsINavHistoryQuery and
 * nsINavHistoryQueryOptions allow you to specify switches that affect query
 * strings.  nsINavHistoryQuery instances have attributes hasBeginTime,
 * hasEndTime, hasSearchTerms, and so on.  nsINavHistoryQueryOptions instances
 * have attributes sortingMode, resultType, excludeItems, etc.
 *
 * Ideally we would like to test all 2^N subsets of switches, where N is the
 * total number of switches; switches might interact in erroneous or other ways
 * we do not expect.  However, since N is large (21 at this time), that's
 * impractical for a single test in a suite.
 *
 * Instead we choose all possible subsets of a certain, smaller size.  In fact
 * we begin by choosing CHOOSE_HOW_MANY_SWITCHES_LO and ramp up to
 * CHOOSE_HOW_MANY_SWITCHES_HI.
 *
 * There are two more wrinkles.  First, for some switches we'd like to be able to
 * test multiple values.  For example, it seems like a good idea to test both an
 * empty string and a non-empty string for switch nsINavHistoryQuery.searchTerms.
 * When switches have more than one value for a test run, we use the Cartesian
 * product of their values to generate all possible combinations of values.
 *
 * Second, we need to also test serialization of multiple nsINavHistoryQuery
 * objects at once.  To do this, we remember the previous NUM_MULTIPLE_QUERIES
 * queries we tested individually and then serialize them together.  We do this
 * each time we test an individual query.  Thus the set of queries we test
 * together loses one query and gains another each time.
 *
 * To summarize, here's how this test works:
 *
 * - For n = CHOOSE_HOW_MANY_SWITCHES_LO to CHOOSE_HOW_MANY_SWITCHES_HI:
 *   - From the total set of switches choose all possible subsets of size n.
 *     For each of those subsets s:
 *     - Collect the test runs of each switch in subset s and take their
 *       Cartesian product.  For each sequence in the product:
 *       - Create nsINavHistoryQuery and nsINavHistoryQueryOptions objects
 *         with the chosen switches and test run values.
 *       - Serialize the query.
 *       - De-serialize and ensure that the de-serialized query objects equal
 *         the originals.
 *       - For each of the previous NUM_MULTIPLE_QUERIES
 *         nsINavHistoryQueryOptions objects o we created:
 *         - Serialize the previous NUM_MULTIPLE_QUERIES nsINavHistoryQuery
 *           objects together with o.
 *         - De-serialize and ensure that the de-serialized query objects
 *           equal the originals.
 */

const CHOOSE_HOW_MANY_SWITCHES_LO = 1;
const CHOOSE_HOW_MANY_SWITCHES_HI = 2;

const NUM_MULTIPLE_QUERIES        = 2;

// The switches are represented by objects below, in arrays querySwitches and
// queryOptionSwitches.  Use them to set up test runs.
//
// Some switches have special properties (where noted), but all switches must
// have the following properties:
//
//   matches: A function that takes two nsINavHistoryQuery objects (in the case
//            of nsINavHistoryQuery switches) or two nsINavHistoryQueryOptions
//            objects (for nsINavHistoryQueryOptions switches) and returns true
//            if the values of the switch in the two objects are equal.  This is
//            the foundation of how we determine if two queries are equal.
//   runs:    An array of functions.  Each function takes an nsINavHistoryQuery
//            object and an nsINavHistoryQueryOptions object.  The functions
//            should set the attributes of one of the two objects as appropriate
//            to their switches.  This is how switch values are set for each test
//            run.
//
// The following properties are optional:
//
//   desc:    An informational string to print out during runs when the switch
//            is chosen.  Hopefully helpful if the test fails.

// nsINavHistoryQuery switches
const querySwitches = [
  // hasBeginTime
  {
    // flag and subswitches are used by the flagSwitchMatches function.  Several
    // of the nsINavHistoryQuery switches (like this one) are really guard flags
    // that indicate if other "subswitches" are enabled.
    flag:        "hasBeginTime",
    subswitches: ["beginTime", "beginTimeReference", "absoluteBeginTime"],
    desc:        "nsINavHistoryQuery.hasBeginTime",
    matches:     flagSwitchMatches,
    runs:        [
      function (aQuery, aQueryOptions) {
        aQuery.beginTime = Date.now() * 1000;
        aQuery.beginTimeReference = Ci.nsINavHistoryQuery.TIME_RELATIVE_EPOCH;
      },
      function (aQuery, aQueryOptions) {
        aQuery.beginTime = Date.now() * 1000;
        aQuery.beginTimeReference = Ci.nsINavHistoryQuery.TIME_RELATIVE_TODAY;
      }
    ]
  },
  // hasEndTime
  {
    flag:        "hasEndTime",
    subswitches: ["endTime", "endTimeReference", "absoluteEndTime"],
    desc:        "nsINavHistoryQuery.hasEndTime",
    matches:     flagSwitchMatches,
    runs:        [
      function (aQuery, aQueryOptions) {
        aQuery.endTime = Date.now() * 1000;
        aQuery.endTimeReference = Ci.nsINavHistoryQuery.TIME_RELATIVE_EPOCH;
      },
      function (aQuery, aQueryOptions) {
        aQuery.endTime = Date.now() * 1000;
        aQuery.endTimeReference = Ci.nsINavHistoryQuery.TIME_RELATIVE_TODAY;
      }
    ]
  },
  // hasSearchTerms
  {
    flag:        "hasSearchTerms",
    subswitches: ["searchTerms"],
    desc:        "nsINavHistoryQuery.hasSearchTerms",
    matches:     flagSwitchMatches,
    runs:        [
      function (aQuery, aQueryOptions) {
        aQuery.searchTerms = "shrimp and white wine";
      },
      function (aQuery, aQueryOptions) {
        aQuery.searchTerms = "";
      }
    ]
  },
  // hasDomain
  {
    flag:        "hasDomain",
    subswitches: ["domain", "domainIsHost"],
    desc:        "nsINavHistoryQuery.hasDomain",
    matches:     flagSwitchMatches,
    runs:        [
      function (aQuery, aQueryOptions) {
        aQuery.domain = "mozilla.com";
        aQuery.domainIsHost = false;
      },
      function (aQuery, aQueryOptions) {
        aQuery.domain = "www.mozilla.com";
        aQuery.domainIsHost = true;
      },
      function (aQuery, aQueryOptions) {
        aQuery.domain = "";
      }
    ]
  },
  // hasUri
  {
    flag:        "hasUri",
    subswitches: ["uri", "uriIsPrefix"],
    desc:        "nsINavHistoryQuery.hasUri",
    matches:     flagSwitchMatches,
    runs:        [
      function (aQuery, aQueryOptions) {
        aQuery.uri = uri("http://mozilla.com");
        aQuery.uriIsPrefix = false;
      },
      function (aQuery, aQueryOptions) {
        aQuery.uri = uri("http://mozilla.com");
        aQuery.uriIsPrefix = true;
      }
    ]
  },
  // hasAnnotation
  {
    flag:        "hasAnnotation",
    subswitches: ["annotation", "annotationIsNot"],
    desc:        "nsINavHistoryQuery.hasAnnotation",
    matches:     flagSwitchMatches,
    runs:        [
      function (aQuery, aQueryOptions) {
        aQuery.annotation = "bookmarks/toolbarFolder";
        aQuery.annotationIsNot = false;
      },
      function (aQuery, aQueryOptions) {
        aQuery.annotation = "bookmarks/toolbarFolder";
        aQuery.annotationIsNot = true;
      }
    ]
  },
  // minVisits
  {
    // property is used by function simplePropertyMatches.
    property: "minVisits",
    desc:     "nsINavHistoryQuery.minVisits",
    matches:  simplePropertyMatches,
    runs:     [
      function (aQuery, aQueryOptions) {
        aQuery.minVisits = 0x7fffffff; // 2^31 - 1
      }
    ]
  },
  // maxVisits
  {
    property: "maxVisits",
    desc:     "nsINavHistoryQuery.maxVisits",
    matches:  simplePropertyMatches,
    runs:     [
      function (aQuery, aQueryOptions) {
        aQuery.maxVisits = 0x7fffffff; // 2^31 - 1
      }
    ]
  },
  // onlyBookmarked
  {
    property: "onlyBookmarked",
    desc:     "nsINavHistoryQuery.onlyBookmarked",
    matches:  simplePropertyMatches,
    runs:     [
      function (aQuery, aQueryOptions) {
        aQuery.onlyBookmarked = true;
      }
    ]
  },
  // getFolders
  {
    desc:    "nsINavHistoryQuery.getFolders",
    matches: function (aQuery1, aQuery2) {
      var q1Folders = aQuery1.getFolders();
      var q2Folders = aQuery2.getFolders();
      if (q1Folders.length !== q2Folders.length)
        return false;
      for (let i = 0; i < q1Folders.length; i++) {
        if (q2Folders.indexOf(q1Folders[i]) < 0)
          return false;
      }
      for (let i = 0; i < q2Folders.length; i++) {
        if (q1Folders.indexOf(q2Folders[i]) < 0)
          return false;
      }
      return true;
    },
    runs: [
      function (aQuery, aQueryOptions) {
        aQuery.setFolders([], 0);
      },
      function (aQuery, aQueryOptions) {
        aQuery.setFolders([PlacesUtils.placesRootId], 1);
      },
      function (aQuery, aQueryOptions) {
        aQuery.setFolders([PlacesUtils.placesRootId, PlacesUtils.tagsFolderId], 2);
      }
    ]
  },
  // tags
  {
    desc:    "nsINavHistoryQuery.getTags",
    matches: function (aQuery1, aQuery2) {
      if (aQuery1.tagsAreNot !== aQuery2.tagsAreNot)
        return false;
      var q1Tags = aQuery1.tags;
      var q2Tags = aQuery2.tags;
      if (q1Tags.length !== q2Tags.length)
        return false;
      for (let i = 0; i < q1Tags.length; i++) {
        if (q2Tags.indexOf(q1Tags[i]) < 0)
          return false;
      }
      for (let i = 0; i < q2Tags.length; i++) {
        if (q1Tags.indexOf(q2Tags[i]) < 0)
          return false;
      }
      return true;
    },
    runs: [
      function (aQuery, aQueryOptions) {
        aQuery.tags = [];
      },
      function (aQuery, aQueryOptions) {
        aQuery.tags = [""];
      },
      function (aQuery, aQueryOptions) {
        aQuery.tags = [
          "foo",
          "七難",
          "",
          "いっぱいおっぱい",
          "Abracadabra",
          "１２３",
          "Here's a pretty long tag name with some = signs and 1 2 3s and spaces oh jeez will it work I hope so!",
          "アスキーでございません",
          "あいうえお",
        ];
      },
      function (aQuery, aQueryOptions) {
        aQuery.tags = [
          "foo",
          "七難",
          "",
          "いっぱいおっぱい",
          "Abracadabra",
          "１２３",
          "Here's a pretty long tag name with some = signs and 1 2 3s and spaces oh jeez will it work I hope so!",
          "アスキーでございません",
          "あいうえお",
        ];
        aQuery.tagsAreNot =  true;
      }
    ]
  },
  // transitions
  {
    desc: "tests nsINavHistoryQuery.getTransitions",
    matches: function (aQuery1, aQuery2) {
      var q1Trans = aQuery1.getTransitions();
      var q2Trans = aQuery2.getTransitions();
      if (q1Trans.length !== q2Trans.length)
        return false;
      for (let i = 0; i < q1Trans.length; i++) {
        if (q2Trans.indexOf(q1Trans[i]) < 0)
          return false;
      }
      for (let i = 0; i < q2Trans.length; i++) {
        if (q1Trans.indexOf(q2Trans[i]) < 0)
          return false;
      }
      return true;
    },
    runs: [
      function (aQuery, aQueryOptions) {
        aQuery.setTransitions([], 0);
      },
      function (aQuery, aQueryOptions) {
        aQuery.setTransitions([Ci.nsINavHistoryService.TRANSITION_DOWNLOAD],
                              1);
      },
      function (aQuery, aQueryOptions) {
        aQuery.setTransitions([Ci.nsINavHistoryService.TRANSITION_TYPED,
                               Ci.nsINavHistoryService.TRANSITION_BOOKMARK], 2);
      }
    ]
  },
];

// nsINavHistoryQueryOptions switches
const queryOptionSwitches = [
  // sortingMode
  {
    desc:    "nsINavHistoryQueryOptions.sortingMode",
    matches: function (aOptions1, aOptions2) {
      if (aOptions1.sortingMode === aOptions2.sortingMode) {
        switch (aOptions1.sortingMode) {
          case aOptions1.SORT_BY_ANNOTATION_ASCENDING:
          case aOptions1.SORT_BY_ANNOTATION_DESCENDING:
            return aOptions1.sortingAnnotation === aOptions2.sortingAnnotation;
            break;
        }
        return true;
      }
      return false;
    },
    runs: [
      function (aQuery, aQueryOptions) {
        aQueryOptions.sortingMode = aQueryOptions.SORT_BY_DATE_ASCENDING;
      },
      function (aQuery, aQueryOptions) {
        aQueryOptions.sortingMode = aQueryOptions.SORT_BY_ANNOTATION_ASCENDING;
        aQueryOptions.sortingAnnotation = "bookmarks/toolbarFolder";
      }
    ]
  },
  // resultType
  {
    // property is used by function simplePropertyMatches.
    property: "resultType",
    desc:     "nsINavHistoryQueryOptions.resultType",
    matches:  simplePropertyMatches,
    runs:     [
      function (aQuery, aQueryOptions) {
        aQueryOptions.resultType = aQueryOptions.RESULTS_AS_URI;
      },
      function (aQuery, aQueryOptions) {
        aQueryOptions.resultType = aQueryOptions.RESULTS_AS_FULL_VISIT;
      }
    ]
  },
  // excludeItems
  {
    property: "excludeItems",
    desc:     "nsINavHistoryQueryOptions.excludeItems",
    matches:  simplePropertyMatches,
    runs:     [
      function (aQuery, aQueryOptions) {
        aQueryOptions.excludeItems = true;
      }
    ]
  },
  // excludeQueries
  {
    property: "excludeQueries",
    desc:     "nsINavHistoryQueryOptions.excludeQueries",
    matches:  simplePropertyMatches,
    runs:     [
      function (aQuery, aQueryOptions) {
        aQueryOptions.excludeQueries = true;
      }
    ]
  },
  // expandQueries
  {
    property: "expandQueries",
    desc:     "nsINavHistoryQueryOptions.expandQueries",
    matches:  simplePropertyMatches,
    runs:     [
      function (aQuery, aQueryOptions) {
        aQueryOptions.expandQueries = true;
      }
    ]
  },
  // includeHidden
  {
    property: "includeHidden",
    desc:     "nsINavHistoryQueryOptions.includeHidden",
    matches:  simplePropertyMatches,
    runs:     [
      function (aQuery, aQueryOptions) {
        aQueryOptions.includeHidden = true;
      }
    ]
  },
  // maxResults
  {
    property: "maxResults",
    desc:     "nsINavHistoryQueryOptions.maxResults",
    matches:  simplePropertyMatches,
    runs:     [
      function (aQuery, aQueryOptions) {
        aQueryOptions.maxResults = 0xffffffff; // 2^32 - 1
      }
    ]
  },
  // queryType
  {
    property: "queryType",
    desc:     "nsINavHistoryQueryOptions.queryType",
    matches:  simplePropertyMatches,
    runs:     [
      function (aQuery, aQueryOptions) {
        aQueryOptions.queryType = aQueryOptions.QUERY_TYPE_HISTORY;
      },
      function (aQuery, aQueryOptions) {
        aQueryOptions.queryType = aQueryOptions.QUERY_TYPE_UNIFIED;
      }
    ]
  },
];

///////////////////////////////////////////////////////////////////////////////

/**
 * Enumerates all the sequences of the cartesian product of the arrays contained
 * in aSequences.  Examples:
 *
 *   cartProd([[1, 2, 3], ["a", "b"]], callback);
 *   // callback is called 3 * 2 = 6 times with the following arrays:
 *   // [1, "a"], [1, "b"], [2, "a"], [2, "b"], [3, "a"], [3, "b"]
 *
 *   cartProd([["a"], [1, 2, 3], ["X", "Y"]], callback);
 *   // callback is called 1 * 3 * 2 = 6 times with the following arrays:
 *   // ["a", 1, "X"], ["a", 1, "Y"], ["a", 2, "X"], ["a", 2, "Y"],
 *   // ["a", 3, "X"], ["a", 3, "Y"]
 *
 *   cartProd([[1], [2], [3], [4]], callback);
 *   // callback is called 1 * 1 * 1 * 1 = 1 time with the following array:
 *   // [1, 2, 3, 4]
 *
 *   cartProd([], callback);
 *   // callback is 0 times
 *
 *   cartProd([[1, 2, 3, 4]], callback);
 *   // callback is called 4 times with the following arrays:
 *   // [1], [2], [3], [4]
 *
 * @param  aSequences
 *         an array that contains an arbitrary number of arrays
 * @param  aCallback
 *         a function that is passed each sequence of the product as it's
 *         computed
 * @return the total number of sequences in the product
 */
function cartProd(aSequences, aCallback)
{
  if (aSequences.length === 0)
    return 0;

  // For each sequence in aSequences, we maintain a pointer (an array index,
  // really) to the element we're currently enumerating in that sequence
  var seqEltPtrs = aSequences.map(function (i) 0);

  var numProds = 0;
  var done = false;
  while (!done) {
    numProds++;

    // prod = sequence in product we're currently enumerating
    let prod = [];
    for (let i = 0; i < aSequences.length; i++) {
      prod.push(aSequences[i][seqEltPtrs[i]]);
    }
    aCallback(prod);

    // The next sequence in the product differs from the current one by just a
    // single element.  Determine which element that is.  We advance the
    // "rightmost" element pointer to the "right" by one.  If we move past the
    // end of that pointer's sequence, reset the pointer to the first element
    // in its sequence and then try the sequence to the "left", and so on.

    // seqPtr = index of rightmost input sequence whose element pointer is not
    // past the end of the sequence
    let seqPtr = aSequences.length - 1;
    while (!done) {
      // Advance the rightmost element pointer.
      seqEltPtrs[seqPtr]++;

      // The rightmost element pointer is past the end of its sequence.
      if (seqEltPtrs[seqPtr] >= aSequences[seqPtr].length) {
        seqEltPtrs[seqPtr] = 0;
        seqPtr--;

        // All element pointers are past the ends of their sequences.
        if (seqPtr < 0)
          done = true;
      }
      else break;
    }
  }
  return numProds;
}

/**
 * Enumerates all the subsets in aSet of size aHowMany.  There are
 * C(aSet.length, aHowMany) such subsets.  aCallback will be passed each subset
 * as it is generated.  Note that aSet and the subsets enumerated are -- even
 * though they're arrays -- not sequences; the ordering of their elements is not
 * important.  Example:
 *
 *   choose([1, 2, 3, 4], 2, callback);
 *   // callback is called C(4, 2) = 6 times with the following sets (arrays):
 *   // [1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4]
 *
 * @param  aSet
 *         an array from which to choose elements, aSet.length > 0
 * @param  aHowMany
 *         the number of elements to choose, > 0 and <= aSet.length
 * @return the total number of sets chosen
 */
function choose(aSet, aHowMany, aCallback)
{
  // ptrs = indices of the elements in aSet we're currently choosing
  var ptrs = [];
  for (let i = 0; i < aHowMany; i++) {
    ptrs.push(i);
  }

  var numFound = 0;
  var done = false;
  while (!done) {
    numFound++;
    aCallback(ptrs.map(function (p) aSet[p]));

    // The next subset to be chosen differs from the current one by just a
    // single element.  Determine which element that is.  Advance the "rightmost"
    // pointer to the "right" by one.  If we move past the end of set, move the
    // next non-adjacent rightmost pointer to the right by one, and reset all
    // succeeding pointers so that they're adjacent to it.  When all pointers
    // are clustered all the way to the right, we're done.

    // Advance the rightmost pointer.
    ptrs[ptrs.length - 1]++;

    // The rightmost pointer has gone past the end of set.
    if (ptrs[ptrs.length - 1] >= aSet.length) {
      // Find the next rightmost pointer that is not adjacent to the current one.
      let si = aSet.length - 2; // aSet index
      let pi = ptrs.length - 2; // ptrs index
      while (pi >= 0 && ptrs[pi] === si) {
        pi--;
        si--;
      }

      // All pointers are adjacent and clustered all the way to the right.
      if (pi < 0)
        done = true;
      else {
        // pi = index of rightmost pointer with a gap between it and its
        // succeeding pointer.  Move it right and reset all succeeding pointers
        // so that they're adjacent to it.
        ptrs[pi]++;
        for (let i = 0; i < ptrs.length - pi - 1; i++) {
          ptrs[i + pi + 1] = ptrs[pi] + i + 1;
        }
      }
    }
  }
  return numFound;
}

/**
 * Convenience function for nsINavHistoryQuery switches that act as flags.  This
 * is attached to switch objects.  See querySwitches array above.
 *
 * @param  aQuery1
 *         an nsINavHistoryQuery object
 * @param  aQuery2
 *         another nsINavHistoryQuery object
 * @return true if this switch is the same in both aQuery1 and aQuery2
 */
function flagSwitchMatches(aQuery1, aQuery2)
{
  if (aQuery1[this.flag] && aQuery2[this.flag]) {
    for (let p in this.subswitches) {
      if (p in aQuery1 && p in aQuery2) {
        if (aQuery1[p] instanceof Ci.nsIURI) {
          if (!aQuery1[p].equals(aQuery2[p]))
            return false;
        }
        else if (aQuery1[p] !== aQuery2[p])
          return false;
      }
    }
  }
  else if (aQuery1[this.flag] || aQuery2[this.flag])
    return false;

  return true;
}

/**
 * Tests if aObj1 and aObj2 are equal.  This function is general and may be used
 * for either nsINavHistoryQuery or nsINavHistoryQueryOptions objects.  aSwitches
 * determines which set of switches is used for comparison.  Pass in either
 * querySwitches or queryOptionSwitches.
 *
 * @param  aSwitches
 *         determines which set of switches applies to aObj1 and aObj2, either
 *         querySwitches or queryOptionSwitches
 * @param  aObj1
 *         an nsINavHistoryQuery or nsINavHistoryQueryOptions object
 * @param  aObj2
 *         another nsINavHistoryQuery or nsINavHistoryQueryOptions object
 * @return true if aObj1 and aObj2 are equal
 */
function queryObjsEqual(aSwitches, aObj1, aObj2)
{
  for (let i = 0; i < aSwitches.length; i++) {
    if (!aSwitches[i].matches(aObj1, aObj2))
      return false;
  }
  return true;
}

/**
 * This drives the test runs.  See the comment at the top of this file.
 *
 * @param aHowManyLo
 *        the size of the switch subsets to start with
 * @param aHowManyHi
 *        the size of the switch subsets to end with (inclusive)
 */
function runQuerySequences(aHowManyLo, aHowManyHi)
{
  var allSwitches = querySwitches.concat(queryOptionSwitches);
  var prevQueries = [];
  var prevOpts = [];

  // Choose aHowManyLo switches up to aHowManyHi switches.
  for (let howMany = aHowManyLo; howMany <= aHowManyHi; howMany++) {
    let numIters = 0;
    print("CHOOSING " + howMany + " SWITCHES");

    // Choose all subsets of size howMany from allSwitches.
    choose(allSwitches, howMany, function (chosenSwitches) {
      print(numIters);
      numIters++;

      // Collect the runs.
      // runs = [ [runs from switch 1], ..., [runs from switch howMany] ]
      var runs = chosenSwitches.map(function (s) {
        if (s.desc)
          print("  " + s.desc);
        return s.runs;
      });

      // cartProd(runs) => [
      //   [switch 1 run 1, switch 2 run 1, ..., switch howMany run 1 ],
      //   ...,
      //   [switch 1 run 1, switch 2 run 1, ..., switch howMany run N ],
      //   ..., ...,
      //   [switch 1 run N, switch 2 run N, ..., switch howMany run 1 ],
      //   ...,
      //   [switch 1 run N, switch 2 run N, ..., switch howMany run N ],
      // ]
      cartProd(runs, function (runSet) {
        // Create a new query, apply the switches in runSet, and test it.
        var query = PlacesUtils.history.getNewQuery();
        var opts = PlacesUtils.history.getNewQueryOptions();
        for (let i = 0; i < runSet.length; i++) {
          runSet[i](query, opts);
        }
        serializeDeserialize([query], opts);

        // Test the previous NUM_MULTIPLE_QUERIES queries together.
        prevQueries.push(query);
        prevOpts.push(opts);
        if (prevQueries.length >= NUM_MULTIPLE_QUERIES) {
          // We can serialize multiple nsINavHistoryQuery objects together but
          // only one nsINavHistoryQueryOptions object with them.  So, test each
          // of the previous NUM_MULTIPLE_QUERIES nsINavHistoryQueryOptions.
          for (let i = 0; i < prevOpts.length; i++) {
            serializeDeserialize(prevQueries, prevOpts[i]);
          }
          prevQueries.shift();
          prevOpts.shift();
        }
      });
    });
  }
  print("\n");
}

/**
 * Serializes the nsINavHistoryQuery objects in aQueryArr and the
 * nsINavHistoryQueryOptions object aQueryOptions, de-serializes the
 * serialization, and ensures (using do_check_* functions) that the
 * de-serialized objects equal the originals.
 *
 * @param aQueryArr
 *        an array containing nsINavHistoryQuery objects
 * @param aQueryOptions
 *        an nsINavHistoryQueryOptions object
 */
function serializeDeserialize(aQueryArr, aQueryOptions)
{
  var queryStr = PlacesUtils.history.queriesToQueryString(aQueryArr,
                                                        aQueryArr.length,
                                                        aQueryOptions);
  print("  " + queryStr);
  var queryArr2 = {};
  var opts2 = {};
  PlacesUtils.history.queryStringToQueries(queryStr, queryArr2, {}, opts2);
  queryArr2 = queryArr2.value;
  opts2 = opts2.value;

  // The two sets of queries cannot be the same if their lengths differ.
  do_check_eq(aQueryArr.length, queryArr2.length);

  // Although the query serialization code as it is written now practically
  // ensures that queries appear in the query string in the same order they
  // appear in both the array to be serialized and the array resulting from
  // de-serialization, the interface does not guarantee any ordering.  So, for
  // each query in aQueryArr, find its equivalent in queryArr2 and delete it
  // from queryArr2.  If queryArr2 is empty after looping through aQueryArr,
  // the two sets of queries are equal.
  for (let i = 0; i < aQueryArr.length; i++) {
    let j = 0;
    for (; j < queryArr2.length; j++) {
      if (queryObjsEqual(querySwitches, aQueryArr[i], queryArr2[j]))
        break;
    }
    if (j < queryArr2.length)
      queryArr2.splice(j, 1);
  }
  do_check_eq(queryArr2.length, 0);

  // Finally check the query options objects.
  do_check_true(queryObjsEqual(queryOptionSwitches, aQueryOptions, opts2));
}

/**
 * Convenience function for switches that have simple values.  This is attached
 * to switch objects.  See querySwitches and queryOptionSwitches arrays above.
 *
 * @param  aObj1
 *         an nsINavHistoryQuery or nsINavHistoryQueryOptions object
 * @param  aObj2
 *         another nsINavHistoryQuery or nsINavHistoryQueryOptions object
 * @return true if this switch is the same in both aObj1 and aObj2
 */
function simplePropertyMatches(aObj1, aObj2)
{
  return aObj1[this.property] === aObj2[this.property];
}

///////////////////////////////////////////////////////////////////////////////

function run_test()
{
  runQuerySequences(CHOOSE_HOW_MANY_SWITCHES_LO, CHOOSE_HOW_MANY_SWITCHES_HI);
}
