Fix undisposed RegistryKeys in Microsoft.Win32.Registry tests (#72117)

diff --git a/src/libraries/Microsoft.Win32.Registry/tests/Helpers.cs b/src/libraries/Microsoft.Win32.Registry/tests/Helpers.cs
index 2eb0534..fb51c8c 100644 (file)
--- a/src/libraries/Microsoft.Win32.Registry/tests/Helpers.cs
+++ b/src/libraries/Microsoft.Win32.Registry/tests/Helpers.cs
@@ -29,6 +29,16 @@ namespace Microsoft.Win32.RegistryTests
             return RegQueryValueEx(key.Handle, null, null, IntPtr.Zero, b, ref size) != ERROR_FILE_NOT_FOUND;
         }
 
+        internal static bool IsSystemKeyDefaultValueSet(this RegistryKey key)
+        {
+            const int ERROR_FILE_NOT_FOUND = 2;
+            byte[] b = new byte[4];
+            int size = 4;
+
+            using SafeRegistryHandle handle = key.Handle;
+            return RegQueryValueEx(handle, null, null, IntPtr.Zero, b, ref size) != ERROR_FILE_NOT_FOUND;
+        }
+
         [LibraryImport(Interop.Libraries.Kernel32, EntryPoint = "SetEnvironmentVariableW", SetLastError = true, StringMarshalling = StringMarshalling.Utf16)]
         [return: MarshalAs(UnmanagedType.Bool)]
         internal static partial bool SetEnvironmentVariable(string lpName, string lpValue);

