The Tor Browser / file revision

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-

  * vim: sw=2 ts=2 et lcs=trail\:.,tab\:>~ :

  * 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/. */

 /**

  * Bug 499990 - Locale-aware collation

  *

  * Tests our custom, locale-aware collating sequences.

  */

 // The name of the file containing the strings we'll sort during this test.

 // The file's data is taken from intl/locale/tests/sort/us-ascii_base.txt and

 // and intl/locale/tests/sort/us-ascii_sort.txt.

 const DATA_BASENAME = "locale_collation.txt";

 // The test data from DATA_BASENAME is read into this array.

 var gStrings;

 // A collation created from the application's locale.  Used by localeCompare().

 var gLocaleCollation;

 // A connection to our in-memory UTF-16-encoded database.

 var gUtf16Conn;

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

 //// Helper Functions

 /**

  * Since we create a UTF-16 database we have to clean it up, in addition to

  * the normal cleanup of Storage tests.

  */

 function cleanupLocaleTests()

 {

   print("-- Cleaning up test_locale_collation.js suite.");

   gUtf16Conn.close();

   cleanup();

 }

 /**

  * Creates a test database similar to the default one created in

  * head_storage.js, except that this one uses UTF-16 encoding.

  *

  * @return A connection to the database.

  */

 function createUtf16Database()

 {

   print("Creating the in-memory UTF-16-encoded database.");

   let conn = getService().openSpecialDatabase("memory");

   conn.executeSimpleSQL("PRAGMA encoding = 'UTF-16'");

   print("Make sure the encoding was set correctly and is now UTF-16.");

   let stmt = conn.createStatement("PRAGMA encoding");

   do_check_true(stmt.executeStep());

   let enc = stmt.getString(0);

   stmt.finalize();

   // The value returned will actually be UTF-16le or UTF-16be.

   do_check_true(enc === "UTF-16le" || enc === "UTF-16be");

   return conn;

 }

 /**

  * Compares aActual to aExpected, ensuring that the numbers and orderings of

  * the two arrays' elements are the same.

  *

  * @param aActual

  *        An array of strings retrieved from the database.

  * @param aExpected

  *        An array of strings to which aActual should be equivalent.

  */

 function ensureResultsAreCorrect(aActual, aExpected)

 {

   print("Actual results:   " + aActual);

   print("Expected results: " + aExpected);

   do_check_eq(aActual.length, aExpected.length);

   for (let i = 0; i < aActual.length; i++)

     do_check_eq(aActual[i], aExpected[i]);

 }

 /**

  * Synchronously SELECTs all rows from the test table of the given database

  * using the given collation.

  *

  * @param  aCollation

  *         The name of one of our custom locale collations.  The rows are

  *         ordered by this collation.

  * @param  aConn

  *         A connection to either the UTF-8 database or the UTF-16 database.

  * @return The resulting strings in an array.

  */

 function getResults(aCollation, aConn)

 {

   let results = [];

   let stmt = aConn.createStatement("SELECT t FROM test " +

                                    "ORDER BY t COLLATE " + aCollation + " ASC");

   while (stmt.executeStep())

     results.push(stmt.row.t);

   stmt.finalize();

   return results;

 }

 /**

  * Inserts strings into our test table of the given database in the order given.

  *

  * @param aStrings

  *        An array of strings.

  * @param aConn

  *        A connection to either the UTF-8 database or the UTF-16 database.

  */

 function initTableWithStrings(aStrings, aConn)

 {

   print("Initializing test table.");

   aConn.executeSimpleSQL("DROP TABLE IF EXISTS test");

   aConn.createTable("test", "t TEXT");

   let stmt = aConn.createStatement("INSERT INTO test (t) VALUES (:t)");

   aStrings.forEach(function (str) {

     stmt.params.t = str;

     stmt.execute();

     stmt.reset();

   });

   stmt.finalize();

 }

 /**

  * Returns a sorting function suitable for passing to Array.prototype.sort().

  * The returned function uses the application's locale to compare strings.

  *

  * @param  aCollation

  *         The name of one of our custom locale collations.  The sorting

  *         strength is computed from this value.

  * @return A function to use as a sorting callback.

  */

 function localeCompare(aCollation)

 {

   var strength;

   switch (aCollation) {

   case "locale":

     strength = Ci.nsICollation.kCollationCaseInSensitive;

     break;

   case "locale_case_sensitive":

     strength = Ci.nsICollation.kCollationAccentInsenstive;

     break;

   case "locale_accent_sensitive":

     strength = Ci.nsICollation.kCollationCaseInsensitiveAscii;

     break;

   case "locale_case_accent_sensitive":

     strength = Ci.nsICollation.kCollationCaseSensitive;

     break;

   default:

     do_throw("Error in test: unknown collation '" + aCollation + "'");

     break;

   }

   return function (aStr1, aStr2)

          gLocaleCollation.compareString(strength, aStr1, aStr2);

 }

 /**

  * Reads in the test data from the file DATA_BASENAME and returns it as an array

  * of strings.

  *

  * @return The test data as an array of strings.

  */

 function readTestData()

 {

   print("Reading in test data.");

   let file = do_get_file(DATA_BASENAME);

   let istream = Cc["@mozilla.org/network/file-input-stream;1"].

                 createInstance(Ci.nsIFileInputStream);

   istream.init(file, -1, -1, 0);

   istream.QueryInterface(Components.interfaces.nsILineInputStream);

   let line = {};

   let lines = [];

   while (istream.readLine(line))

     lines.push(line.value); 

   istream.close();

   return lines;

 }

 /**

  * Gets the results from the given database using the given collation and

  * ensures that they match gStrings sorted by the same collation.

  *

  * @param aCollation

  *        The name of one of our custom locale collations.  The rows from the

  *        database and the expected results are ordered by this collation.

  * @param aConn

  *        A connection to either the UTF-8 database or the UTF-16 database.

  */

 function runTest(aCollation, aConn)

 {

   ensureResultsAreCorrect(getResults(aCollation, aConn),

                           gStrings.slice(0).sort(localeCompare(aCollation)));

 }

 /**

  * Gets the results from the UTF-8 database using the given collation and

  * ensures that they match gStrings sorted by the same collation.

  *

  * @param aCollation

  *        The name of one of our custom locale collations.  The rows from the

  *        database and the expected results are ordered by this collation.

  */

 function runUtf8Test(aCollation)

 {

   runTest(aCollation, getOpenedDatabase());

 }

 /**

  * Gets the results from the UTF-16 database using the given collation and

  * ensures that they match gStrings sorted by the same collation.

  *

  * @param aCollation

  *        The name of one of our custom locale collations.  The rows from the

  *        database and the expected results are ordered by this collation.

  */

 function runUtf16Test(aCollation)

 {

   runTest(aCollation, gUtf16Conn);

 }

 /**

  * Sets up the test suite.

  */

 function setup()

 {

   print("-- Setting up the test_locale_collation.js suite.");

   gStrings = readTestData();

   initTableWithStrings(gStrings, getOpenedDatabase());

   gUtf16Conn = createUtf16Database();

   initTableWithStrings(gStrings, gUtf16Conn);

   let localeSvc = Cc["@mozilla.org/intl/nslocaleservice;1"].

                   getService(Ci.nsILocaleService);

   let collFact = Cc["@mozilla.org/intl/collation-factory;1"].

                  createInstance(Ci.nsICollationFactory);

   gLocaleCollation = collFact.CreateCollation(localeSvc.getApplicationLocale());

 }

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

 //// Test Runs

 let gTests = [

   {

     desc: "Case and accent sensitive UTF-8",

     run:   function () runUtf8Test("locale_case_accent_sensitive")

   },

   {

     desc: "Case sensitive, accent insensitive UTF-8",

     run:   function () runUtf8Test("locale_case_sensitive")

   },

   {

     desc: "Case insensitive, accent sensitive UTF-8",

     run:   function () runUtf8Test("locale_accent_sensitive")

   },

   {

     desc: "Case and accent insensitive UTF-8",

     run:   function () runUtf8Test("locale")

   },

   {

     desc: "Case and accent sensitive UTF-16",

     run:   function () runUtf16Test("locale_case_accent_sensitive")

   },

   {

     desc: "Case sensitive, accent insensitive UTF-16",

     run:   function () runUtf16Test("locale_case_sensitive")

   },

   {

     desc: "Case insensitive, accent sensitive UTF-16",

     run:   function () runUtf16Test("locale_accent_sensitive")

   },

   {

     desc: "Case and accent insensitive UTF-16",

     run:   function () runUtf16Test("locale")

   },

 ];

 function run_test()

 {

   setup();

   gTests.forEach(function (test) {

     print("-- Running test: " + test.desc);

     test.run();

   });

 }