The Tor Browser: comparison toolkit/components/places/tests/queries/test_querySerialization.js

comparison: toolkit/components/places/tests/queries/test_querySerialization.js

toolkit/components/places/tests/queries/test_querySerialization.js

branch: TOR_BUG_9701
changeset 15: b8a032363ba2

equal deleted inserted replaced

--1:000000000000
+:b8b87fac0b04
+/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 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;
+}
+]
+},
+// excludeReadOnlyFolders
+{
+property: "excludeReadOnlyFolders",
+desc:     "nsINavHistoryQueryOptions.excludeReadOnlyFolders",
+matches:  simplePropertyMatches,
+runs:     [
+function (aQuery, aQueryOptions) {
+aQueryOptions.excludeReadOnlyFolders = 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);
+}