diff --git a/src/libraries/Microsoft.Win32.Registry/tests/Registry/Registry_Getvalue_str_str_obj.cs b/src/libraries/Microsoft.Win32.Registry/tests/Registry/Registry_Getvalue_str_str_obj.cs
index 26df786..39200cf 100644 (file)
--- a/src/libraries/Microsoft.Win32.Registry/tests/Registry/Registry_Getvalue_str_str_obj.cs
+++ b/src/libraries/Microsoft.Win32.Registry/tests/Registry/Registry_Getvalue_str_str_obj.cs
@@ -114,7 +114,7 @@ namespace Microsoft.Win32.RegistryTests
             {
                 // keyName should be case insensitive so we mix casing
                 string keyName = MixUpperAndLowerCase(key.Name) + (useSeparator ? "\\" : "");
-                if (key.IsDefaultValueSet())
+                if (key.IsSystemKeyDefaultValueSet())
                 {
                     Registry.GetValue(keyName, valueName, null);
                 }

diff --git a/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_CreateSubKey_str.cs b/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_CreateSubKey_str.cs
index c87e7bf..a98d6a8 100644 (file)
--- a/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_CreateSubKey_str.cs
+++ b/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_CreateSubKey_str.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using Xunit;
@@ -44,7 +45,7 @@ namespace Microsoft.Win32.RegistryTests
         public void CreateSubkeyWithEmptyName()
         {
             string expectedName = TestRegistryKey.Name + @"\";
-            var rk = TestRegistryKey.CreateSubKey(string.Empty);
+            using RegistryKey rk = TestRegistryKey.CreateSubKey(string.Empty);
             Assert.NotNull(rk);
             Assert.Equal(expectedName, rk.Name);
         }
@@ -52,8 +53,12 @@ namespace Microsoft.Win32.RegistryTests
         [Fact]
         public void CreateSubKeyAndCheckThatItExists()
         {
-            TestRegistryKey.CreateSubKey(TestRegistryKeyName);
-            Assert.NotNull(TestRegistryKey.OpenSubKey(TestRegistryKeyName));
+            using RegistryKey created = TestRegistryKey.CreateSubKey(TestRegistryKeyName);
+            Assert.NotNull(created);
+
+            using RegistryKey opened = TestRegistryKey.OpenSubKey(TestRegistryKeyName);
+            Assert.NotNull(opened);
+
             Assert.Equal(expected: 1, actual:TestRegistryKey.SubKeyCount);
         }
 
@@ -61,9 +66,14 @@ namespace Microsoft.Win32.RegistryTests
         public void CreateSubKeyShouldOpenExisting()
         {
             // CreateSubKey should open subkey if it already exists
-            Assert.NotNull(TestRegistryKey.CreateSubKey(TestRegistryKeyName));
-            Assert.NotNull(TestRegistryKey.OpenSubKey(TestRegistryKeyName));
-            Assert.NotNull(TestRegistryKey.CreateSubKey(TestRegistryKeyName));
+            using RegistryKey subkey1 = TestRegistryKey.CreateSubKey(TestRegistryKeyName);
+            Assert.NotNull(subkey1);
+
+            using RegistryKey subkey2 = TestRegistryKey.OpenSubKey(TestRegistryKeyName);
+            Assert.NotNull(subkey2);
+
+            using RegistryKey subkey3 = TestRegistryKey.CreateSubKey(TestRegistryKeyName);
+            Assert.NotNull(subkey3);
         }
 
         [Theory]
@@ -72,8 +82,11 @@ namespace Microsoft.Win32.RegistryTests
         [InlineData(@"a\b\c\/d\//e\f\g\h\//\\")]
         public void CreateSubKeyWithName(string subkeyName)
         {
-            TestRegistryKey.CreateSubKey(subkeyName);
-            Assert.NotNull(TestRegistryKey.OpenSubKey(subkeyName));
+            using RegistryKey created = TestRegistryKey.CreateSubKey(subkeyName);
+            Assert.NotNull(created);
+
+            using RegistryKey opened = TestRegistryKey.OpenSubKey(subkeyName);
+            Assert.NotNull(opened);
         }
 
         [Fact]
@@ -89,17 +102,25 @@ namespace Microsoft.Win32.RegistryTests
             for (int i = 0; i < 25 && subkeyName.Length < 230; i++)
                 subkeyName = subkeyName + i.ToString() + @"\";
 
-            TestRegistryKey.CreateSubKey(subkeyName);
-            Assert.NotNull(TestRegistryKey.OpenSubKey(subkeyName));
+            using RegistryKey created = TestRegistryKey.CreateSubKey(subkeyName);
+            Assert.NotNull(created);
+
+            using RegistryKey opened = TestRegistryKey.OpenSubKey(subkeyName);
+            Assert.NotNull(opened);
 
             //However, we are interested in ensuring that there are no buffer overflow issues with a deeply nested keys
+            var keys = new List<RegistryKey>();
             RegistryKey rk = TestRegistryKey;
             for (int i = 0; i < 3; i++)
             {
                 rk = rk.OpenSubKey(subkeyName, true);
                 Assert.NotNull(rk);
-                rk.CreateSubKey(subkeyName);
+                keys.Add(rk);
+
+                keys.Add(rk.CreateSubKey(subkeyName));
             }
+
+            keys.ForEach(key => key.Dispose());
         }
 
         [Theory]

diff --git a/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_CreateSubKey_str_rkpc.cs b/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_CreateSubKey_str_rkpc.cs
index 4ffc4e7..27cb48e 100644 (file)
--- a/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_CreateSubKey_str_rkpc.cs
+++ b/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_CreateSubKey_str_rkpc.cs
@@ -145,10 +145,11 @@ namespace Microsoft.Win32.RegistryTests
 
             if (alreadyExists)
             {
-                TestRegistryKey.CreateSubKey(subkey, true, options);
+                TestRegistryKey.CreateSubKey(subkey, true, options).Dispose();
             }
 
-            Assert.NotNull(TestRegistryKey.CreateSubKey(subkey, true, options));
+            using RegistryKey created = TestRegistryKey.CreateSubKey(subkey, true, options);
+            Assert.NotNull(created);
         }
 
         [Theory]
