public void GetDefaultValueTest()
{
if (!TestRegistryKey.IsDefaultValueSet())
{
Assert.Equal(TestData.DefaultValue, TestRegistryKey.GetValue(null, TestData.DefaultValue));
Assert.Equal(TestData.DefaultValue, TestRegistryKey.GetValue(string.Empty, TestData.DefaultValue));
}
Assert.True(TestRegistryKey.SetDefaultValue(TestData.DefaultValue));
Assert.Equal(TestData.DefaultValue, TestRegistryKey.GetValue(null, null));
Assert.Equal(TestData.DefaultValue, TestRegistryKey.GetValue(string.Empty, null));
}
public void TestValueCount2()
{
int expectedCount = 0;
foreach (var testCase in TestData.TestValueTypes)
{
TestRegistryKey.SetValue(testCase[0].ToString(), testCase[1]);
++expectedCount;
}
Assert.Equal(expectedCount, TestRegistryKey.ValueCount);
}
public void SubKeyCountTest()
{
// [] Creating new SubKeys and get count
Assert.Equal(expected: 0, actual: TestRegistryKey.SubKeyCount);
using RegistryKey subkey = TestRegistryKey.CreateSubKey(TestRegistryKeyName);
Assert.NotNull(subkey);
Assert.Equal(expected: 1, actual: TestRegistryKey.SubKeyCount);
TestRegistryKey.DeleteSubKey(TestRegistryKeyName);
Assert.Equal(expected: 0, actual: TestRegistryKey.SubKeyCount);
}
public void NegativeTests()
{
// Should throw if passed subkey name is null
Assert.Throws <ArgumentNullException>(() => TestRegistryKey.CreateSubKey(null, true));
Assert.Throws <ArgumentNullException>(() => TestRegistryKey.CreateSubKey(null, RegistryKeyPermissionCheck.ReadWriteSubTree));
Assert.Throws <ArgumentNullException>(() => TestRegistryKey.CreateSubKey(null, RegistryKeyPermissionCheck.ReadWriteSubTree, new RegistrySecurity()));
Assert.Throws <ArgumentNullException>(() => TestRegistryKey.CreateSubKey(null, RegistryKeyPermissionCheck.ReadWriteSubTree, new RegistryOptions()));
Assert.Throws <ArgumentNullException>(() => TestRegistryKey.CreateSubKey(null, RegistryKeyPermissionCheck.ReadWriteSubTree, new RegistryOptions(), new RegistrySecurity()));
// Should throw if passed option is invalid
Assert.Throws <ArgumentException>(() => TestRegistryKey.CreateSubKey(TestRegistryKeyName, true, options: (RegistryOptions)(-1)));
Assert.Throws <ArgumentException>(() => TestRegistryKey.CreateSubKey(TestRegistryKeyName, true, options: (RegistryOptions)3));
Assert.Throws <ArgumentException>(() => TestRegistryKey.CreateSubKey(TestRegistryKeyName, RegistryKeyPermissionCheck.ReadWriteSubTree, (RegistryOptions)(-1)));
Assert.Throws <ArgumentException>(() => TestRegistryKey.CreateSubKey(TestRegistryKeyName, RegistryKeyPermissionCheck.ReadWriteSubTree, (RegistryOptions)3));
Assert.Throws <ArgumentException>(() => TestRegistryKey.CreateSubKey(TestRegistryKeyName, RegistryKeyPermissionCheck.ReadWriteSubTree, (RegistryOptions)(-1), new RegistrySecurity()));
Assert.Throws <ArgumentException>(() => TestRegistryKey.CreateSubKey(TestRegistryKeyName, RegistryKeyPermissionCheck.ReadWriteSubTree, (RegistryOptions)3, new RegistrySecurity()));
// Should throw if key length above 255 characters
const int maxValueNameLength = 255;
Assert.Throws <ArgumentException>(() => TestRegistryKey.CreateSubKey(new string('a', maxValueNameLength + 1)));
// Should throw if RegistryKey is readonly
const string name = "FooBar";
TestRegistryKey.SetValue(name, 42);
using (var rk = Registry.CurrentUser.CreateSubKey(TestRegistryKeyName, writable: false, options: RegistryOptions.None))
{
Assert.Throws <UnauthorizedAccessException>(() => rk.CreateSubKey(name));
Assert.Throws <UnauthorizedAccessException>(() => rk.SetValue(name, "String"));
Assert.Throws <UnauthorizedAccessException>(() => rk.DeleteValue(name));
Assert.Throws <UnauthorizedAccessException>(() => rk.DeleteSubKey(name));
Assert.Throws <UnauthorizedAccessException>(() => rk.DeleteSubKeyTree(name));
}
using (var rk = Registry.CurrentUser.CreateSubKey(TestRegistryKeyName, RegistryKeyPermissionCheck.ReadSubTree, RegistryOptions.None))
{
Assert.Throws <UnauthorizedAccessException>(() => rk.CreateSubKey(name));
Assert.Throws <UnauthorizedAccessException>(() => rk.SetValue(name, "String"));
Assert.Throws <UnauthorizedAccessException>(() => rk.DeleteValue(name));
Assert.Throws <UnauthorizedAccessException>(() => rk.DeleteSubKey(name));
Assert.Throws <UnauthorizedAccessException>(() => rk.DeleteSubKeyTree(name));
}
// Should throw if RegistryKey closed
Assert.Throws <ObjectDisposedException>(() =>
{
TestRegistryKey.Dispose();
TestRegistryKey.CreateSubKey(TestRegistryKeyName, true);
});
}
public void OpenSubKeyTest()
{
// [] Vanilla; open a subkey in read/write mode and write to it
const string valueName = "FooBar";
const string expectedValue = "BLAH";
using (var rk = TestRegistryKey.OpenSubKey("", RegistryKeyPermissionCheck.ReadWriteSubTree))
{
rk.SetValue(valueName, expectedValue);
Assert.Equal(expectedValue, rk.GetValue(valueName));
rk.CreateSubKey(valueName);
Assert.NotNull(rk.OpenSubKey(valueName));
}
}
public void OpenSubKeyTest()
{
// [] Should have write rights when true is passed
const int testValue = 32;
using (var rk = TestRegistryKey.OpenSubKey("", true))
{
rk.CreateSubKey(TestRegistryKeyName);
rk.SetValue(TestRegistryKeyName, testValue);
Assert.NotNull(rk.OpenSubKey(TestRegistryKeyName));
Assert.Equal(testValue, (int)rk.GetValue(TestRegistryKeyName));
}
}
public void DeleteSubKeyTest2()
{
string[] subKeyNames = Enumerable.Range(1, 9).Select(x => "BLAH_" + x.ToString()).ToArray();
foreach (var subKeyName in subKeyNames)
{
TestRegistryKey.CreateSubKey(subKeyName).Dispose();
}
Assert.Equal(subKeyNames, TestRegistryKey.GetSubKeyNames());
foreach (var subKeyName in subKeyNames)
{
TestRegistryKey.DeleteSubKey(subKeyName);
Assert.Null(TestRegistryKey.OpenSubKey(subKeyName));
}
}
public void NegativeTest_DeeplyNestedKey()
{
// Max number of parts to the registry key path is 509 (failing once it hits 510).
// As TestRegistryKey is already a subkey, that gives us 507 remaining parts before an
// exception is thrown.
const int maxNestedLevel = 507;
string exceedsNestedSubkeyName = string.Join(@"\", Enumerable.Repeat("a", maxNestedLevel));
using (RegistryKey k = TestRegistryKey.CreateSubKey(exceedsNestedSubkeyName))
{
// Verify TestRegistryKey is already nested, with 508 slashes meaning 509 parts
Assert.Equal(maxNestedLevel + 1, k.Name.Count(c => c == '\\'));
}
Assert.Throws <IOException>(() => TestRegistryKey.CreateSubKey(exceedsNestedSubkeyName + @"\" + maxNestedLevel));
}
public void GetValueKindFromReadonlyRegistryKey()
{
// [] RegistryKey is readonly
const string valueName = null;
const long expectedValue = long.MaxValue;
const RegistryValueKind expectedValueKind = RegistryValueKind.QWord;
TestRegistryKey.SetValue(valueName, expectedValue, expectedValueKind);
using (RegistryKey rk = Registry.CurrentUser.OpenSubKey(TestRegistryKeyName, false))
{
Assert.Equal(expectedValue.ToString(), rk.GetValue(valueName).ToString());
Assert.Equal(expectedValueKind, rk.GetValueKind(valueName));
}
}
public void GetStringArrayTest()
{
const string valueName = "StringArr";
string[] expected =
{
"This is a public",
"broadcast intend to test",
"lot of things. one of which"
};
TestRegistryKey.SetValue(valueName, expected);
Assert.Equal(expected, (string[])TestRegistryKey.GetValue(valueName));
TestRegistryKey.DeleteValue(valueName);
}
public void TestGetValueNames()
{
// [] Add several values and get the values then check the names
Assert.Equal(expected: 0, actual: TestRegistryKey.GetValueNames().Length);
string[] expected = { TestRegistryKeyName };
foreach (string valueName in expected)
{
TestRegistryKey.SetValue(valueName, 5);
}
Assert.Equal(expected, TestRegistryKey.GetValueNames());
TestRegistryKey.DeleteValue(TestRegistryKeyName);
Assert.Equal(expected: 0, actual: TestRegistryKey.GetValueNames().Length);
}
public void NegativeTests()
{
// null handle
Assert.Throws <ArgumentNullException>(() => RegistryKey.FromHandle(handle: null, view: RegistryView.Default));
// invalid view
Assert.Throws <ArgumentException>(() => RegistryKey.FromHandle(TestRegistryKey.Handle, (RegistryView)(-1)));
Assert.Throws <ArgumentException>(() => RegistryKey.FromHandle(TestRegistryKey.Handle, (RegistryView)3));
// get handle of disposed RegistryKey
Assert.Throws <ObjectDisposedException>(() =>
{
TestRegistryKey.Dispose();
return(TestRegistryKey.Handle);
});
}
public void SetValueWithMultiString()
{
// This will be written as REG_MULTI_SZ
const string testValueName = "StringArr";
string[] expected =
{
"This is a public",
"broadcast intend to test",
"lot of things. one of which"
};
Registry.SetValue(TestRegistryKey.Name, testValueName, expected);
Assert.Equal(expected, (string[])TestRegistryKey.GetValue(testValueName));
TestRegistryKey.DeleteValue(testValueName);
}
public void SetValueWithBinaryValueKind(int testIndex, object testValue, RegistryValueKind expectedValueKind)
{
try
{
string valueName = "Testing_" + testIndex.ToString();
expectedValueKind = RegistryValueKind.Binary;
TestRegistryKey.SetValue(valueName, testValue, expectedValueKind);
Assert.Equal(testValue.ToString(), TestRegistryKey.GetValue(valueName).ToString());
Assert.Equal(expectedValueKind, TestRegistryKey.GetValueKind(valueName));
TestRegistryKey.DeleteValue(valueName);
}
catch (ArgumentException)
{
Assert.IsNotType <byte[]>(testValue);
}
}
public void SetValueWithEnvironmentVariable(string valueName, string envVariableName, string expectedVariableValue)
{
// ExpandEnvironmentStrings is converting "C:\Program Files (Arm)" to "C:\Program Files (x86)".
if (envVariableName == "ProgramFiles" && PlatformDetection.IsArmProcess)
{
return; // see https://github.com/dotnet/runtime/issues/25778
}
string value = "%" + envVariableName + "%";
Registry.SetValue(TestRegistryKey.Name, valueName, value);
string result = (string)TestRegistryKey.GetValue(valueName);
//we don't expand for the user, REG_SZ_EXPAND not supported
Assert.Equal(expectedVariableValue, Environment.ExpandEnvironmentVariables(result));
TestRegistryKey.DeleteValue(valueName);
}
public void DeleteValueTest2()
{
// [] Vanilla case , add a bunch different objects and then Delete them
object[][] testCases = TestData.TestValueTypes.ToArray();
foreach (var testCase in testCases)
{
TestRegistryKey.SetValue(testCase[0].ToString(), testCase[1]);
}
Assert.Equal(expected: testCases.Length, actual: TestRegistryKey.ValueCount);
foreach (var testCase in testCases)
{
TestRegistryKey.DeleteValue(testCase[0].ToString());
}
Assert.Equal(expected: 0, actual: TestRegistryKey.ValueCount);
}
public void SetValueWithDWordValueKind(int testIndex, object testValue, RegistryValueKind expectedValueKind)
{
try
{
string valueName = "Testing_" + testIndex.ToString();
expectedValueKind = RegistryValueKind.DWord;
TestRegistryKey.SetValue(valueName, testValue, expectedValueKind);
Assert.Equal(Convert.ToInt32(testValue).ToString(), TestRegistryKey.GetValue(valueName).ToString());
Assert.Equal(expectedValueKind, TestRegistryKey.GetValueKind(valueName));
Assert.True(testIndex <= 15);
TestRegistryKey.DeleteValue(valueName);
}
catch (ArgumentException ioe)
{
Assert.False(testIndex <= 15, ioe.ToString());
}
}
public void OpenSubKeyTest()
{
// [] Vanilla; open a subkey in read/write mode and write to it
const string valueName = "FooBar";
const string expectedValue = "BLAH";
using (var rk = TestRegistryKey.OpenSubKey("", RegistryRights.SetValue | RegistryRights.QueryValues))
{
rk.SetValue(valueName, expectedValue);
Assert.Equal(expectedValue, rk.GetValue(valueName));
}
using (var rk = TestRegistryKey.OpenSubKey("", RegistryRights.CreateSubKey))
{
rk.CreateSubKey(valueName);
Assert.NotNull(rk.OpenSubKey(valueName));
}
}
public void SetValueForNonExistingKey()
{
const string valueName = "FooBar";
const int expectedValue1 = int.MaxValue;
const long expectedValue2 = long.MinValue;
const RegistryValueKind expectedValueKind1 = RegistryValueKind.DWord;
const RegistryValueKind expectedValueKind2 = RegistryValueKind.QWord;
Assert.True(TestRegistryKey.GetValue(valueName) == null, "Registry key already exists");
TestRegistryKey.SetValue(valueName, expectedValue1, expectedValueKind1);
Assert.True(TestRegistryKey.GetValue(valueName) != null, "Registry key doesn't exists");
Assert.Equal(expectedValue1, (int)TestRegistryKey.GetValue(valueName));
Assert.Equal(expectedValueKind1, TestRegistryKey.GetValueKind(valueName));
TestRegistryKey.SetValue(valueName, expectedValue2, expectedValueKind2);
Assert.Equal(expectedValue2, (long)TestRegistryKey.GetValue(valueName));
Assert.Equal(expectedValueKind2, TestRegistryKey.GetValueKind(valueName));
}
public void NegativeTests()
{
// Should throw if passed subkey name is null
Assert.Throws <ArgumentNullException>(() => TestRegistryKey.CreateSubKey(null));
// Should throw if key length above 255 characters
const int maxValueNameLength = 255;
Assert.Throws <ArgumentException>(() => TestRegistryKey.CreateSubKey(new string('a', maxValueNameLength + 1)));
// Max number of parts to the registry key path is 509 (failing once it hits 510).
// As TestRegistryKey is already a subkey, that gives us 507 remaining parts before an
// exception is thrown.
const int maxNestedLevel = 507;
string exceedsNestedSubkeyName = string.Join(@"\", Enumerable.Repeat("a", maxNestedLevel));
using (RegistryKey k = TestRegistryKey.CreateSubKey(exceedsNestedSubkeyName))
{
// Verify TestRegistryKey is already nested, with 508 slashes meaning 509 parts
Assert.Equal(maxNestedLevel + 1, k.Name.Count(c => c == '\\'));
}
Assert.Throws <IOException>(() => TestRegistryKey.CreateSubKey(exceedsNestedSubkeyName + @"\" + maxNestedLevel));
// Should throw if RegistryKey is readonly
const string name = "FooBar";
TestRegistryKey.SetValue(name, 42);
using (var rk = Registry.CurrentUser.CreateSubKey(TestRegistryKeyName, writable: false))
{
Assert.Throws <UnauthorizedAccessException>(() => rk.CreateSubKey(name));
Assert.Throws <UnauthorizedAccessException>(() => rk.SetValue(name, "String"));
Assert.Throws <UnauthorizedAccessException>(() => rk.DeleteValue(name));
Assert.Throws <UnauthorizedAccessException>(() => rk.DeleteSubKey(name));
Assert.Throws <UnauthorizedAccessException>(() => rk.DeleteSubKeyTree(name));
}
// Should throw if RegistryKey closed
Assert.Throws <ObjectDisposedException>(() =>
{
TestRegistryKey.Dispose();
TestRegistryKey.CreateSubKey(TestRegistryKeyName);
});
}
public void DeleteSubKeyTreeTest2()
{
// [] Add in multiple subkeys and then delete the root key
string[] subKeyNames = Enumerable.Range(1, 9).Select(x => "BLAH_" + x.ToString()).ToArray();
using (var rk = TestRegistryKey.CreateSubKey(TestRegistryKeyName))
{
foreach (var subKeyName in subKeyNames)
{
var rk2 = rk.CreateSubKey(subKeyName);
Assert.NotNull(rk2);
Assert.NotNull(rk2.CreateSubKey("Test"));
}
Assert.Equal(subKeyNames, rk.GetSubKeyNames());
}
TestRegistryKey.DeleteSubKeyTree(TestRegistryKeyName);
Assert.Null(TestRegistryKey.OpenSubKey(TestRegistryKeyName));
}
public void SubkeyExistsTests()
{
const string subKeyExists = "SubkeyExists";
const string subKeyExists2 = "SubkeyExists2";
//throwOnMissing is true with subkey present
using (var rk = TestRegistryKey.CreateSubKey(subKeyExists))
{
rk.CreateSubKey("a");
rk.CreateSubKey("b");
TestRegistryKey.DeleteSubKeyTree(subKeyExists, false);
}
//throwOnMissing is false with subkey present
using (var rk = TestRegistryKey.CreateSubKey(subKeyExists2))
{
rk.CreateSubKey("a");
rk.CreateSubKey("b");
TestRegistryKey.DeleteSubKeyTree(subKeyExists2, true);
}
}
public void NegativeTests()
{
// Should throw if passed subkey name is null
Assert.Throws <ArgumentNullException>(() => TestRegistryKey.CreateSubKey(null, true));
// Should throw if passed option is invalid
Assert.Throws <ArgumentException>(() => TestRegistryKey.CreateSubKey(TestRegistryKeyName, true, options: (RegistryOptions)(-1)));
Assert.Throws <ArgumentException>(() => TestRegistryKey.CreateSubKey(TestRegistryKeyName, true, options: (RegistryOptions)3));
// Should throw if key length above 255 characters
const int maxValueNameLength = 255;
Assert.Throws <ArgumentException>(() => TestRegistryKey.CreateSubKey(new string('a', maxValueNameLength + 1)));
//According to msdn documentation max nesting level exceeds is 510 but actual is 508
const int maxNestedLevel = 508;
string exceedsNestedSubkeyName = string.Join(@"\", Enumerable.Repeat("a", maxNestedLevel));
Assert.Throws <IOException>(() => TestRegistryKey.CreateSubKey(exceedsNestedSubkeyName, true));
// Should throw if RegistryKey is readonly
const string name = "FooBar";
TestRegistryKey.SetValue(name, 42);
using (var rk = Registry.CurrentUser.CreateSubKey(TestRegistryKeyName, writable: false, options: RegistryOptions.None))
{
Assert.Throws <UnauthorizedAccessException>(() => rk.CreateSubKey(name));
Assert.Throws <UnauthorizedAccessException>(() => rk.SetValue(name, "String"));
Assert.Throws <UnauthorizedAccessException>(() => rk.DeleteValue(name));
Assert.Throws <UnauthorizedAccessException>(() => rk.DeleteSubKey(name));
Assert.Throws <UnauthorizedAccessException>(() => rk.DeleteSubKeyTree(name));
}
// Should throw if RegistryKey closed
Assert.Throws <ObjectDisposedException>(() =>
{
TestRegistryKey.Dispose();
TestRegistryKey.CreateSubKey(TestRegistryKeyName, true);
});
}
public void NegativeTests()
{
// Should throw if key length above 255 characters but prior to V4 the limit is 16383
const int maxValueNameLength = 16383;
string tooLongValueName = new string('a', maxValueNameLength + 1);
AssertExtensions.Throws <ArgumentException>("name", null, () => TestRegistryKey.SetValue(tooLongValueName, ulong.MaxValue, RegistryValueKind.String));
const string valueName = "FooBar";
// Should throw if passed value is null
Assert.Throws <ArgumentNullException>(() => TestRegistryKey.SetValue(valueName, null, RegistryValueKind.QWord));
// Should throw because valueKind is equal to -2 which is not an acceptable value
AssertExtensions.Throws <ArgumentException>("valueKind", () => TestRegistryKey.SetValue(valueName, int.MinValue, (RegistryValueKind)(-2)));
// Should throw because passed array contains null
string[] strArr = { "one", "two", null, "three" };
AssertExtensions.Throws <ArgumentException>(null, () => TestRegistryKey.SetValue(valueName, strArr, RegistryValueKind.MultiString));
// Should throw because passed array has wrong type
AssertExtensions.Throws <ArgumentException>(null, () => TestRegistryKey.SetValue(valueName, new[] { new object() }, RegistryValueKind.MultiString));
// Should throw because passed array has wrong type
object[] objTemp = { "my string", "your string", "Any once string" };
AssertExtensions.Throws <ArgumentException>(null, () => TestRegistryKey.SetValue(valueName, objTemp, RegistryValueKind.Unknown));
// Should throw because RegistryKey is readonly
using (var rk = Registry.CurrentUser.OpenSubKey(TestRegistryKeyName, false))
{
Assert.Throws <UnauthorizedAccessException>(() => rk.SetValue(valueName, int.MaxValue, RegistryValueKind.DWord));
}
// Should throw if RegistryKey is closed
Assert.Throws <ObjectDisposedException>(() =>
{
TestRegistryKey.Dispose();
TestRegistryKey.SetValue(valueName, int.MinValue, RegistryValueKind.DWord);
});
}
public void CreateWriteableSubkeyAndWrite()
{
// [] Vanilla; create a new subkey in read/write mode and write to it
const string testValueName = "TestValue";
const string testStringValueName = "TestString";
const string testStringValue = "Hello World!\u2020\u00FE";
const int testValue = 42;
using (var rk = TestRegistryKey.CreateSubKey(TestRegistryKeyName, writable: true))
{
Assert.NotNull(rk);
rk.SetValue(testValueName, testValue);
Assert.Equal(1, rk.ValueCount);
rk.SetValue(testStringValueName, testStringValue);
Assert.Equal(2, rk.ValueCount);
Assert.Equal(testValue, rk.GetValue(testValueName));
Assert.Equal(testStringValue, rk.GetValue(testStringValueName).ToString());
}
}
public void CreateReadWritePermissionCheckSubKeyAndWrite()
{
// [] Vanilla; create a new subkey in read/write mode and write to it
const string testValueName = "TestValue";
const string testStringValueName = "TestString";
const string testStringValue = "Hello World!†þ";
const int testValue = 42;
using (var rk = TestRegistryKey.CreateSubKey(TestRegistryKeyName, RegistryKeyPermissionCheck.ReadWriteSubTree))
{
Assert.NotNull(rk);
rk.SetValue(testValueName, testValue);
Assert.Equal(1, rk.ValueCount);
rk.SetValue(testStringValueName, testStringValue);
Assert.Equal(2, rk.ValueCount);
Assert.Equal(testValue, rk.GetValue(testValueName));
Assert.Equal(testStringValue, rk.GetValue(testStringValueName).ToString());
}
}
public void NegativeTests()
{
// Should throw if passed subkey name is null
Assert.Throws <ArgumentNullException>(() => TestRegistryKey.OpenSubKey(name: null, permissionCheck: RegistryKeyPermissionCheck.ReadSubTree));
// Should throw if subkey name greater than 255 chars
AssertExtensions.Throws <ArgumentException>("name", null, () => TestRegistryKey.OpenSubKey(new string('a', 256), RegistryKeyPermissionCheck.Default));
// Should throw when opened with default permission check
const string name = "FooBar";
TestRegistryKey.SetValue(name, 42);
TestRegistryKey.CreateSubKey(name).Dispose();
using (var rk = Registry.CurrentUser.OpenSubKey(name: TestRegistryKeyName, permissionCheck: RegistryKeyPermissionCheck.Default))
{
Assert.Throws <UnauthorizedAccessException>(() => rk.CreateSubKey(name));
Assert.Throws <UnauthorizedAccessException>(() => rk.SetValue(name, "String"));
Assert.Throws <UnauthorizedAccessException>(() => rk.DeleteValue(name));
Assert.Throws <UnauthorizedAccessException>(() => rk.DeleteSubKey(name));
Assert.Throws <UnauthorizedAccessException>(() => rk.DeleteSubKeyTree(name));
}
// Should throw when opened with read permission check
using (var rk = Registry.CurrentUser.OpenSubKey(name: TestRegistryKeyName, permissionCheck: RegistryKeyPermissionCheck.ReadSubTree))
{
Assert.Throws <UnauthorizedAccessException>(() => rk.CreateSubKey(name));
Assert.Throws <UnauthorizedAccessException>(() => rk.SetValue(name, "String"));
Assert.Throws <UnauthorizedAccessException>(() => rk.DeleteValue(name));
Assert.Throws <UnauthorizedAccessException>(() => rk.DeleteSubKey(name));
Assert.Throws <UnauthorizedAccessException>(() => rk.DeleteSubKeyTree(name));
}
// Should throw if RegistryKey closed
Assert.Throws <ObjectDisposedException>(() =>
{
TestRegistryKey.Dispose();
TestRegistryKey.OpenSubKey(TestRegistryKeyName, RegistryKeyPermissionCheck.Default);
});
}
public void TestDeletedRegistryKey()
{
const string subKeyName = "TestKeyThatWillBeDeleted";
//Try getting registrykey from handle for key that has been deleted.
Assert.Throws <IOException>(() =>
{
RegistryKey rk = TestRegistryKey.CreateSubKey(subKeyName);
SafeRegistryHandle handle = rk.Handle;
TestRegistryKey.DeleteSubKey(subKeyName);
rk = RegistryKey.FromHandle(handle, RegistryView.Default);
rk.CreateSubKey("TestThrows");
});
//Try getting handle on deleted key.
Assert.Throws <IOException>(() =>
{
RegistryKey rk = TestRegistryKey.CreateSubKey(subKeyName);
TestRegistryKey.DeleteSubKey(subKeyName);
SafeRegistryHandle handle = rk.Handle;
rk = RegistryKey.FromHandle(handle, RegistryView.Default);
rk.CreateSubKey("TestThrows");
});
}
public void NegativeTests()
{
// Should throw if passed value is null
Assert.Throws <ArgumentNullException>(() => TestRegistryKey.SetValue("test", null));
// Should throw if key length above 255 characters but prior to V4, the limit is 16383
const int maxValueNameLength = 16383;
AssertExtensions.Throws <ArgumentException>("name", null, () => TestRegistryKey.SetValue(new string('a', maxValueNameLength + 1), 5));
// Should throw if passed value is array with uninitialized elements
AssertExtensions.Throws <ArgumentException>(null, () => TestRegistryKey.SetValue("StringArr", value: new string[1]));
// Should throw because only String[] (REG_MULTI_SZ) and byte[] (REG_BINARY) are supported.
// RegistryKey.SetValue does not support arrays of type UInt32[].
AssertExtensions.Throws <ArgumentException>(null, () => TestRegistryKey.SetValue("IntArray", value: new[] { 1, 2, 3 }));
// Should throw if RegistryKey closed
Assert.Throws <ObjectDisposedException>(() =>
{
TestRegistryKey.Dispose();
TestRegistryKey.SetValue("TestValue", 42);
});
}
public void RegSzOddByteLength(RegistryValueKind kind, byte[] contents)
{
const string TestValueName = "CorruptData2";
SafeRegistryHandle handle = TestRegistryKey.Handle;
int ret = Interop.mincore.RegSetValueEx(handle, TestValueName, 0,
kind, contents, contents.Length);
Assert.Equal(0, ret);
try
{
object o = TestRegistryKey.GetValue(TestValueName);
string s;
if (kind == RegistryValueKind.MultiString)
{
Assert.IsType <string[]>(o);
var strings = (string[])o;
Assert.Equal(1, strings.Length);
s = strings[0];
}
else
{
Assert.IsType <string>(o);
s = (string)o;
}
Assert.Equal(2, s.Length);
Assert.Equal(0x506, s[0]);
Assert.Equal(0x6, s[1]);
}
finally
{
TestRegistryKey.DeleteValue(TestValueName);
}
}
