Adding upstream version 110.0.1.upstream/110.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 237 insertions, 0 deletions

diff --git a/xpcom/tests/unit/test_windows_registry.js b/xpcom/tests/unit/test_windows_registry.js
new file mode 100644
index 0000000000..6b89f55502
--- /dev/null
+++ b/xpcom/tests/unit/test_windows_registry.js
@@ -0,0 +1,237 @@
+/* -*- 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/. */
+
+const nsIWindowsRegKey = Ci.nsIWindowsRegKey;
+let regKeyComponent = Cc["@mozilla.org/windows-registry-key;1"];
+
+function run_test() {
+  //* create a key structure in a spot that's normally writable (somewhere under HKCU).
+  let testKey = regKeyComponent.createInstance(nsIWindowsRegKey);
+
+  // If it's already present because a previous test crashed or didn't clean up properly, clean it up first.
+  let keyName = BASE_PATH + "\\" + TESTDATA_KEYNAME;
+  setup_test_run(testKey, keyName);
+
+  //* test that the write* functions write stuff
+  test_writing_functions(testKey);
+
+  //* check that the valueCount/getValueName functions work for the values we just wrote
+  test_value_functions(testKey);
+
+  //* check that the get* functions work for the values we just wrote.
+  test_reading_functions(testKey);
+
+  //* check that the get* functions fail with the right exception codes if we ask for the wrong type or if the value name doesn't exist at all
+  test_invalidread_functions(testKey);
+
+  //* check that creating/enumerating/deleting child keys works
+  test_childkey_functions(testKey);
+
+  test_watching_functions(testKey);
+
+  //* clean up
+  cleanup_test_run(testKey, keyName);
+}
+
+function setup_test_run(testKey, keyName) {
+  info("Setup test run");
+  try {
+    testKey.open(
+      nsIWindowsRegKey.ROOT_KEY_CURRENT_USER,
+      keyName,
+      nsIWindowsRegKey.ACCESS_READ
+    );
+    info("Test key exists. Needs cleanup.");
+    cleanup_test_run(testKey, keyName);
+  } catch (e) {
+    if (!(e instanceof Ci.nsIException && e.result == Cr.NS_ERROR_FAILURE)) {
+      throw e;
+    }
+  }
+
+  testKey.create(
+    nsIWindowsRegKey.ROOT_KEY_CURRENT_USER,
+    keyName,
+    nsIWindowsRegKey.ACCESS_ALL
+  );
+}
+
+function test_writing_functions(testKey) {
+  strictEqual(testKey.valueCount, 0);
+
+  strictEqual(testKey.hasValue(TESTDATA_STRNAME), false);
+  testKey.writeStringValue(TESTDATA_STRNAME, TESTDATA_STRVALUE);
+  strictEqual(testKey.hasValue(TESTDATA_STRNAME), true);
+
+  strictEqual(testKey.hasValue(TESTDATA_INTNAME), false);
+  testKey.writeIntValue(TESTDATA_INTNAME, TESTDATA_INTVALUE);
+
+  strictEqual(testKey.hasValue(TESTDATA_INT64NAME), false);
+  testKey.writeInt64Value(TESTDATA_INT64NAME, TESTDATA_INT64VALUE);
+
+  strictEqual(testKey.hasValue(TESTDATA_BINARYNAME), false);
+  testKey.writeBinaryValue(TESTDATA_BINARYNAME, TESTDATA_BINARYVALUE);
+}
+
+function test_value_functions(testKey) {
+  strictEqual(testKey.valueCount, 4);
+  strictEqual(testKey.getValueName(0), TESTDATA_STRNAME);
+  strictEqual(testKey.getValueName(1), TESTDATA_INTNAME);
+  strictEqual(testKey.getValueName(2), TESTDATA_INT64NAME);
+  strictEqual(testKey.getValueName(3), TESTDATA_BINARYNAME);
+}
+
+function test_reading_functions(testKey) {
+  strictEqual(
+    testKey.getValueType(TESTDATA_STRNAME),
+    nsIWindowsRegKey.TYPE_STRING
+  );
+  strictEqual(testKey.readStringValue(TESTDATA_STRNAME), TESTDATA_STRVALUE);
+
+  strictEqual(
+    testKey.getValueType(TESTDATA_INTNAME),
+    nsIWindowsRegKey.TYPE_INT
+  );
+  strictEqual(testKey.readIntValue(TESTDATA_INTNAME), TESTDATA_INTVALUE);
+
+  strictEqual(
+    testKey.getValueType(TESTDATA_INT64NAME),
+    nsIWindowsRegKey.TYPE_INT64
+  );
+  strictEqual(testKey.readInt64Value(TESTDATA_INT64NAME), TESTDATA_INT64VALUE);
+
+  strictEqual(
+    testKey.getValueType(TESTDATA_BINARYNAME),
+    nsIWindowsRegKey.TYPE_BINARY
+  );
+  strictEqual(
+    testKey.readBinaryValue(TESTDATA_BINARYNAME),
+    TESTDATA_BINARYVALUE
+  );
+}
+
+function test_invalidread_functions(testKey) {
+  try {
+    testKey.readIntValue(TESTDATA_STRNAME);
+    do_throw("Reading an integer from a string registry value should throw.");
+  } catch (e) {
+    if (!(e instanceof Ci.nsIException && e.result == Cr.NS_ERROR_FAILURE)) {
+      throw e;
+    }
+  }
+
+  try {
+    let val = testKey.readStringValue(TESTDATA_INTNAME);
+    do_throw(
+      "Reading an string from an Int registry value should throw." + val
+    );
+  } catch (e) {
+    if (!(e instanceof Ci.nsIException && e.result == Cr.NS_ERROR_FAILURE)) {
+      throw e;
+    }
+  }
+
+  try {
+    testKey.readStringValue(TESTDATA_INT64NAME);
+    do_throw("Reading an string from an Int64 registry value should throw.");
+  } catch (e) {
+    if (!(e instanceof Ci.nsIException && e.result == Cr.NS_ERROR_FAILURE)) {
+      throw e;
+    }
+  }
+
+  try {
+    testKey.readStringValue(TESTDATA_BINARYNAME);
+    do_throw("Reading a string from an Binary registry value should throw.");
+  } catch (e) {
+    if (!(e instanceof Ci.nsIException && e.result == Cr.NS_ERROR_FAILURE)) {
+      throw e;
+    }
+  }
+}
+
+function test_childkey_functions(testKey) {
+  strictEqual(testKey.childCount, 0);
+  strictEqual(testKey.hasChild(TESTDATA_CHILD_KEY), false);
+
+  let childKey = testKey.createChild(
+    TESTDATA_CHILD_KEY,
+    nsIWindowsRegKey.ACCESS_ALL
+  );
+  childKey.close();
+
+  strictEqual(testKey.childCount, 1);
+  strictEqual(testKey.hasChild(TESTDATA_CHILD_KEY), true);
+  strictEqual(testKey.getChildName(0), TESTDATA_CHILD_KEY);
+
+  childKey = testKey.openChild(TESTDATA_CHILD_KEY, nsIWindowsRegKey.ACCESS_ALL);
+  testKey.removeChild(TESTDATA_CHILD_KEY);
+  strictEqual(testKey.childCount, 0);
+  strictEqual(testKey.hasChild(TESTDATA_CHILD_KEY), false);
+}
+
+function test_watching_functions(testKey) {
+  strictEqual(testKey.isWatching(), false);
+  strictEqual(testKey.hasChanged(), false);
+
+  testKey.startWatching(true);
+  strictEqual(testKey.isWatching(), true);
+
+  testKey.stopWatching();
+  strictEqual(testKey.isWatching(), false);
+
+  // Create a child key, and update a value
+  let childKey = testKey.createChild(
+    TESTDATA_CHILD_KEY,
+    nsIWindowsRegKey.ACCESS_ALL
+  );
+  childKey.writeIntValue(TESTDATA_INTNAME, TESTDATA_INTVALUE);
+
+  // Start a recursive watch, and update the child's value
+  testKey.startWatching(true);
+  strictEqual(testKey.isWatching(), true);
+
+  childKey.writeIntValue(TESTDATA_INTNAME, 0);
+  strictEqual(testKey.hasChanged(), true);
+  testKey.stopWatching();
+  strictEqual(testKey.isWatching(), false);
+
+  childKey.removeValue(TESTDATA_INTNAME);
+  childKey.close();
+  testKey.removeChild(TESTDATA_CHILD_KEY);
+}
+
+function cleanup_test_run(testKey, keyName) {
+  info("Cleaning up test.");
+
+  for (var i = 0; i < testKey.childCount; i++) {
+    testKey.removeChild(testKey.getChildName(i));
+  }
+  testKey.close();
+
+  let baseKey = regKeyComponent.createInstance(nsIWindowsRegKey);
+  baseKey.open(
+    nsIWindowsRegKey.ROOT_KEY_CURRENT_USER,
+    BASE_PATH,
+    nsIWindowsRegKey.ACCESS_ALL
+  );
+  baseKey.removeChild(TESTDATA_KEYNAME);
+  baseKey.close();
+}
+
+// Test data used above.
+const BASE_PATH = "SOFTWARE";
+const TESTDATA_KEYNAME = "TestRegXPC";
+const TESTDATA_STRNAME = "AString";
+const TESTDATA_STRVALUE = "The quick brown fox jumps over the lazy dog.";
+const TESTDATA_INTNAME = "AnInteger";
+const TESTDATA_INTVALUE = 65536;
+const TESTDATA_INT64NAME = "AnInt64";
+const TESTDATA_INT64VALUE = 9223372036854775000;
+const TESTDATA_BINARYNAME = "ABinary";
+const TESTDATA_BINARYVALUE = "She sells seashells by the seashore";
+const TESTDATA_CHILD_KEY = "TestChildKey";