@@ -162,10 +163,11 @@ namespace Microsoft.Win32.RegistryTests
 
             if (alreadyExists)
             {
-                TestRegistryKey.CreateSubKey(subkey, RegistryKeyPermissionCheck.ReadWriteSubTree, options);
+                TestRegistryKey.CreateSubKey(subkey, RegistryKeyPermissionCheck.ReadWriteSubTree, options).Dispose();
             }
 
-            Assert.NotNull(TestRegistryKey.CreateSubKey(subkey, RegistryKeyPermissionCheck.ReadWriteSubTree, options));
+            using RegistryKey created = TestRegistryKey.CreateSubKey(subkey, RegistryKeyPermissionCheck.ReadWriteSubTree, options);
+            Assert.NotNull(created);
         }
 
         [Theory]

diff --git a/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_DeleteSubKeyTree.cs b/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_DeleteSubKeyTree.cs
index aaa8f26..79278cc 100644 (file)
--- a/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_DeleteSubKeyTree.cs
+++ b/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_DeleteSubKeyTree.cs
@@ -54,15 +54,15 @@ namespace Microsoft.Win32.RegistryTests
             //throwOnMissing is true with subkey present
             using (var rk = TestRegistryKey.CreateSubKey(subKeyExists))
             {
-                rk.CreateSubKey("a");
-                rk.CreateSubKey("b");
+                using RegistryKey a = rk.CreateSubKey("a");
+                using RegistryKey b = 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");
+                using RegistryKey a = rk.CreateSubKey("a");
+                using RegistryKey b = rk.CreateSubKey("b");
                 TestRegistryKey.DeleteSubKeyTree(subKeyExists2, true);
             }
         }

diff --git a/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_DeleteSubKeyTree_str.cs b/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_DeleteSubKeyTree_str.cs
index b7016bb..c8606e1 100644 (file)
--- a/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_DeleteSubKeyTree_str.cs
+++ b/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_DeleteSubKeyTree_str.cs
@@ -43,7 +43,7 @@ namespace Microsoft.Win32.RegistryTests
         {
             using (var rk = TestRegistryKey.CreateSubKey(TestRegistryKeyName))
             {
-                rk.CreateSubKey(TestRegistryKeyName);
+                using RegistryKey created = rk.CreateSubKey(TestRegistryKeyName);
                 rk.DeleteSubKeyTree("");
             }
 
@@ -54,8 +54,9 @@ namespace Microsoft.Win32.RegistryTests
         public void DeleteSubKeyTreeTest()
         {
             // Creating new SubKey and deleting it
-            TestRegistryKey.CreateSubKey(TestRegistryKeyName);
-            Assert.NotNull(TestRegistryKey.OpenSubKey(TestRegistryKeyName));
+            using RegistryKey created = TestRegistryKey.CreateSubKey(TestRegistryKeyName);
+            using RegistryKey opened = TestRegistryKey.OpenSubKey(TestRegistryKeyName);
+            Assert.NotNull(opened);
 
             TestRegistryKey.DeleteSubKeyTree(TestRegistryKeyName);
             Assert.Null(TestRegistryKey.OpenSubKey(TestRegistryKeyName));
@@ -67,13 +68,15 @@ namespace Microsoft.Win32.RegistryTests
             // [] 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))
+            using (RegistryKey rk = TestRegistryKey.CreateSubKey(TestRegistryKeyName))
             {
                 foreach (var subKeyName in subKeyNames)
                 {
-                    var rk2 = rk.CreateSubKey(subKeyName);
+                    using RegistryKey rk2 = rk.CreateSubKey(subKeyName);
                     Assert.NotNull(rk2);
-                    Assert.NotNull(rk2.CreateSubKey("Test"));
+
+                    using RegistryKey rk3 = rk2.CreateSubKey("Test");
+                    Assert.NotNull(rk3);
                 }
 
                 Assert.Equal(subKeyNames, rk.GetSubKeyNames());

diff --git a/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_DeleteSubKey_Str_Bln.cs b/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_DeleteSubKey_Str_Bln.cs
index 2d2a375..d985200 100644 (file)
--- a/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_DeleteSubKey_Str_Bln.cs
+++ b/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_DeleteSubKey_Str_Bln.cs
@@ -24,7 +24,7 @@ namespace Microsoft.Win32.RegistryTests
             // Should throw if subkey has child subkeys
             using (var rk = TestRegistryKey.CreateSubKey(name))
             {
-                rk.CreateSubKey(name);
+                using RegistryKey subkey = rk.CreateSubKey(name);
                 Assert.Throws<InvalidOperationException>(() => TestRegistryKey.DeleteSubKey(name, false));
             }
 
@@ -46,7 +46,9 @@ namespace Microsoft.Win32.RegistryTests
         public void DeleteSubKeyTest()
         {
             Assert.Equal(expected: 0, actual: TestRegistryKey.SubKeyCount);
-            Assert.NotNull(TestRegistryKey.CreateSubKey(TestRegistryKeyName));
+
+            using RegistryKey subkey = TestRegistryKey.CreateSubKey(TestRegistryKeyName);
+            Assert.NotNull(subkey);
             Assert.Equal(expected: 1, actual: TestRegistryKey.SubKeyCount);
 
             TestRegistryKey.DeleteSubKey(TestRegistryKeyName);
@@ -60,7 +62,7 @@ namespace Microsoft.Win32.RegistryTests
             string[] subKeyNames = Enumerable.Range(1, 9).Select(x => "BLAH_" + x.ToString()).ToArray();
             foreach (var subKeyName in subKeyNames)
             {
-                TestRegistryKey.CreateSubKey(subKeyName);
+                TestRegistryKey.CreateSubKey(subKeyName).Dispose();
             }
 
             Assert.Equal(subKeyNames, TestRegistryKey.GetSubKeyNames());

diff --git a/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_DeleteSubKey_str.cs b/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_DeleteSubKey_str.cs
index d37d8a6..ae07224 100644 (file)
--- a/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_DeleteSubKey_str.cs
+++ b/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_DeleteSubKey_str.cs
@@ -22,7 +22,7 @@ namespace Microsoft.Win32.RegistryTests
             // Should throw if subkey has child subkeys
             using (var rk = TestRegistryKey.CreateSubKey(name))
             {
-                rk.CreateSubKey(name);
+                using RegistryKey subkey = rk.CreateSubKey(name);
                 Assert.Throws<InvalidOperationException>(() => TestRegistryKey.DeleteSubKey(name));
             }
 
@@ -44,7 +44,9 @@ namespace Microsoft.Win32.RegistryTests
         public void DeleteSubKeyTest()
         {
             Assert.Equal(expected: 0, actual: TestRegistryKey.SubKeyCount);
-            Assert.NotNull(TestRegistryKey.CreateSubKey(TestRegistryKeyName));
+
+            using RegistryKey subkey = TestRegistryKey.CreateSubKey(TestRegistryKeyName);
+            Assert.NotNull(subkey);
             Assert.Equal(expected: 1, actual: TestRegistryKey.SubKeyCount);
 
             TestRegistryKey.DeleteSubKey(TestRegistryKeyName);

diff --git a/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_GetSubKeyCount.cs b/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_GetSubKeyCount.cs
index b168ff0..754196b 100644 (file)
--- a/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_GetSubKeyCount.cs
+++ b/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_GetSubKeyCount.cs
@@ -33,7 +33,9 @@ namespace Microsoft.Win32.RegistryTests
             // [] Creating new SubKeys and get count
 
             Assert.Equal(expected: 0, actual: TestRegistryKey.SubKeyCount);
-            Assert.NotNull(TestRegistryKey.CreateSubKey(TestRegistryKeyName));
+
+            using RegistryKey subkey = TestRegistryKey.CreateSubKey(TestRegistryKeyName);
+            Assert.NotNull(subkey);
             Assert.Equal(expected: 1, actual: TestRegistryKey.SubKeyCount);
 
             TestRegistryKey.DeleteSubKey(TestRegistryKeyName);
@@ -47,7 +49,7 @@ namespace Microsoft.Win32.RegistryTests
             string[] testSubKeys = Enumerable.Range(1, 9).Select(x => "BLAH_" + x.ToString()).ToArray();
             foreach (var subKey in testSubKeys)
             {
-                TestRegistryKey.CreateSubKey(subKey);
+                TestRegistryKey.CreateSubKey(subKey).Dispose();
             }
 
             Assert.Equal(testSubKeys.Length, TestRegistryKey.SubKeyCount);

diff --git a/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_GetSubKeyNames.cs b/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_GetSubKeyNames.cs
index 8bc03b6..047a2ba 100644 (file)
--- a/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_GetSubKeyNames.cs
+++ b/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_GetSubKeyNames.cs
@@ -34,7 +34,7 @@ namespace Microsoft.Win32.RegistryTests
             string[] expectedSubKeyNames = Enumerable.Range(1, 9).Select(x => "BLAH_" + x.ToString()).ToArray();
             foreach (var subKeyName in expectedSubKeyNames)
             {
-                TestRegistryKey.CreateSubKey(subKeyName);
+                TestRegistryKey.CreateSubKey(subKeyName).Dispose();
             }
 
             Assert.Equal(expectedSubKeyNames, TestRegistryKey.GetSubKeyNames());

diff --git a/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_OpenSubKey_str.cs b/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_OpenSubKey_str.cs
index 08f5792..209af60 100644 (file)
--- a/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_OpenSubKey_str.cs
+++ b/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_OpenSubKey_str.cs
@@ -41,12 +41,14 @@ namespace Microsoft.Win32.RegistryTests
         [Fact]
         public void OpenSubKeyTest()
         {
-            TestRegistryKey.CreateSubKey(TestRegistryKeyName);
-            Assert.NotNull(TestRegistryKey.OpenSubKey(TestRegistryKeyName));
+            using RegistryKey created = TestRegistryKey.CreateSubKey(TestRegistryKeyName);
+            using RegistryKey subkey = TestRegistryKey.OpenSubKey(TestRegistryKeyName);
+            Assert.NotNull(subkey);
             Assert.Equal(expected: 1, actual: TestRegistryKey.SubKeyCount);
 
             TestRegistryKey.DeleteSubKey(TestRegistryKeyName);
-            Assert.Null(TestRegistryKey.OpenSubKey(TestRegistryKeyName));
+            using RegistryKey subkey2 = TestRegistryKey.OpenSubKey(TestRegistryKeyName);
+            Assert.Null(subkey2);
             Assert.Equal(expected: 0, actual: TestRegistryKey.SubKeyCount);
         }
 
@@ -56,7 +58,7 @@ namespace Microsoft.Win32.RegistryTests
             string[] subKeyNames = Enumerable.Range(1, 9).Select(x => "BLAH_" + x.ToString()).ToArray();
             foreach (var subKeyName in subKeyNames)
             {
-                TestRegistryKey.CreateSubKey(subKeyName);
+                TestRegistryKey.CreateSubKey(subKeyName).Dispose();
             }
 
             Assert.Equal(subKeyNames.Length, TestRegistryKey.SubKeyCount);

diff --git a/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_OpenSubKey_str_b.cs b/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_OpenSubKey_str_b.cs
index d3f81b5..7990bdc 100644 (file)
--- a/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_OpenSubKey_str_b.cs
+++ b/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_OpenSubKey_str_b.cs
@@ -20,7 +20,7 @@ namespace Microsoft.Win32.RegistryTests
             // OpenSubKey should be read only
             const string name = "FooBar";
             TestRegistryKey.SetValue(name, 42);
-            TestRegistryKey.CreateSubKey(name);
+            TestRegistryKey.CreateSubKey(name).Dispose();
             using (var rk = Registry.CurrentUser.OpenSubKey(name: TestRegistryKeyName, writable: false))
             {
                 Assert.Throws<UnauthorizedAccessException>(() => rk.CreateSubKey(name));
@@ -45,10 +45,11 @@ namespace Microsoft.Win32.RegistryTests
             const int testValue = 32;
             using (var rk = TestRegistryKey.OpenSubKey("", true))
             {
-                rk.CreateSubKey(TestRegistryKeyName);
+                rk.CreateSubKey(TestRegistryKeyName).Dispose();
                 rk.SetValue(TestRegistryKeyName, testValue);
 
-                Assert.NotNull(rk.OpenSubKey(TestRegistryKeyName));
+                using RegistryKey subkey = rk.OpenSubKey(TestRegistryKeyName);
+                Assert.NotNull(subkey);
                 Assert.Equal(testValue, (int)rk.GetValue(TestRegistryKeyName));
             }
         }

diff --git a/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_OpenSubKey_str_rkpc.cs b/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_OpenSubKey_str_rkpc.cs
index 033354f..8e010e6 100644 (file)
--- a/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_OpenSubKey_str_rkpc.cs
+++ b/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_OpenSubKey_str_rkpc.cs
@@ -20,7 +20,7 @@ namespace Microsoft.Win32.RegistryTests
             // Should throw when opened with default permission check
             const string name = "FooBar";
             TestRegistryKey.SetValue(name, 42);
-            TestRegistryKey.CreateSubKey(name);
+            TestRegistryKey.CreateSubKey(name).Dispose();
             using (var rk = Registry.CurrentUser.OpenSubKey(name: TestRegistryKeyName, permissionCheck: RegistryKeyPermissionCheck.Default))
             {
                 Assert.Throws<UnauthorizedAccessException>(() => rk.CreateSubKey(name));
@@ -59,8 +59,9 @@ namespace Microsoft.Win32.RegistryTests
             {
                 rk.SetValue(valueName, expectedValue);
                 Assert.Equal(expectedValue, rk.GetValue(valueName));
-                rk.CreateSubKey(valueName);
-                Assert.NotNull(rk.OpenSubKey(valueName));
+                rk.CreateSubKey(valueName).Dispose();
+                using RegistryKey subkey = rk.OpenSubKey(valueName);
+                Assert.NotNull(subkey);
             }
         }
 

diff --git a/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_OpenSubKey_str_rkpc_rr.cs b/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_OpenSubKey_str_rkpc_rr.cs
index ffce017..5cb23fb 100644 (file)
--- a/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_OpenSubKey_str_rkpc_rr.cs
+++ b/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_OpenSubKey_str_rkpc_rr.cs
@@ -21,7 +21,7 @@ namespace Microsoft.Win32.RegistryTests
             // Should throw when opened with default permission check and write rights
             const string name = "FooBar";
             TestRegistryKey.SetValue(name, 42);
-            TestRegistryKey.CreateSubKey(name);
+            TestRegistryKey.CreateSubKey(name).Dispose();
             using (var rk = Registry.CurrentUser.OpenSubKey(name: TestRegistryKeyName, permissionCheck: RegistryKeyPermissionCheck.Default, rights: RegistryRights.WriteKey))
             {
                 Assert.Throws<UnauthorizedAccessException>(() => rk.CreateSubKey(name));
@@ -79,8 +79,9 @@ namespace Microsoft.Win32.RegistryTests
 
             using (var rk = TestRegistryKey.OpenSubKey("", RegistryKeyPermissionCheck.ReadWriteSubTree, RegistryRights.CreateSubKey))
             {
-                rk.CreateSubKey(valueName);
-                Assert.NotNull(rk.OpenSubKey(valueName));
+                rk.CreateSubKey(valueName).Dispose();
+                using RegistryKey subkey = rk.OpenSubKey(valueName);
+                Assert.NotNull(subkey);
             }
         }
 

diff --git a/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_OpenSubKey_str_rr.cs b/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_OpenSubKey_str_rr.cs
index 2527534..8cf711f 100644 (file)
--- a/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_OpenSubKey_str_rr.cs
+++ b/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/RegistryKey_OpenSubKey_str_rr.cs
@@ -21,7 +21,7 @@ namespace Microsoft.Win32.RegistryTests
             // OpenSubKey should be read only
             const string name = "FooBar";
             TestRegistryKey.SetValue(name, 42);
-            TestRegistryKey.CreateSubKey(name);
+            TestRegistryKey.CreateSubKey(name).Dispose();
             using (var rk = Registry.CurrentUser.OpenSubKey(name: TestRegistryKeyName, rights: RegistryRights.ReadKey))
             {
                 Assert.Throws<UnauthorizedAccessException>(() => rk.CreateSubKey(name));
@@ -53,8 +53,9 @@ namespace Microsoft.Win32.RegistryTests
 
             using (var rk = TestRegistryKey.OpenSubKey("", RegistryRights.CreateSubKey))
             {
-                rk.CreateSubKey(valueName);
-                Assert.NotNull(rk.OpenSubKey(valueName));
+                rk.CreateSubKey(valueName).Dispose();
+                using RegistryKey subkey = rk.OpenSubKey(valueName);
+                Assert.NotNull(subkey);
             }
         }
 

diff --git a/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/SafeRegistryHandle.cs b/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/SafeRegistryHandle.cs
index 3ddd111..4424cad 100644 (file)
--- a/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/SafeRegistryHandle.cs
+++ b/src/libraries/Microsoft.Win32.Registry/tests/RegistryKey/SafeRegistryHandle.cs
@@ -36,21 +36,23 @@ namespace Microsoft.Win32.RegistryTests
             //Try getting registrykey from handle for key that has been deleted.
             Assert.Throws<IOException>(() =>
             {
-                RegistryKey rk = TestRegistryKey.CreateSubKey(subKeyName);
+                using RegistryKey rk = TestRegistryKey.CreateSubKey(subKeyName);
                 SafeRegistryHandle handle = rk.Handle;
                 TestRegistryKey.DeleteSubKey(subKeyName);
-                rk = RegistryKey.FromHandle(handle, RegistryView.Default);
-                rk.CreateSubKey("TestThrows");
+
+                using RegistryKey rk2 = RegistryKey.FromHandle(handle, RegistryView.Default);
+                rk2.CreateSubKey("TestThrows").Dispose();
             });
 
             //Try getting handle on deleted key.
             Assert.Throws<IOException>(() =>
             {
-                RegistryKey rk = TestRegistryKey.CreateSubKey(subKeyName);
+                using RegistryKey rk = TestRegistryKey.CreateSubKey(subKeyName);
                 TestRegistryKey.DeleteSubKey(subKeyName);
                 SafeRegistryHandle handle = rk.Handle;
-                rk = RegistryKey.FromHandle(handle, RegistryView.Default);
-                rk.CreateSubKey("TestThrows");
+
+                using RegistryKey rk2 = RegistryKey.FromHandle(handle, RegistryView.Default);
+                rk2.CreateSubKey("TestThrows");
             });
         }
     }

diff --git a/src/libraries/Microsoft.Win32.Registry/tests/RegistryTestsBase.cs b/src/libraries/Microsoft.Win32.Registry/tests/RegistryTestsBase.cs
index 588feae..df1e537 100644 (file)
--- a/src/libraries/Microsoft.Win32.Registry/tests/RegistryTestsBase.cs
+++ b/src/libraries/Microsoft.Win32.Registry/tests/RegistryTestsBase.cs
@@ -36,7 +36,9 @@ namespace Microsoft.Win32.RegistryTests
         private static void RemoveKeyIfExists(string keyName)
         {
             RegistryKey rk = Registry.CurrentUser;
-            if (rk.OpenSubKey(keyName) != null)
+
+            using RegistryKey subkey = rk.OpenSubKey(keyName);
+            if (subkey != null)
             {
                 rk.DeleteSubKeyTree(keyName);
                 Assert.Null(rk.OpenSubKey(keyName));