?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2010-04-15 Jb Evain <jbevain@novell.com>
[mcs.git] / class / corlib / Test / Microsoft.Win32 / RegistryKeyTest.cs
blob79f8ee453fa66e3ced62f0df012724470e90484a
1 //
2 // RegistryKeyTest.cs - NUnit Test Cases for Microsoft.Win32.RegistryKey
3 //
4 // Authors:
5 // mei (mei@work.email.ne.jp)
6 // Robert Jordan (robertj@gmx.net)
7 // Gert Driesen (drieseng@users.sourceforge.net)
8 //
9 // (C) 2005 mei
10 // (C) 2004, 2005 Novell (http://www.novell.com)
11 //
12
13 using System;
14 using System.IO;
15
16 using Microsoft.Win32;
17
18 using NUnit.Framework;
19
20 namespace MonoTests.Microsoft.Win32
21 {
22 [TestFixture]
23 public class RegistryKeyTest
24 {
25 private const string mimeroot = @"MIME\Database\Content Type";
26
27 [Test]
28 [Category ("NotWorking")] // this will not work on Linux ever
29 public void TestGetValue ()
30 {
31 RegistryKey root = Registry.ClassesRoot;
32 RegistryKey key;
33
34 key = root.OpenSubKey (mimeroot + @"\audio/wav");
35 Assert.AreEqual (".wav", key.GetValue ("Extension"), "GetValue #1");
36 key = root.OpenSubKey (mimeroot + @"\text/x-scriptlet");
37 Assert.AreEqual (null, key.GetValue ("Extension"), "GetValue #2");
38 }
39
40 [Test] // bug #77212
41 public void TestHandle ()
42 {
43 // this test is for Windows only
44 if (RunningOnUnix)
45 return;
46
47 // this regpath always exists under windows
48 RegistryKey k = Registry.CurrentUser
49 .OpenSubKey ("Software", false)
50 .OpenSubKey ("Microsoft", false)
51 .OpenSubKey ("Windows", false);
52
53 Assert.IsNotNull (k, "#01");
54 }
55
56 [Test]
57 public void OpenSubKey ()
58 {
59 RegistryKey key = Registry.LocalMachine;
60
61 // HKEY_LOCAL_MACHINE\software should always exist on Windows
62 // and is automatically created on Linux
63 Assert.IsNotNull (key.OpenSubKey ("Software"), "#A1");
64 Assert.IsNotNull (key.OpenSubKey ("soFtware"), "#A2");
65
66 key = Registry.CurrentUser;
67
68 // HKEY_CURRENT_USER\software should always exist on Windows
69 // and is automatically created on Linux
70 Assert.IsNotNull (key.OpenSubKey ("Software"), "#B1");
71 Assert.IsNotNull (key.OpenSubKey ("soFtware"), "#B2");
72
73 key = Registry.Users;
74
75 // HKEY_USERS\software should not exist on Windows, and should not
76 // be created automatically on Linux
77 Assert.IsNull (key.OpenSubKey ("Software"), "#C1");
78 Assert.IsNull (key.OpenSubKey ("soFtware"), "#C2");
79 }
80
81 [Test]
82 public void OpenSubKey_Key_DoesNotExist ()
83 {
84 string subKeyName = Guid.NewGuid ().ToString ();
85 Assert.IsNull (Registry.CurrentUser.OpenSubKey (subKeyName), "#1"); // read-only
86 Assert.IsNull (Registry.CurrentUser.OpenSubKey (subKeyName, true), "#2"); // writable
87 }
88
89 [Test]
90 public void OpenSubKey_Key_Removed ()
91 {
92 string subKeyName = Guid.NewGuid ().ToString ();
93
94 try {
95 using (RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName)) {
96 // check if key was successfully created
97 Assert.IsNotNull (createdKey, "#1");
98 RegistryKey subKey = createdKey.CreateSubKey ("monotemp");
99 subKey.Close ();
100 }
101 using (RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName, true)) {
102 Assert.IsNotNull (createdKey, "#2");
103 using (RegistryKey subKey = createdKey.OpenSubKey ("monotemp")) {
104 Assert.IsNotNull (createdKey, "#3");
105 }
106 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
107
108 // read-only
109 Assert.IsNull (Registry.CurrentUser.OpenSubKey (subKeyName), "#4");
110 Assert.IsNull (createdKey.OpenSubKey ("monotemp"), "#5"); // read-only
111 // writable
112 Assert.IsNull (Registry.CurrentUser.OpenSubKey (subKeyName, true), "#6");
113 Assert.IsNull (createdKey.OpenSubKey ("monotemp", true), "#7");
114 }
115 } finally {
116 try {
117 RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName);
118 if (createdKey != null) {
119 createdKey.Close ();
120 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
121 }
122 } catch {
123 }
124 }
125 }
126
127 [Test]
128 [Category ("NotWorking")] // MS should not allow this
129 public void OpenSubKey_Name_Empty ()
130 {
131 // read-only
132 using (RegistryKey emptyKey = Registry.CurrentUser.OpenSubKey (string.Empty)) {
133 Assert.IsNotNull (emptyKey, "#1");
134 }
135 // writable
136 using (RegistryKey emptyKey = Registry.CurrentUser.OpenSubKey (string.Empty, true)) {
137 Assert.IsNotNull (emptyKey, "#1");
138 }
139 }
140
141 [Test]
142 public void OpenSubKey_Name_MaxLength ()
143 {
144 string name = new string ('a', 254);
145
146 Assert.IsNull (Registry.CurrentUser.OpenSubKey (name), "#A1");
147
148 name = new string ('a', 255);
149
150 Assert.IsNull (Registry.CurrentUser.OpenSubKey (name), "#B1");
151
152 name = new string ('a', 256);
153
154 try {
155 Registry.CurrentUser.OpenSubKey (name);
156 Assert.Fail ("#C1");
157 } catch (ArgumentException ex) {
158 // 1.x: Registry subkeys should not be
159 // greater than or equal to 255 characters
160 //
161 // 2.x: Registry subkeys should not be
162 // greater than 255 characters
163 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
164 Assert.IsNull (ex.InnerException, "#C3");
165 Assert.IsNotNull (ex.Message, "#c4");
166 Assert.IsTrue (ex.Message.IndexOf ("255") != -1, "#C5");
167 Assert.IsNull (ex.ParamName, "#C6");
168 }
169 }
170
171 [Test]
172 public void OpenSubKey_Name_Null ()
173 {
174 try {
175 Registry.CurrentUser.OpenSubKey (null);
176 Assert.Fail ("#A1");
177 } catch (ArgumentNullException ex) {
178 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
179 Assert.IsNull (ex.InnerException, "#A3");
180 Assert.IsNotNull (ex.Message, "#A4");
181 Assert.AreEqual ("name", ex.ParamName, "#A5");
182 }
183
184 try {
185 Registry.CurrentUser.OpenSubKey (null, true);
186 Assert.Fail ("#B1");
187 } catch (ArgumentNullException ex) {
188 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
189 Assert.IsNull (ex.InnerException, "#B3");
190 Assert.IsNotNull (ex.Message, "#B4");
191 Assert.AreEqual ("name", ex.ParamName, "#B5");
192 }
193 }
194
195 [Test]
196 public void Close_Local_Hive ()
197 {
198 RegistryKey hive = Registry.CurrentUser;
199 hive.Close ();
200
201 Assert.IsNotNull (hive.GetSubKeyNames (), "#1");
202 Assert.IsNull (hive.GetValue ("doesnotexist"), "#2");
203 Assert.IsNotNull (hive.GetValueNames (), "#3");
204 Assert.IsNull (hive.OpenSubKey ("doesnotexist"), "#4");
205 Assert.IsNotNull (hive.SubKeyCount, "#5");
206 Assert.IsNotNull (hive.ToString (), "#6");
207
208 // closing key again does not have any effect
209 hive.Close ();
210 }
211
212 [Test]
213 public void Close_Local_Key ()
214 {
215 RegistryKey key = Registry.CurrentUser.OpenSubKey ("SOFTWARE");
216 key.Close ();
217
218 // closing a key twice does not have any effect
219 key.Close ();
220
221 try {
222 key.CreateSubKey ("a");
223 Assert.Fail ("#1");
224 } catch (ObjectDisposedException) {
225 }
226
227 try {
228 key.DeleteSubKey ("doesnotexist");
229 Assert.Fail ("#2");
230 } catch (ObjectDisposedException) {
231 }
232
233 try {
234 key.DeleteSubKeyTree ("doesnotexist");
235 Assert.Fail ("#3");
236 } catch (ObjectDisposedException) {
237 }
238
239 try {
240 key.DeleteValue ("doesnotexist");
241 Assert.Fail ("#4");
242 } catch (ObjectDisposedException) {
243 }
244
245 // flushing a closed key does not have any effect
246 key.Flush ();
247
248 try {
249 key.GetSubKeyNames ();
250 Assert.Fail ("#5");
251 } catch (ObjectDisposedException) {
252 }
253
254 try {
255 key.GetValue ("doesnotexist");
256 Assert.Fail ("#6");
257 } catch (ObjectDisposedException) {
258 }
259
260 try {
261 key.GetValueNames ();
262 Assert.Fail ("#7");
263 } catch (ObjectDisposedException) {
264 }
265
266 try {
267 key.OpenSubKey ("doesnotexist");
268 Assert.Fail ("#8");
269 } catch (ObjectDisposedException) {
270 }
271
272 try {
273 key.SetValue ("doesnotexist", "something");
274 Assert.Fail ("#9");
275 } catch (ObjectDisposedException) {
276 }
277
278 try {
279 int x = key.SubKeyCount;
280 Assert.Fail ("#10:" + x);
281 } catch (ObjectDisposedException) {
282 }
283
284 try {
285 key.ToString ();
286 Assert.Fail ("#11");
287 } catch (ObjectDisposedException) {
288 }
289
290 try {
291 int x = key.ValueCount;
292 Assert.Fail ("#12:" + x);
293 } catch (ObjectDisposedException) {
294 }
295 }
296
297 [Test]
298 public void Close_Remote_Hive ()
299 {
300 // access to registry of remote machines is not implemented on unix
301 if (RunningOnUnix)
302 return;
303
304 RegistryKey hive = RegistryKey.OpenRemoteBaseKey (
305 RegistryHive.CurrentUser, Environment.MachineName);
306 hive.Close ();
307
308 // closing a remote hive twice does not have any effect
309 hive.Close ();
310
311 try {
312 hive.CreateSubKey ("a");
313 Assert.Fail ("#1");
314 } catch (ObjectDisposedException) {
315 }
316
317 try {
318 hive.DeleteSubKey ("doesnotexist");
319 Assert.Fail ("#2");
320 } catch (ObjectDisposedException) {
321 }
322
323 try {
324 hive.DeleteSubKeyTree ("doesnotexist");
325 Assert.Fail ("#3");
326 } catch (ObjectDisposedException) {
327 }
328
329 try {
330 hive.DeleteValue ("doesnotexist");
331 Assert.Fail ("#4");
332 } catch (ObjectDisposedException) {
333 }
334
335 // flushing a closed hive does not have any effect
336 hive.Flush ();
337
338 try {
339 hive.GetSubKeyNames ();
340 Assert.Fail ("#5");
341 } catch (ObjectDisposedException) {
342 }
343
344 try {
345 hive.GetValue ("doesnotexist");
346 Assert.Fail ("#6");
347 } catch (ObjectDisposedException) {
348 }
349
350 try {
351 hive.GetValueNames ();
352 Assert.Fail ("#7");
353 } catch (ObjectDisposedException) {
354 }
355
356 try {
357 hive.OpenSubKey ("doesnotexist");
358 Assert.Fail ("#8");
359 } catch (ObjectDisposedException) {
360 }
361
362 try {
363 hive.SetValue ("doesnotexist", "something");
364 Assert.Fail ("#9");
365 } catch (ObjectDisposedException) {
366 }
367
368 try {
369 int x = hive.SubKeyCount;
370 Assert.Fail ("#10:" + x);
371 } catch (ObjectDisposedException) {
372 }
373
374 try {
375 hive.ToString ();
376 Assert.Fail ("#11");
377 } catch (ObjectDisposedException) {
378 }
379
380 try {
381 int x = hive.ValueCount;
382 Assert.Fail ("#12:" + x);
383 } catch (ObjectDisposedException) {
384 }
385 }
386
387 [Test]
388 public void Close_Remote_Key ()
389 {
390 // access to registry of remote machines is not implemented on unix
391 if (RunningOnUnix)
392 return;
393
394 RegistryKey hive = RegistryKey.OpenRemoteBaseKey (
395 RegistryHive.CurrentUser, Environment.MachineName);
396 RegistryKey key = hive.OpenSubKey ("SOFTWARE");
397 key.Close ();
398
399 // closing a remote key twice does not have any effect
400 key.Close ();
401
402 try {
403 key.CreateSubKey ("a");
404 Assert.Fail ("#1");
405 } catch (ObjectDisposedException) {
406 }
407
408 try {
409 key.DeleteSubKey ("doesnotexist");
410 Assert.Fail ("#2");
411 } catch (ObjectDisposedException) {
412 }
413
414 try {
415 key.DeleteSubKeyTree ("doesnotexist");
416 Assert.Fail ("#3");
417 } catch (ObjectDisposedException) {
418 }
419
420 try {
421 key.DeleteValue ("doesnotexist");
422 Assert.Fail ("#4");
423 } catch (ObjectDisposedException) {
424 }
425
426 // flushing a closed key does not have any effect
427 key.Flush ();
428
429 try {
430 key.GetSubKeyNames ();
431 Assert.Fail ("#5");
432 } catch (ObjectDisposedException) {
433 }
434
435 try {
436 key.GetValue ("doesnotexist");
437 Assert.Fail ("#6");
438 } catch (ObjectDisposedException) {
439 }
440
441 try {
442 key.GetValueNames ();
443 Assert.Fail ("#7");
444 } catch (ObjectDisposedException) {
445 }
446
447 try {
448 key.OpenSubKey ("doesnotexist");
449 Assert.Fail ("#8");
450 } catch (ObjectDisposedException) {
451 }
452
453 try {
454 key.SetValue ("doesnotexist", "something");
455 Assert.Fail ("#9");
456 } catch (ObjectDisposedException) {
457 }
458
459 try {
460 int x = key.SubKeyCount;
461 Assert.Fail ("#10:" + x);
462 } catch (ObjectDisposedException) {
463 }
464
465 try {
466 key.ToString ();
467 Assert.Fail ("#11");
468 } catch (ObjectDisposedException) {
469 }
470
471 try {
472 int x = key.ValueCount;
473 Assert.Fail ("#12:" + x);
474 } catch (ObjectDisposedException) {
475 }
476
477 hive.Close ();
478 }
479
480 [Test]
481 public void CreateSubKey ()
482 {
483 string subKeyName = Guid.NewGuid ().ToString ();
484
485 try {
486 using (RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName)) {
487 // check if key was successfully created
488 Assert.IsNotNull (createdKey, "#A1");
489 // software subkey should not be created automatically
490 Assert.IsNull (createdKey.OpenSubKey ("software"), "#A2");
491 }
492
493 using (RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName)) {
494 // check if key was successfully created
495 Assert.IsNotNull (createdKey, "#B1");
496 // software subkey should not be created automatically
497 Assert.IsNull (createdKey.OpenSubKey ("software"), "#B2");
498 }
499 } finally {
500 // clean-up
501 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
502 }
503
504 using (RegistryKey softwareKey = Registry.CurrentUser.OpenSubKey ("software", true)) {
505 try {
506 using (RegistryKey createdKey = softwareKey.CreateSubKey (subKeyName)) {
507 // check if key was successfully created
508 Assert.IsNotNull (createdKey, "#C1");
509 // software subkey should not be created automatically
510 Assert.IsNull (softwareKey.OpenSubKey ("software"), "#C2");
511 }
512
513 using (RegistryKey createdKey = softwareKey.OpenSubKey (subKeyName)) {
514 // check if key was successfully created
515 Assert.IsNotNull (createdKey, "#D1");
516 // software subkey should not be created automatically
517 Assert.IsNull (softwareKey.OpenSubKey ("software"), "#D2");
518 }
519 } finally {
520 // clean-up
521 softwareKey.DeleteSubKeyTree (subKeyName);
522 }
523 }
524 }
525
526 [Test]
527 public void CreateSubKey_Key_ReadOnly ()
528 {
529 string subKeyName = Guid.NewGuid ().ToString ();
530
531 using (RegistryKey softwareKey = Registry.CurrentUser.OpenSubKey ("software")) {
532 RegistryKey createdKey = null;
533 try {
534 try {
535 createdKey = softwareKey.CreateSubKey (subKeyName);
536 Assert.Fail ("#1");
537 } catch (UnauthorizedAccessException ex) {
538 // Cannot write to the registry key
539 Assert.AreEqual (typeof (UnauthorizedAccessException), ex.GetType (), "#2");
540 Assert.IsNotNull (ex.Message, "#3");
541 Assert.IsNull (ex.InnerException, "#4");
542 }
543 } finally {
544 if (createdKey != null)
545 createdKey.Close ();
546 }
547 }
548 }
549
550 [Test]
551 public void CreateSubKey_Key_Removed ()
552 {
553 string subKeyName = Guid.NewGuid ().ToString ();
554
555 using (RegistryKey softwareKey = Registry.CurrentUser.OpenSubKey ("software", true)) {
556 try {
557 using (RegistryKey createdKey = softwareKey.CreateSubKey (subKeyName)) {
558 softwareKey.DeleteSubKeyTree (subKeyName);
559 Assert.IsNull (softwareKey.OpenSubKey (subKeyName), "#1");
560 try {
561 createdKey.CreateSubKey ("test");
562 Assert.Fail ("#2");
563 } catch (IOException ex) {
564 // Illegal operation attempted on a registry key that
565 // has been marked for deletion
566 Assert.AreEqual (typeof (IOException), ex.GetType (), "#3");
567 Assert.IsNotNull (ex.Message, "#4");
568 Assert.IsNull (ex.InnerException, "#5");
569 }
570 }
571 } finally {
572 try {
573 RegistryKey createdKey = softwareKey.OpenSubKey (subKeyName);
574 if (createdKey != null) {
575 createdKey.Close ();
576 softwareKey.DeleteSubKeyTree (subKeyName);
577 }
578 } catch {
579 }
580 }
581 }
582 }
583
584 [Test]
585 [Category ("NotWorking")] // MS should not allow this
586 public void CreateSubKey_Name_Empty ()
587 {
588 using (RegistryKey softwareKey = Registry.CurrentUser.OpenSubKey ("software", true)) {
589 using (RegistryKey emptyKey = softwareKey.CreateSubKey (string.Empty)) {
590 Assert.IsNotNull (emptyKey, "#1");
591 emptyKey.SetValue ("name1", "value1");
592 }
593 }
594 }
595
596 [Test]
597 public void CreateSubKey_Name_MaxLength ()
598 {
599 using (RegistryKey softwareKey = Registry.CurrentUser.OpenSubKey ("software", true)) {
600 string subKeyName = new string ('a', 254);
601
602 try {
603 using (RegistryKey createdKey = softwareKey.CreateSubKey (subKeyName)) {
604 Assert.IsNotNull (createdKey, "#A1");
605 Assert.IsNotNull (softwareKey.OpenSubKey (subKeyName), "#A2");
606 }
607 } finally {
608 softwareKey.DeleteSubKeyTree (subKeyName);
609 }
610
611 subKeyName = new string ('a', 255);
612
613 try {
614 using (RegistryKey createdKey = softwareKey.CreateSubKey (subKeyName)) {
615 Assert.IsNotNull (createdKey, "#B1");
616 Assert.IsNotNull (softwareKey.OpenSubKey (subKeyName), "#B2");
617 }
618 } finally {
619 softwareKey.DeleteSubKey (subKeyName);
620 }
621
622 subKeyName = new string ('a', 256);
623
624 try {
625 softwareKey.CreateSubKey (subKeyName);
626 Assert.Fail ("#C1");
627 } catch (ArgumentException ex) {
628 // 1.x: Registry subkeys should not be
629 // greater than or equal to 255 characters
630 //
631 // 2.x: Registry subkeys should not be
632 // greater than 255 characters
633 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
634 Assert.IsNull (ex.InnerException, "#C3");
635 Assert.IsNotNull (ex.Message, "#C4");
636 Assert.IsTrue (ex.Message.IndexOf ("255") != -1, "#C5");
637 Assert.IsNull (ex.ParamName, "#C6");
638 }
639 }
640 }
641
642 [Test]
643 public void CreateSubKey_Name_Null ()
644 {
645 using (RegistryKey softwareKey = Registry.CurrentUser.OpenSubKey ("software", true)) {
646 try {
647 softwareKey.CreateSubKey (null);
648 Assert.Fail ("#1");
649 } catch (ArgumentNullException ex) {
650 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
651 Assert.IsNull (ex.InnerException, "#3");
652 Assert.IsNotNull (ex.Message, "#4");
653 Assert.AreEqual ("name", ex.ParamName, "#5");
654 }
655 }
656 }
657
658 [Test]
659 public void DeleteSubKey ()
660 {
661 string subKeyName = Guid.NewGuid ().ToString ();
662
663 try {
664 using (RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName)) {
665 // check if key was successfully created
666 Assert.IsNotNull (createdKey, "#1");
667 }
668 using (RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName)) {
669 Assert.IsNotNull (createdKey, "#2");
670 Registry.CurrentUser.DeleteSubKey (subKeyName);
671 }
672 using (RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName)) {
673 Assert.IsNull (createdKey, "#3");
674 }
675 } finally {
676 try {
677 RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName);
678 if (createdKey != null) {
679 createdKey.Close ();
680 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
681 }
682 } catch {
683 }
684 }
685 }
686
687 [Test]
688 public void DeleteSubKey_Key_HasChildKeys ()
689 {
690 string subKeyName = Guid.NewGuid ().ToString ();
691
692 try {
693 using (RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName)) {
694 // check if key was successfully created
695 Assert.IsNotNull (createdKey, "#1");
696 RegistryKey subKey = createdKey.CreateSubKey ("monotemp");
697 subKey.Close ();
698 }
699 try {
700 Registry.CurrentUser.DeleteSubKey (subKeyName);
701 Assert.Fail ("#2");
702 } catch (InvalidOperationException ex) {
703 // Registry key has subkeys and recursive removes are not
704 // supported by this method
705 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#3");
706 Assert.IsNotNull (ex.Message, "#4");
707 Assert.IsNull (ex.InnerException, "#5");
708 }
709 } finally {
710 try {
711 RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName);
712 if (createdKey != null) {
713 createdKey.Close ();
714 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
715 }
716 } catch {
717 }
718 }
719 }
720
721 [Test]
722 public void DeleteSubKey_Key_ReadOnly ()
723 {
724 string subKeyName = Guid.NewGuid ().ToString ();
725
726 try {
727 using (RegistryKey softwareKey = Registry.CurrentUser.OpenSubKey ("software", true)) {
728 RegistryKey createdKey = softwareKey.CreateSubKey (subKeyName);
729 createdKey.Close ();
730 }
731
732 using (RegistryKey softwareKey = Registry.CurrentUser.OpenSubKey ("software")) {
733 try {
734 softwareKey.DeleteSubKey (subKeyName);
735 Assert.Fail ("#1");
736 } catch (UnauthorizedAccessException ex) {
737 // Cannot write to the registry key
738 Assert.AreEqual (typeof (UnauthorizedAccessException), ex.GetType (), "#2");
739 Assert.IsNotNull (ex.Message, "#3");
740 Assert.IsNull (ex.InnerException, "#4");
741 }
742 }
743 } finally {
744 try {
745 using (RegistryKey softwareKey = Registry.CurrentUser.OpenSubKey ("software", true)) {
746 RegistryKey createdKey = softwareKey.OpenSubKey (subKeyName);
747 if (createdKey != null) {
748 createdKey.Close ();
749 softwareKey.DeleteSubKeyTree (subKeyName);
750 }
751 }
752 } catch {
753 }
754 }
755 }
756
757 [Test]
758 public void DeleteSubKey_Key_DoesNotExist ()
759 {
760 string subKeyName = Guid.NewGuid ().ToString ();
761
762 try {
763 Registry.CurrentUser.DeleteSubKey (subKeyName);
764 Assert.Fail ("#A1");
765 } catch (ArgumentException ex) {
766 // Cannot delete a subkey tree because the subkey does not exist
767 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
768 Assert.IsNull (ex.InnerException, "#A3");
769 Assert.IsNotNull (ex.Message, "#A4");
770 Assert.IsNull (ex.ParamName, "#A5");
771 }
772
773 try {
774 Registry.CurrentUser.DeleteSubKey (subKeyName, true);
775 Assert.Fail ("#B1");
776 } catch (ArgumentException ex) {
777 // Cannot delete a subkey tree because the subkey does not exist
778 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
779 Assert.IsNull (ex.InnerException, "#B3");
780 Assert.IsNotNull (ex.Message, "#B4");
781 Assert.IsNull (ex.ParamName, "#B5");
782 }
783
784 Registry.CurrentUser.DeleteSubKey (subKeyName, false);
785 }
786
787 [Test]
788 public void DeleteSubKey_Key_Removed ()
789 {
790 string subKeyName = Guid.NewGuid ().ToString ();
791
792 try {
793 using (RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName)) {
794 // check if key was successfully created
795 Assert.IsNotNull (createdKey, "#1");
796 RegistryKey subKey = createdKey.CreateSubKey ("monotemp");
797 subKey.Close ();
798 }
799 using (RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName, true)) {
800 Assert.IsNotNull (createdKey, "#2");
801 using (RegistryKey subKey = createdKey.OpenSubKey ("monotemp")) {
802 Assert.IsNotNull (createdKey, "#3");
803 }
804 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
805 Assert.IsNull (Registry.CurrentUser.OpenSubKey (subKeyName), "#4");
806 try {
807 createdKey.DeleteSubKey ("monotemp");
808 Assert.Fail ("#5");
809 } catch (ArgumentException ex) {
810 // Cannot delete a subkey tree because the subkey does
811 // not exist
812 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#6");
813 Assert.IsNull (ex.InnerException, "#7");
814 Assert.IsNotNull (ex.Message, "#8");
815 Assert.IsNull (ex.ParamName, "#9");
816 }
817 }
818 } finally {
819 try {
820 RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName);
821 if (createdKey != null) {
822 createdKey.Close ();
823 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
824 }
825 } catch {
826 }
827 }
828 }
829
830 [Test]
831 [Category ("NotWorking")] // MS should not allow this
832 public void DeleteSubKey_Name_Empty ()
833 {
834 string subKeyName = Guid.NewGuid ().ToString ();
835
836 using (RegistryKey softwareKey = Registry.CurrentUser.OpenSubKey ("software", true)) {
837 try {
838 RegistryKey createdKey = softwareKey.CreateSubKey (subKeyName);
839 createdKey.DeleteSubKey (string.Empty);
840 createdKey.Close ();
841
842 createdKey = softwareKey.OpenSubKey (subKeyName);
843 Assert.IsNull (createdKey, "#1");
844 } finally {
845 try {
846 RegistryKey createdKey = softwareKey.OpenSubKey (subKeyName);
847 if (createdKey != null)
848 createdKey.Close ();
849 softwareKey.DeleteSubKeyTree (subKeyName);
850 } catch {
851 }
852 }
853 }
854 }
855
856 [Test]
857 public void DeleteSubKey_Name_MaxLength ()
858 {
859 using (RegistryKey softwareKey = Registry.CurrentUser.OpenSubKey ("software", true)) {
860 string subKeyName = new string ('a', 254);
861
862 using (RegistryKey createdKey = softwareKey.CreateSubKey (subKeyName)) {
863 createdKey.Close ();
864 }
865 using (RegistryKey createdKey = softwareKey.OpenSubKey (subKeyName, false)) {
866 Assert.IsNotNull (createdKey, "#A1");
867 }
868 softwareKey.DeleteSubKey (subKeyName);
869 using (RegistryKey createdKey = softwareKey.OpenSubKey (subKeyName, false)) {
870 Assert.IsNull (createdKey, "#A2");
871 }
872
873 subKeyName = new string ('a', 256);
874
875 try {
876 softwareKey.DeleteSubKey (subKeyName);
877 Assert.Fail ("#B1");
878 } catch (ArgumentException ex) {
879 // 1.x: Registry subkeys should not be
880 // greater than or equal to 255 characters
881 //
882 // 2.x: Registry subkeys should not be
883 // greater than 255 characters
884 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
885 Assert.IsNull (ex.InnerException, "#B3");
886 Assert.IsNotNull (ex.Message, "#B4");
887 Assert.IsTrue (ex.Message.IndexOf ("255") != -1, "#B5");
888 Assert.IsNull (ex.ParamName, "#B6");
889 }
890 }
891 }
892
893 [Test]
894 public void DeleteSubKey_Name_Null ()
895 {
896 string subKeyName = Guid.NewGuid ().ToString ();
897
898 using (RegistryKey softwareKey = Registry.CurrentUser.OpenSubKey ("software", true)) {
899 try {
900 RegistryKey createdKey = softwareKey.CreateSubKey (subKeyName);
901 try {
902 createdKey.DeleteSubKey (null);
903 Assert.Fail ("#1");
904 } catch (ArgumentNullException ex) {
905 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
906 Assert.IsNull (ex.InnerException, "#3");
907 Assert.IsNotNull (ex.Message, "#4");
908 Assert.AreEqual ("name", ex.ParamName, "#5");
909 }
910 } finally {
911 try {
912 RegistryKey createdKey = softwareKey.OpenSubKey (subKeyName);
913 if (createdKey != null)
914 createdKey.Close ();
915 softwareKey.DeleteSubKeyTree (subKeyName);
916 } catch {
917 }
918 }
919 }
920 }
921
922 [Test]
923 public void DeleteSubKeyTree ()
924 {
925 // TODO:
926 // - remove key with subkeys
927 // - remove key of which some subkeys are marked for deletion
928 // - remove key with values
929 }
930
931 [Test]
932 public void DeleteSubKeyTree_Key_DoesNotExist ()
933 {
934 // Cannot delete a subkey tree because the subkey does not exist
935 string subKeyName = Guid.NewGuid ().ToString ();
936 try {
937 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
938 Assert.Fail ("#1");
939 } catch (ArgumentException ex) {
940 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
941 Assert.IsNull (ex.InnerException, "#3");
942 Assert.IsNotNull (ex.Message, "#4");
943 Assert.IsNull (ex.ParamName, "#5");
944 }
945 }
946
947 [Test]
948 public void DeleteSubKeyTree_Key_ReadOnly ()
949 {
950 string subKeyName = Guid.NewGuid ().ToString ();
951
952 try {
953 using (RegistryKey softwareKey = Registry.CurrentUser.OpenSubKey ("software", true)) {
954 RegistryKey createdKey = softwareKey.CreateSubKey (subKeyName);
955 createdKey.Close ();
956 }
957
958 using (RegistryKey softwareKey = Registry.CurrentUser.OpenSubKey ("software")) {
959 try {
960 softwareKey.DeleteSubKeyTree (subKeyName);
961 Assert.Fail ("#1");
962 } catch (UnauthorizedAccessException ex) {
963 // Cannot write to the registry key
964 Assert.AreEqual (typeof (UnauthorizedAccessException), ex.GetType (), "#2");
965 Assert.IsNotNull (ex.Message, "#3");
966 Assert.IsNull (ex.InnerException, "#4");
967 }
968 }
969 } finally {
970 try {
971 using (RegistryKey softwareKey = Registry.CurrentUser.OpenSubKey ("software", true)) {
972 RegistryKey createdKey = softwareKey.OpenSubKey (subKeyName);
973 if (createdKey != null)
974 createdKey.Close ();
975 softwareKey.DeleteSubKeyTree (subKeyName);
976 }
977 } catch {
978 }
979 }
980 }
981
982 [Test]
983 public void DeleteSubKeyTree_Key_Removed ()
984 {
985 string subKeyName = Guid.NewGuid ().ToString ();
986
987 try {
988 using (RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName)) {
989 // check if key was successfully created
990 Assert.IsNotNull (createdKey, "#1");
991 RegistryKey subKey = createdKey.CreateSubKey ("monotemp");
992 subKey.Close ();
993 }
994 using (RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName, true)) {
995 Assert.IsNotNull (createdKey, "#2");
996 using (RegistryKey subKey = createdKey.OpenSubKey ("monotemp")) {
997 Assert.IsNotNull (createdKey, "#3");
998 }
999 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
1000 Assert.IsNull (Registry.CurrentUser.OpenSubKey (subKeyName), "#4");
1001 try {
1002 createdKey.DeleteSubKeyTree ("monotemp");
1003 Assert.Fail ("#5");
1004 } catch (ArgumentException ex) {
1005 // Cannot delete a subkey tree because the subkey does
1006 // not exist
1007 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#6");
1008 Assert.IsNull (ex.InnerException, "#7");
1009 Assert.IsNotNull (ex.Message, "#8");
1010 Assert.IsNull (ex.ParamName, "#9");
1011 }
1012 }
1013 } finally {
1014 try {
1015 RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName);
1016 if (createdKey != null) {
1017 createdKey.Close ();
1018 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
1019 }
1020 } catch {
1021 }
1022 }
1023 }
1024
1025 [Test]
1026 [Category ("NotWorking")] // MS should not allow this
1027 public void DeleteSubKeyTree_Name_Empty ()
1028 {
1029 string subKeyName = Guid.NewGuid ().ToString ();
1030
1031 using (RegistryKey softwareKey = Registry.CurrentUser.OpenSubKey ("software", true)) {
1032 try {
1033 RegistryKey createdKey = softwareKey.CreateSubKey (subKeyName);
1034 createdKey.DeleteSubKeyTree (string.Empty);
1035 createdKey.Close ();
1036
1037 createdKey = softwareKey.OpenSubKey (subKeyName);
1038 Assert.IsNull (createdKey, "#1");
1039 } finally {
1040 try {
1041 RegistryKey createdKey = softwareKey.OpenSubKey (subKeyName);
1042 if (createdKey != null)
1043 createdKey.Close ();
1044 softwareKey.DeleteSubKeyTree (subKeyName);
1045 } catch {
1046 }
1047 }
1048 }
1049 }
1050
1051 [Test]
1052 public void DeleteSubKeyTree_Name_MaxLength ()
1053 {
1054 using (RegistryKey softwareKey = Registry.CurrentUser.OpenSubKey ("software", true)) {
1055 string subKeyName = new string ('a', 254);
1056
1057 using (RegistryKey createdKey = softwareKey.CreateSubKey (subKeyName)) {
1058 createdKey.Close ();
1059 }
1060 using (RegistryKey createdKey = softwareKey.OpenSubKey (subKeyName, false)) {
1061 Assert.IsNotNull (createdKey, "#A1");
1062 }
1063 softwareKey.DeleteSubKeyTree (subKeyName);
1064 using (RegistryKey createdKey = softwareKey.OpenSubKey (subKeyName, false)) {
1065 Assert.IsNull (createdKey, "#A2");
1066 }
1067
1068 #if ONLY_1_1
1069 subKeyName = new string ('a', 255);
1070 #else
1071 subKeyName = new string ('a', 256);
1072 #endif
1073
1074 try {
1075 softwareKey.DeleteSubKeyTree (subKeyName);
1076 Assert.Fail ("#B1");
1077 } catch (ArgumentException ex) {
1078 // 1.x: Registry subkeys should not be
1079 // greater than or equal to 255 characters
1080 //
1081 // 2.x: Registry subkeys should not be
1082 // greater than 255 characters
1083 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1084 Assert.IsNull (ex.InnerException, "#B3");
1085 Assert.IsNotNull (ex.Message, "#B4");
1086 Assert.IsTrue (ex.Message.IndexOf ("255") != -1, "#B5");
1087 Assert.IsNull (ex.ParamName, "#B6");
1088 }
1089 }
1090 }
1091
1092 [Test]
1093 public void DeleteSubKeyTree_Name_Null ()
1094 {
1095 using (RegistryKey softwareKey = Registry.CurrentUser.OpenSubKey ("software", true)) {
1096 try {
1097 softwareKey.DeleteSubKeyTree (null);
1098 Assert.Fail ("#1");
1099 } catch (ArgumentNullException ex) {
1100 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1101 Assert.IsNull (ex.InnerException, "#3");
1102 Assert.IsNotNull (ex.Message, "#4");
1103 Assert.AreEqual ("name", ex.ParamName, "#5");
1104 }
1105 }
1106 }
1107
1108 [Test]
1109 public void DeleteValue ()
1110 {
1111 string subKeyName = Guid.NewGuid ().ToString ();
1112
1113 try {
1114 using (RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName)) {
1115 // check if key was successfully created
1116 Assert.IsNotNull (createdKey, "#A1");
1117 createdKey.SetValue ("name1", "value1");
1118 createdKey.SetValue ("name2", "value2");
1119 string [] names = createdKey.GetValueNames ();
1120 Assert.IsNotNull (names, "#A2");
1121 Assert.AreEqual (2, names.Length, "#A3");
1122 Assert.IsNotNull (names [0], "#A4");
1123 Assert.AreEqual ("name1", names [0], "#A5");
1124 Assert.IsNotNull (createdKey.GetValue ("name1"), "#A6");
1125 Assert.AreEqual ("value1", createdKey.GetValue ("name1"), "#A7");
1126 Assert.AreEqual ("name2", names [1], "#A8");
1127 Assert.IsNotNull (createdKey.GetValue ("name2"), "#A9");
1128 Assert.AreEqual ("value2", createdKey.GetValue ("name2"), "#A10");
1129 }
1130 using (RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName, true)) {
1131 Assert.IsNotNull (createdKey, "#B1");
1132 createdKey.DeleteValue ("name1");
1133 string [] names = createdKey.GetValueNames ();
1134 Assert.IsNotNull (names, "#B2");
1135 Assert.AreEqual (1, names.Length, "#B3");
1136 Assert.IsNotNull (names [0], "#B4");
1137 Assert.AreEqual ("name2", names [0], "#B5");
1138 Assert.IsNotNull (createdKey.GetValue ("name2"), "#B6");
1139 Assert.AreEqual ("value2", createdKey.GetValue ("name2"), "#B7");
1140 createdKey.DeleteValue (new string ('a', 400), false);
1141 }
1142 using (RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName)) {
1143 string [] names = createdKey.GetValueNames ();
1144 Assert.IsNotNull (names, "#C1");
1145 Assert.AreEqual (1, names.Length, "#C2");
1146 Assert.IsNotNull (names [0], "#C3");
1147 Assert.AreEqual ("name2", names [0], "#C4");
1148 Assert.IsNotNull (createdKey.GetValue ("name2"), "#C5");
1149 Assert.AreEqual ("value2", createdKey.GetValue ("name2"), "#C6");
1150 }
1151 } finally {
1152 try {
1153 RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName);
1154 if (createdKey != null) {
1155 createdKey.Close ();
1156 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
1157 }
1158 } catch {
1159 }
1160 }
1161 }
1162
1163 [Test]
1164 public void DeleteValue_Key_ReadOnly ()
1165 {
1166 string subKeyName = Guid.NewGuid ().ToString ();
1167
1168 try {
1169 using (RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName)) {
1170 createdKey.SetValue ("name1", "value1");
1171 }
1172
1173 using (RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName)) {
1174 try {
1175 // deleting value that exists
1176 createdKey.DeleteValue ("name1");
1177 Assert.Fail ("#A1");
1178 } catch (UnauthorizedAccessException ex) {
1179 // Cannot write to the registry key
1180 Assert.AreEqual (typeof (UnauthorizedAccessException), ex.GetType (), "#A2");
1181 Assert.IsNotNull (ex.Message, "#A3");
1182 Assert.IsNull (ex.InnerException, "#A4");
1183 }
1184
1185 try {
1186 // deleting value that exists
1187 createdKey.DeleteValue ("name1", true);
1188 Assert.Fail ("#B1");
1189 } catch (UnauthorizedAccessException ex) {
1190 // Cannot write to the registry key
1191 Assert.AreEqual (typeof (UnauthorizedAccessException), ex.GetType (), "#B2");
1192 Assert.IsNotNull (ex.Message, "#B3");
1193 Assert.IsNull (ex.InnerException, "#B4");
1194 }
1195
1196 try {
1197 // deleting value that exists
1198 createdKey.DeleteValue ("name1", false);
1199 Assert.Fail ("#C1");
1200 } catch (UnauthorizedAccessException ex) {
1201 // Cannot write to the registry key
1202 Assert.AreEqual (typeof (UnauthorizedAccessException), ex.GetType (), "#C2");
1203 Assert.IsNotNull (ex.Message, "#C3");
1204 Assert.IsNull (ex.InnerException, "#C4");
1205 }
1206
1207 try {
1208 // deleting value that does not exist
1209 createdKey.DeleteValue ("name2");
1210 Assert.Fail ("#D1");
1211 } catch (UnauthorizedAccessException ex) {
1212 // Cannot write to the registry key
1213 Assert.AreEqual (typeof (UnauthorizedAccessException), ex.GetType (), "#D2");
1214 Assert.IsNotNull (ex.Message, "#D3");
1215 Assert.IsNull (ex.InnerException, "#D4");
1216 }
1217
1218 try {
1219 // deleting value that does not exist
1220 createdKey.DeleteValue ("name2", true);
1221 Assert.Fail ("#E1");
1222 } catch (UnauthorizedAccessException ex) {
1223 // Cannot write to the registry key
1224 Assert.AreEqual (typeof (UnauthorizedAccessException), ex.GetType (), "#E2");
1225 Assert.IsNotNull (ex.Message, "#E3");
1226 Assert.IsNull (ex.InnerException, "#E4");
1227 }
1228
1229 try {
1230 // deleting value that does not exist
1231 createdKey.DeleteValue ("name2", false);
1232 Assert.Fail ("#F1");
1233 } catch (UnauthorizedAccessException ex) {
1234 // Cannot write to the registry key
1235 Assert.AreEqual (typeof (UnauthorizedAccessException), ex.GetType (), "#F2");
1236 Assert.IsNotNull (ex.Message, "#F3");
1237 Assert.IsNull (ex.InnerException, "#F4");
1238 }
1239 }
1240 } finally {
1241 try {
1242 RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName);
1243 if (createdKey != null) {
1244 createdKey.Close ();
1245 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
1246 }
1247 } catch {
1248 }
1249 }
1250 }
1251
1252 [Test]
1253 public void DeleteValue_Key_Removed ()
1254 {
1255 string subKeyName = Guid.NewGuid ().ToString ();
1256
1257 try {
1258 using (RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName)) {
1259 // check if key was successfully created
1260 Assert.IsNotNull (createdKey, "#1");
1261 createdKey.SetValue ("name1", "value1");
1262 }
1263 using (RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName, true)) {
1264 Assert.IsNotNull (createdKey, "#2");
1265 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
1266 Assert.IsNull (Registry.CurrentUser.OpenSubKey (subKeyName), "#3");
1267
1268 createdKey.DeleteValue ("name1");
1269 createdKey.DeleteValue ("name1", true);
1270 createdKey.DeleteValue ("name1", false);
1271 }
1272 } finally {
1273 try {
1274 RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName);
1275 if (createdKey != null) {
1276 createdKey.Close ();
1277 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
1278 }
1279 } catch {
1280 }
1281 }
1282 }
1283
1284 [Test]
1285 public void DeleteValue_Value_DoesNotExist ()
1286 {
1287 string subKeyName = Guid.NewGuid ().ToString ();
1288
1289 try {
1290 using (RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName)) {
1291 // check if key was successfully created
1292 Assert.IsNotNull (createdKey, "#A1");
1293 createdKey.SetValue ("name1", "value1");
1294
1295 try {
1296 createdKey.DeleteValue ("name2");
1297 Assert.Fail ("#B1");
1298 } catch (ArgumentException ex) {
1299 // No value exists with that name
1300 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1301 Assert.IsNull (ex.InnerException, "#B3");
1302 Assert.IsNotNull (ex.Message, "#B4");
1303 Assert.IsNull (ex.ParamName, "#B5");
1304 }
1305
1306 try {
1307 createdKey.DeleteValue ("name2", true);
1308 Assert.Fail ("#C1");
1309 } catch (ArgumentException ex) {
1310 // No value exists with that name
1311 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
1312 Assert.IsNull (ex.InnerException, "#C3");
1313 Assert.IsNotNull (ex.Message, "#C4");
1314 Assert.IsNull (ex.ParamName, "#C5");
1315 }
1316
1317 createdKey.DeleteValue ("name2", false);
1318 }
1319 } finally {
1320 try {
1321 RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName);
1322 if (createdKey != null) {
1323 createdKey.Close ();
1324 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
1325 }
1326 } catch {
1327 }
1328 }
1329 }
1330
1331 [Test]
1332 public void DeleteValue_Name_Empty ()
1333 {
1334 string subKeyName = Guid.NewGuid ().ToString ();
1335
1336 try {
1337 using (RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName)) {
1338 createdKey.SetValue ("name1", "value1");
1339 createdKey.SetValue (string.Empty, "value2");
1340
1341 string [] names = createdKey.GetValueNames ();
1342 Assert.IsNotNull (names, "#A1");
1343 Assert.AreEqual (2, names.Length, "#A2");
1344 Assert.IsNotNull (names [0], "#A3");
1345 /*
1346 Assert.AreEqual ("name1", names [0], "#A4");
1347 */
1348 Assert.IsNotNull (createdKey.GetValue ("name1"), "#A5");
1349 Assert.AreEqual ("value1", createdKey.GetValue ("name1"), "#A6");
1350 Assert.IsNotNull (names [1], "#A7");
1351 /*
1352 Assert.AreEqual (string.Empty, names [1], "#A8");
1353 */
1354 Assert.IsNotNull (createdKey.GetValue (string.Empty), "#A9");
1355 Assert.AreEqual ("value2", createdKey.GetValue (string.Empty), "#A10");
1356
1357 createdKey.DeleteValue (string.Empty);
1358
1359 names = createdKey.GetValueNames ();
1360 Assert.IsNotNull (names, "#B1");
1361 Assert.AreEqual (1, names.Length, "#B2");
1362 Assert.IsNotNull (names [0], "#B3");
1363 Assert.AreEqual ("name1", names [0], "#B4");
1364 Assert.IsNotNull (createdKey.GetValue ("name1"), "#B5");
1365 Assert.AreEqual ("value1", createdKey.GetValue ("name1"), "#B6");
1366
1367 try {
1368 createdKey.DeleteValue (string.Empty);
1369 Assert.Fail ("#C1");
1370 } catch (ArgumentException ex) {
1371 // No value exists with that name
1372 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
1373 Assert.IsNull (ex.InnerException, "#C3");
1374 Assert.IsNotNull (ex.Message, "#C4");
1375 Assert.IsNull (ex.ParamName, "#C5");
1376 }
1377
1378 try {
1379 createdKey.DeleteValue (string.Empty, true);
1380 Assert.Fail ("#D1");
1381 } catch (ArgumentException ex) {
1382 // No value exists with that name
1383 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#D2");
1384 Assert.IsNull (ex.InnerException, "#D3");
1385 Assert.IsNotNull (ex.Message, "#D4");
1386 Assert.IsNull (ex.ParamName, "#D5");
1387 }
1388
1389 createdKey.DeleteValue (string.Empty, false);
1390
1391 names = createdKey.GetValueNames ();
1392 Assert.IsNotNull (names, "#E1");
1393 Assert.AreEqual (1, names.Length, "#E2");
1394 Assert.IsNotNull (names [0], "#E3");
1395 Assert.AreEqual ("name1", names [0], "#E4");
1396 Assert.IsNotNull (createdKey.GetValue ("name1"), "#E5");
1397 Assert.AreEqual ("value1", createdKey.GetValue ("name1"), "#E6");
1398 }
1399 } finally {
1400 try {
1401 RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName);
1402 if (createdKey != null) {
1403 createdKey.Close ();
1404 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
1405 }
1406 } catch {
1407 }
1408 }
1409 }
1410
1411 [Test]
1412 public void DeleteValue_Name_Null ()
1413 {
1414 string subKeyName = Guid.NewGuid ().ToString ();
1415
1416 try {
1417 using (RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName)) {
1418 createdKey.SetValue ("name1", "value1");
1419 createdKey.SetValue (null, "value2");
1420
1421 string [] names = createdKey.GetValueNames ();
1422 Assert.IsNotNull (names, "#A1");
1423 Assert.AreEqual (2, names.Length, "#A2");
1424 Assert.IsNotNull (names [0], "#A3");
1425 /*
1426 Assert.AreEqual ("name1", names [0], "#A4");
1427 */
1428 Assert.IsNotNull (createdKey.GetValue ("name1"), "#A5");
1429 Assert.AreEqual ("value1", createdKey.GetValue ("name1"), "#A6");
1430 Assert.IsNotNull (names [1], "#A7");
1431 /*
1432 Assert.AreEqual (string.Empty, names [1], "#A8");
1433 */
1434 Assert.IsNotNull (createdKey.GetValue (null), "#A9");
1435 Assert.AreEqual ("value2", createdKey.GetValue (null), "#A10");
1436
1437 try {
1438 createdKey.DeleteValue (null);
1439 Assert.Fail ("#B1");
1440 } catch (ArgumentNullException ex) {
1441 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
1442 Assert.IsNull (ex.InnerException, "#B3");
1443 Assert.IsNotNull (ex.Message, "#B4");
1444 Assert.AreEqual ("name", ex.ParamName, "#B5");
1445 }
1446
1447 try {
1448 createdKey.DeleteValue (null, true);
1449 Assert.Fail ("#C1");
1450 } catch (ArgumentNullException ex) {
1451 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#C2");
1452 Assert.IsNull (ex.InnerException, "#C3");
1453 Assert.IsNotNull (ex.Message, "#C4");
1454 Assert.AreEqual ("name", ex.ParamName, "#C5");
1455 }
1456
1457 try {
1458 createdKey.DeleteValue (null, false);
1459 Assert.Fail ("#D1");
1460 } catch (ArgumentNullException ex) {
1461 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#D2");
1462 Assert.IsNull (ex.InnerException, "#D3");
1463 Assert.IsNotNull (ex.Message, "#D4");
1464 Assert.AreEqual ("name", ex.ParamName, "#D5");
1465 }
1466 }
1467 } finally {
1468 try {
1469 RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName);
1470 if (createdKey != null) {
1471 createdKey.Close ();
1472 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
1473 }
1474 } catch {
1475 }
1476 }
1477 }
1478
1479 [Test]
1480 public void GetValue ()
1481 {
1482 string subKeyName = Guid.NewGuid ().ToString ();
1483
1484 try {
1485 using (RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName)) {
1486 createdKey.SetValue ("name1", "value1");
1487 createdKey.SetValue ("name2", "value2");
1488 }
1489
1490 using (RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName)) {
1491 Assert.IsNotNull (createdKey.GetValue ("name1"), "#1");
1492 Assert.AreEqual ("value1", createdKey.GetValue ("name1"), "#2");
1493 Assert.IsNotNull (createdKey.GetValue ("name2"), "#3");
1494 Assert.AreEqual ("value2", createdKey.GetValue ("name2"), "#4");
1495 Assert.IsNull (createdKey.GetValue ("name3"), "#5");
1496 Assert.AreEqual ("value3", createdKey.GetValue ("name3", "value3"), "#6");
1497 Assert.IsNull (createdKey.GetValue ("name3", null), "#7");
1498 Assert.IsNull (createdKey.GetValue (new string ('a', 400)), "#8");
1499 }
1500 } finally {
1501 try {
1502 RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName);
1503 if (createdKey != null) {
1504 createdKey.Close ();
1505 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
1506 }
1507 } catch {
1508 }
1509 }
1510 }
1511
1512 [Test]
1513 public void GetValue_Key_Removed ()
1514 {
1515 string subKeyName = Guid.NewGuid ().ToString ();
1516
1517 try {
1518 using (RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName)) {
1519 createdKey.SetValue ("name1", "value1");
1520 createdKey.SetValue ("name2", "value2");
1521 }
1522
1523 using (RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName)) {
1524 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
1525
1526 Assert.IsNull (createdKey.GetValue ("name1"), "#1");
1527 Assert.IsNotNull (createdKey.GetValue ("name1", "default"), "#2");
1528 Assert.AreEqual ("default", createdKey.GetValue ("name1", "default"), "#3");
1529 Assert.IsNull (createdKey.GetValue ("name3"), "#3");
1530 Assert.IsNotNull (createdKey.GetValue ("name3", "default"), "#4");
1531 Assert.AreEqual ("default", createdKey.GetValue ("name3", "default"), "#5");
1532 }
1533 } finally {
1534 try {
1535 RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName);
1536 if (createdKey != null) {
1537 createdKey.Close ();
1538 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
1539 }
1540 } catch {
1541 }
1542 }
1543 }
1544
1545 [Test]
1546 public void GetValue_Name_Empty ()
1547 {
1548 string subKeyName = Guid.NewGuid ().ToString ();
1549
1550 try {
1551 using (RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName)) {
1552 createdKey.SetValue ("name1", "value1");
1553 createdKey.SetValue ("name2", "value2");
1554
1555 Assert.IsNull (createdKey.GetValue (string.Empty), "#A1");
1556 Assert.IsNotNull (createdKey.GetValue (string.Empty, "default"), "#A2");
1557 Assert.AreEqual ("default", createdKey.GetValue (string.Empty, "default"), "#A3");
1558 Assert.IsNull (createdKey.GetValue (string.Empty, null), "#A4");
1559 }
1560
1561 using (RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName)) {
1562 Assert.IsNull (createdKey.GetValue (string.Empty), "#B1");
1563 Assert.IsNotNull (createdKey.GetValue (string.Empty, "default"), "#B2");
1564 Assert.AreEqual ("default", createdKey.GetValue (string.Empty, "default"), "#B3");
1565 Assert.IsNull (createdKey.GetValue (string.Empty, null), "#B4");
1566 }
1567
1568 using (RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName, true)) {
1569 createdKey.SetValue (string.Empty, "value1");
1570 Assert.IsNotNull (createdKey.GetValue (string.Empty), "#C1");
1571 Assert.AreEqual ("value1", createdKey.GetValue (string.Empty), "#C2");
1572 Assert.AreEqual ("value1", createdKey.GetValue (string.Empty, "default"), "#C3");
1573 Assert.AreEqual ("value1", createdKey.GetValue (string.Empty, null), "#C4");
1574 }
1575
1576 using (RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName)) {
1577 Assert.IsNotNull (createdKey.GetValue (string.Empty), "#D1");
1578 Assert.AreEqual ("value1", createdKey.GetValue (string.Empty), "#D2");
1579 Assert.AreEqual ("value1", createdKey.GetValue (string.Empty, "default"), "#D3");
1580 Assert.AreEqual ("value1", createdKey.GetValue (string.Empty, null), "#D4");
1581 }
1582 } finally {
1583 try {
1584 RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName);
1585 if (createdKey != null) {
1586 createdKey.Close ();
1587 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
1588 }
1589 } catch {
1590 }
1591 }
1592 }
1593
1594 [Test]
1595 public void GetValue_Name_Null ()
1596 {
1597 string subKeyName = Guid.NewGuid ().ToString ();
1598
1599 try {
1600 using (RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName)) {
1601 createdKey.SetValue ("name1", "value1");
1602 createdKey.SetValue ("name2", "value2");
1603
1604 Assert.IsNull (createdKey.GetValue (null), "#A1");
1605 Assert.IsNotNull (createdKey.GetValue (null, "default"), "#A2");
1606 Assert.AreEqual ("default", createdKey.GetValue (null, "default"), "#A3");
1607 Assert.IsNull (createdKey.GetValue (null, null), "#A4");
1608 }
1609
1610 using (RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName)) {
1611 Assert.IsNull (createdKey.GetValue (null), "#B1");
1612 Assert.IsNotNull (createdKey.GetValue (null, "default"), "#B2");
1613 Assert.AreEqual ("default", createdKey.GetValue (null, "default"), "#B3");
1614 Assert.IsNull (createdKey.GetValue (null, null), "#B4");
1615 }
1616
1617 using (RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName, true)) {
1618 createdKey.SetValue (string.Empty, "value1");
1619 Assert.IsNotNull (createdKey.GetValue (null), "#C1");
1620 Assert.AreEqual ("value1", createdKey.GetValue (null), "#C2");
1621 Assert.AreEqual ("value1", createdKey.GetValue (null, "default"), "#C3");
1622 Assert.AreEqual ("value1", createdKey.GetValue (null, null), "#C4");
1623 }
1624
1625 using (RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName)) {
1626 Assert.IsNotNull (createdKey.GetValue (null), "#D1");
1627 Assert.AreEqual ("value1", createdKey.GetValue (null), "#D2");
1628 Assert.AreEqual ("value1", createdKey.GetValue (null, "default"), "#D3");
1629 Assert.AreEqual ("value1", createdKey.GetValue (null, null), "#D4");
1630 }
1631 } finally {
1632 try {
1633 RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName);
1634 if (createdKey != null) {
1635 createdKey.Close ();
1636 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
1637 }
1638 } catch {
1639 }
1640 }
1641 }
1642
1643 [Test]
1644 public void GetValue_Expand ()
1645 {
1646 string subKeyName = Guid.NewGuid ().ToString ();
1647
1648 try {
1649 using (RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName)) {
1650 Environment.SetEnvironmentVariable ("MONO_TEST1", "123");
1651 Environment.SetEnvironmentVariable ("MONO_TEST2", "456");
1652
1653 createdKey.SetValue ("name1", "%MONO_TEST1%/%MONO_TEST2%",
1654 RegistryValueKind.ExpandString);
1655 createdKey.SetValue ("name2", "%MONO_TEST1%/%MONO_TEST2%");
1656 createdKey.SetValue ("name3", "just some text",
1657 RegistryValueKind.ExpandString);
1658
1659 Assert.AreEqual ("123/456", createdKey.GetValue ("name1"), "#A1");
1660 Assert.AreEqual ("%MONO_TEST1%/%MONO_TEST2%", createdKey.GetValue ("name2"), "#A2");
1661 Assert.AreEqual ("just some text", createdKey.GetValue ("name3"), "#A3");
1662 Assert.AreEqual ("%MONO_TEST1%/%MONO_TEST2%", createdKey.GetValue ("name1",
1663 null, RegistryValueOptions.DoNotExpandEnvironmentNames), "#A4");
1664 Assert.AreEqual ("%MONO_TEST1%/%MONO_TEST2%", createdKey.GetValue ("name2",
1665 null, RegistryValueOptions.DoNotExpandEnvironmentNames), "#A5");
1666 Assert.AreEqual ("just some text", createdKey.GetValue ("name3",
1667 null, RegistryValueOptions.DoNotExpandEnvironmentNames), "#A6");
1668 Assert.AreEqual ("123/456", createdKey.GetValue ("name1",
1669 null, RegistryValueOptions.None), "#A7");
1670 Assert.AreEqual ("%MONO_TEST1%/%MONO_TEST2%", createdKey.GetValue ("name2",
1671 null, RegistryValueOptions.None), "#A8");
1672 Assert.AreEqual ("just some text", createdKey.GetValue ("name3",
1673 null, RegistryValueOptions.None), "#A9");
1674
1675 Environment.SetEnvironmentVariable ("MONO_TEST1", "789");
1676 Environment.SetEnvironmentVariable ("MONO_TEST2", "666");
1677
1678 Assert.AreEqual ("789/666", createdKey.GetValue ("name1"), "#B1");
1679 Assert.AreEqual ("%MONO_TEST1%/%MONO_TEST2%", createdKey.GetValue ("name2"), "#B2");
1680 Assert.AreEqual ("just some text", createdKey.GetValue ("name3"), "#B3");
1681 Assert.AreEqual ("%MONO_TEST1%/%MONO_TEST2%", createdKey.GetValue ("name1",
1682 null, RegistryValueOptions.DoNotExpandEnvironmentNames), "#B4");
1683 Assert.AreEqual ("%MONO_TEST1%/%MONO_TEST2%", createdKey.GetValue ("name2",
1684 null, RegistryValueOptions.DoNotExpandEnvironmentNames), "#B5");
1685 Assert.AreEqual ("just some text", createdKey.GetValue ("name3",
1686 null, RegistryValueOptions.DoNotExpandEnvironmentNames), "#B6");
1687 Assert.AreEqual ("789/666", createdKey.GetValue ("name1",
1688 null, RegistryValueOptions.None), "#B7");
1689 Assert.AreEqual ("%MONO_TEST1%/%MONO_TEST2%", createdKey.GetValue ("name2",
1690 null, RegistryValueOptions.None), "#B8");
1691 Assert.AreEqual ("just some text", createdKey.GetValue ("name3",
1692 null, RegistryValueOptions.None), "#B9");
1693 }
1694 using (RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName)) {
1695 Assert.AreEqual ("789/666", createdKey.GetValue ("name1"), "#C1");
1696 Assert.AreEqual ("%MONO_TEST1%/%MONO_TEST2%", createdKey.GetValue ("name2"), "#C2");
1697 Assert.AreEqual ("just some text", createdKey.GetValue ("name3"), "#C3");
1698 Assert.AreEqual ("%MONO_TEST1%/%MONO_TEST2%", createdKey.GetValue ("name1",
1699 null, RegistryValueOptions.DoNotExpandEnvironmentNames), "#C4");
1700 Assert.AreEqual ("%MONO_TEST1%/%MONO_TEST2%", createdKey.GetValue ("name2",
1701 null, RegistryValueOptions.DoNotExpandEnvironmentNames), "#C5");
1702 Assert.AreEqual ("just some text", createdKey.GetValue ("name3",
1703 null, RegistryValueOptions.DoNotExpandEnvironmentNames), "#C6");
1704 Assert.AreEqual ("789/666", createdKey.GetValue ("name1",
1705 null, RegistryValueOptions.None), "#C7");
1706 Assert.AreEqual ("%MONO_TEST1%/%MONO_TEST2%", createdKey.GetValue ("name2",
1707 null, RegistryValueOptions.None), "#C8");
1708 Assert.AreEqual ("just some text", createdKey.GetValue ("name3",
1709 null, RegistryValueOptions.None), "#C9");
1710
1711 Environment.SetEnvironmentVariable ("MONO_TEST1", "123");
1712 Environment.SetEnvironmentVariable ("MONO_TEST2", "456");
1713
1714 Assert.AreEqual ("123/456", createdKey.GetValue ("name1"), "#D1");
1715 Assert.AreEqual ("%MONO_TEST1%/%MONO_TEST2%", createdKey.GetValue ("name2"), "#D2");
1716 Assert.AreEqual ("just some text", createdKey.GetValue ("name3"), "#D3");
1717 Assert.AreEqual ("%MONO_TEST1%/%MONO_TEST2%", createdKey.GetValue ("name1",
1718 null, RegistryValueOptions.DoNotExpandEnvironmentNames), "#D4");
1719 Assert.AreEqual ("%MONO_TEST1%/%MONO_TEST2%", createdKey.GetValue ("name2",
1720 null, RegistryValueOptions.DoNotExpandEnvironmentNames), "#D5");
1721 Assert.AreEqual ("just some text", createdKey.GetValue ("name3",
1722 null, RegistryValueOptions.DoNotExpandEnvironmentNames), "#D6");
1723 Assert.AreEqual ("123/456", createdKey.GetValue ("name1",
1724 null, RegistryValueOptions.None), "#D7");
1725 Assert.AreEqual ("%MONO_TEST1%/%MONO_TEST2%", createdKey.GetValue ("name2",
1726 null, RegistryValueOptions.None), "#D8");
1727 Assert.AreEqual ("just some text", createdKey.GetValue ("name3",
1728 null, RegistryValueOptions.None), "#D9");
1729 }
1730 } finally {
1731 try {
1732 RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName);
1733 if (createdKey != null) {
1734 createdKey.Close ();
1735 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
1736 }
1737 } catch {
1738 }
1739 }
1740 }
1741
1742 [Test]
1743 public void GetValueNames ()
1744 {
1745 string subKeyName = Guid.NewGuid ().ToString ();
1746
1747 try {
1748 using (RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName)) {
1749 string [] names = createdKey.GetValueNames ();
1750 Assert.IsNotNull (names, "#A1");
1751 Assert.AreEqual (0, names.Length, "#A2");
1752
1753 createdKey.SetValue ("name1", "value1");
1754 createdKey.SetValue ("name2", "value2");
1755 createdKey.SetValue ("namelong", "value3");
1756 createdKey.SetValue ("name3", "value4");
1757
1758 Assert.AreEqual (4, createdKey.ValueCount, "#B1");
1759 names = createdKey.GetValueNames ();
1760 Assert.IsNotNull (names, "#B2");
1761 Assert.AreEqual (4, names.Length, "#B3");
1762 }
1763
1764 using (RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName, true)) {
1765 string [] names = createdKey.GetValueNames ();
1766 Assert.IsNotNull (names, "#C1");
1767 Assert.AreEqual (4, names.Length, "#C2");
1768
1769 // Mono's Unix registry API uses a hashtable to store the
1770 // values (and their names), so names are not returned in
1771 // order
1772 //
1773 // to test whether the names returned by GetValueNames
1774 // match what we expect, we use these names to remove the
1775 // the values from the created keys and such we should end
1776 // up with zero values
1777 for (int i = 0; i < names.Length; i++) {
1778 string valueName = names [i];
1779 createdKey.DeleteValue (valueName);
1780 }
1781
1782 // all values should be removed now
1783 Assert.AreEqual (0, createdKey.ValueCount, "#C3");
1784 }
1785 } finally {
1786 try {
1787 RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName);
1788 if (createdKey != null) {
1789 createdKey.Close ();
1790 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
1791 }
1792 } catch {
1793 }
1794 }
1795 }
1796
1797 [Test]
1798 public void GetValueNames_Key_Removed ()
1799 {
1800 string subKeyName = Guid.NewGuid ().ToString ();
1801
1802 try {
1803 using (RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName)) {
1804 createdKey.SetValue ("name1", "value1");
1805 createdKey.SetValue ("name2", "value2");
1806
1807 string [] names = createdKey.GetValueNames ();
1808 Assert.IsNotNull (names, "#A1");
1809 Assert.AreEqual (2, names.Length, "#A2");
1810 }
1811
1812 using (RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName)) {
1813 string [] names = createdKey.GetValueNames ();
1814 Assert.IsNotNull (names, "#B1");
1815 Assert.AreEqual (2, names.Length, "#B2");
1816
1817 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
1818
1819 try {
1820 createdKey.GetValueNames ();
1821 Assert.Fail ("#C1");
1822 } catch (IOException ex) {
1823 // Illegal operation attempted on a registry key that
1824 // has been marked for deletion
1825 Assert.AreEqual (typeof (IOException), ex.GetType (), "#C2");
1826 Assert.IsNotNull (ex.Message, "#C3");
1827 Assert.IsNull (ex.InnerException, "#C4");
1828 }
1829 }
1830 } finally {
1831 try {
1832 RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName);
1833 if (createdKey != null) {
1834 createdKey.Close ();
1835 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
1836 }
1837 } catch {
1838 }
1839 }
1840 }
1841
1842 [Test] // bug #78519
1843 public void GetSubKeyNamesTest ()
1844 {
1845 string subKeyName = Guid.NewGuid ().ToString ();
1846
1847 RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName);
1848 try {
1849 // check if key was successfully created
1850 Assert.IsNotNull (createdKey, "#A");
1851
1852 RegistryKey subKey = createdKey.CreateSubKey ("foo");
1853 Assert.IsNotNull (subKey, "#B1");
1854 Assert.AreEqual (1, createdKey.SubKeyCount, "#B2");
1855 string[] subKeyNames = createdKey.GetSubKeyNames ();
1856 Assert.IsNotNull (subKeyNames, "#B3");
1857 Assert.AreEqual (1, subKeyNames.Length, "#B4");
1858 Assert.AreEqual ("foo", subKeyNames[0], "#B5");
1859
1860 subKey = createdKey.CreateSubKey ("longfoo");
1861 Assert.IsNotNull (subKey, "#C1");
1862 Assert.AreEqual (2, createdKey.SubKeyCount, "#C2");
1863 subKeyNames = createdKey.GetSubKeyNames ();
1864 Assert.IsNotNull (subKeyNames, "#C3");
1865 Assert.AreEqual (2, subKeyNames.Length, "#C4");
1866 Assert.AreEqual ("foo", subKeyNames [0], "#C5");
1867 Assert.AreEqual ("longfoo", subKeyNames [1], "#C6");
1868
1869 subKey = createdKey.CreateSubKey ("sfoo");
1870 Assert.IsNotNull (subKey, "#D1");
1871 Assert.AreEqual (3, createdKey.SubKeyCount, "#D2");
1872 subKeyNames = createdKey.GetSubKeyNames ();
1873 Assert.IsNotNull (subKeyNames, "#D3");
1874 Assert.AreEqual (3, subKeyNames.Length, "#D4");
1875 Assert.AreEqual ("foo", subKeyNames [0], "#D5");
1876 Assert.AreEqual ("longfoo", subKeyNames [1], "#D6");
1877 Assert.AreEqual ("sfoo", subKeyNames [2], "#D7");
1878
1879 foreach (string name in subKeyNames) {
1880 createdKey.DeleteSubKeyTree (name);
1881 }
1882 Assert.AreEqual (0, createdKey.SubKeyCount, "#E");
1883 } finally {
1884 // clean-up
1885 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
1886 }
1887 }
1888
1889 [Test]
1890 public void OpenRemoteBaseKey ()
1891 {
1892 // access to registry of remote machines is not implemented on unix
1893 if (RunningOnUnix)
1894 return;
1895
1896 RegistryKey hive = RegistryKey.OpenRemoteBaseKey (
1897 RegistryHive.CurrentUser, Environment.MachineName);
1898 Assert.IsNotNull (hive, "#1");
1899
1900 RegistryKey key = hive.OpenSubKey ("SOFTWARE");
1901 Assert.IsNotNull (key, "#2");
1902 key.Close ();
1903
1904 hive.Close ();
1905 }
1906
1907 [Test]
1908 public void OpenRemoteBaseKey_MachineName_Null ()
1909 {
1910 try {
1911 RegistryKey.OpenRemoteBaseKey (RegistryHive.CurrentUser, null);
1912 Assert.Fail ("#1");
1913 } catch (ArgumentNullException ex) {
1914 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1915 Assert.IsNull (ex.InnerException, "#3");
1916 Assert.IsNotNull (ex.Message, "#4");
1917 Assert.AreEqual ("machineName", ex.ParamName, "#5");
1918 }
1919 }
1920
1921 [Test]
1922 public void OpenRemoteBaseKey_MachineName_DoesNotExist ()
1923 {
1924 // access to registry of remote machines is not implemented on unix
1925 if (RunningOnUnix)
1926 return;
1927
1928 try {
1929 RegistryKey.OpenRemoteBaseKey (RegistryHive.CurrentUser,
1930 "DOESNOTEXIST");
1931 Assert.Fail ("#1");
1932 } catch (IOException ex) {
1933 // The network path was not found
1934 Assert.AreEqual (typeof (IOException), ex.GetType (), "#2");
1935 Assert.IsNotNull (ex.Message, "#3");
1936 Assert.IsNull (ex.InnerException, "#4");
1937 }
1938 }
1939
1940 [Test] // bug #322839
1941 public void SetValue1_EntityReferences ()
1942 {
1943 string subKeyName = Guid.NewGuid ().ToString ();
1944
1945 try {
1946 using (RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName)) {
1947 // we created a new subkey, so value should not exist
1948 Assert.IsNull (createdKey.GetValue ("FirstName&\"<LastName>\""), "#A1");
1949 // create value
1950 createdKey.SetValue ("FirstName&\"<LastName>\"", "<'Miguel' & \"de Icaza\">!");
1951 // get value
1952 object name = createdKey.GetValue ("FirstName&\"<LastName>\"");
1953 // value should exist
1954 Assert.IsNotNull (name, "#A2");
1955 // type of value should be string
1956 Assert.AreEqual (typeof (string), name.GetType (), "#A3");
1957 // ensure value matches
1958 Assert.AreEqual ("<'Miguel' & \"de Icaza\">!", name, "#A4");
1959
1960 // we created a new subkey, so value should not exist
1961 Assert.IsNull (createdKey.GetValue ("Info"), "#B1");
1962 // create value
1963 createdKey.SetValue ("Info", new string [] { "Mono&<Novell>!", "<CLR&BCL>" });
1964 // get value
1965 object info = createdKey.GetValue ("Info");
1966 // value should exist
1967 Assert.IsNotNull (info, "#B2");
1968 // type of value should be string
1969 Assert.AreEqual (typeof (string []), info.GetType (), "#B3");
1970 // ensure value matches
1971 Assert.AreEqual (new string [] { "Mono&<Novell>!", "<CLR&BCL>" }, info, "#B4");
1972 }
1973
1974 using (RegistryKey openedKey = Registry.CurrentUser.OpenSubKey (subKeyName)) {
1975 object name = openedKey.GetValue ("FirstName&\"<LastName>\"");
1976 Assert.IsNotNull (name, "#C1");
1977 Assert.AreEqual (typeof (string), name.GetType (), "#C2");
1978 Assert.AreEqual ("<'Miguel' & \"de Icaza\">!", name, "#C3");
1979
1980 object info = openedKey.GetValue ("Info");
1981 Assert.IsNotNull (info, "#D1");
1982 Assert.AreEqual (typeof (string []), info.GetType (), "#D2");
1983 Assert.AreEqual (new string [] { "Mono&<Novell>!", "<CLR&BCL>" }, info, "#D3");
1984 }
1985 } finally {
1986 // clean-up
1987 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
1988 }
1989 }
1990
1991 [Test] // SetValue (String, Object)
1992 public void SetValue1_Name_Null ()
1993 {
1994 string subKeyName = Guid.NewGuid ().ToString ();
1995
1996 RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName);
1997 try {
1998 createdKey.SetValue (null, "value1");
1999 string [] names = createdKey.GetValueNames ();
2000 Assert.IsNotNull (names, "#A1");
2001 Assert.AreEqual (1, names.Length, "#A2");
2002 Assert.IsNotNull (names [0], "#A3");
2003 Assert.AreEqual (string.Empty, names [0], "#A4");
2004 Assert.IsNotNull (createdKey.GetValue (string.Empty), "#A5");
2005 Assert.AreEqual ("value1", createdKey.GetValue (string.Empty), "#A6");
2006 Assert.IsNotNull (createdKey.GetValue (null), "#A7");
2007 Assert.AreEqual ("value1", createdKey.GetValue (null), "#A8");
2008
2009 createdKey.SetValue (string.Empty, "value2");
2010 names = createdKey.GetValueNames ();
2011 Assert.IsNotNull (names, "#B1");
2012 Assert.AreEqual (1, names.Length, "#B2");
2013 Assert.IsNotNull (names [0], "#B3");
2014 Assert.AreEqual (string.Empty, names [0], "#B4");
2015 Assert.IsNotNull (createdKey.GetValue (string.Empty), "#B5");
2016 Assert.AreEqual ("value2", createdKey.GetValue (string.Empty), "#B6");
2017 Assert.IsNotNull (createdKey.GetValue (null), "#B7");
2018 Assert.AreEqual ("value2", createdKey.GetValue (null), "#B8");
2019 } finally {
2020 // clean-up
2021 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
2022 }
2023 }
2024
2025 [Test] // SetValue (String, Object)
2026 public void SetValue1_Name_Empty ()
2027 {
2028 string subKeyName = Guid.NewGuid ().ToString ();
2029
2030 RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName);
2031 try {
2032 createdKey.SetValue (string.Empty, "value1");
2033 string [] names = createdKey.GetValueNames ();
2034 Assert.IsNotNull (names, "#A1");
2035 Assert.AreEqual (1, names.Length, "#A2");
2036 Assert.IsNotNull (names [0], "#A3");
2037 Assert.AreEqual (string.Empty, names [0], "#A4");
2038 Assert.IsNotNull (createdKey.GetValue (string.Empty), "#A5");
2039 Assert.AreEqual ("value1", createdKey.GetValue (string.Empty), "#A6");
2040 Assert.IsNotNull (createdKey.GetValue (null), "#A7");
2041 Assert.AreEqual ("value1", createdKey.GetValue (null), "#A8");
2042
2043 createdKey.SetValue (null, "value2");
2044 names = createdKey.GetValueNames ();
2045 Assert.IsNotNull (names, "#B1");
2046 Assert.AreEqual (1, names.Length, "#B2");
2047 Assert.IsNotNull (names [0], "#B3");
2048 Assert.AreEqual (string.Empty, names [0], "#B4");
2049 Assert.IsNotNull (createdKey.GetValue (string.Empty), "#B5");
2050 Assert.AreEqual ("value2", createdKey.GetValue (string.Empty), "#B6");
2051 Assert.IsNotNull (createdKey.GetValue (null), "#B7");
2052 Assert.AreEqual ("value2", createdKey.GetValue (null), "#B8");
2053 } finally {
2054 // clean-up
2055 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
2056 }
2057 }
2058
2059 [Test] // SetValue (String, Object)
2060 public void SetValue1_Name_MaxLength ()
2061 {
2062 string subKeyName = Guid.NewGuid ().ToString ();
2063
2064 try {
2065 using (RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName)) {
2066 string name = new string ('a', 254);
2067
2068 createdKey.SetValue (name, "value1");
2069 Assert.IsNotNull (createdKey.GetValue (name), "#A1");
2070 createdKey.DeleteValue (name);
2071 Assert.IsNull (createdKey.GetValue (name), "#A2");
2072
2073 name = new string ('a', 255);
2074
2075 createdKey.SetValue (name, "value2");
2076 Assert.IsNotNull (createdKey.GetValue (name), "#B1");
2077 createdKey.DeleteValue (name);
2078 Assert.IsNull (createdKey.GetValue (name), "#B2");
2079
2080 name = new string ('a', 256);
2081
2082 try {
2083 createdKey.SetValue (name, "value2");
2084 Assert.Fail ("#C1");
2085 } catch (ArgumentException ex) {
2086 // 1.x: Registry subkeys should not be
2087 // greater than or equal to 255 characters
2088 //
2089 // 2.x: Registry subkeys should not be
2090 // greater than 255 characters
2091 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
2092 Assert.IsNull (ex.InnerException, "#C3");
2093 Assert.IsNotNull (ex.Message, "#C4");
2094 Assert.IsTrue (ex.Message.IndexOf ("255") != -1, "#C5");
2095 Assert.IsNull (ex.ParamName, "#C6");
2096 }
2097 }
2098 } finally {
2099 try {
2100 RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName);
2101 if (createdKey != null) {
2102 createdKey.Close ();
2103 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
2104 }
2105 } catch {
2106 }
2107 }
2108 }
2109
2110 [Test] // SetValue (String, Object)
2111 public void SetValue1_Value_Null ()
2112 {
2113 string subKeyName = Guid.NewGuid ().ToString ();
2114
2115 RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName);
2116 try {
2117 try {
2118 createdKey.SetValue ("Name", null);
2119 Assert.Fail ("#1");
2120 } catch (ArgumentNullException ex) {
2121 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
2122 Assert.IsNull (ex.InnerException, "#3");
2123 Assert.IsNotNull (ex.Message, "#4");
2124 Assert.AreEqual ("value", ex.ParamName, "#5");
2125 }
2126 } finally {
2127 // clean-up
2128 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
2129 }
2130 }
2131
2132 [Test] // SetValue (String, Object)
2133 public void SetValue1_Boolean ()
2134 {
2135 string subKeyName = Guid.NewGuid ().ToString ();
2136
2137 try {
2138 using (RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName)) {
2139 // we created a new subkey, so value should not exist
2140 Assert.IsNull (createdKey.GetValue ("Installed"), "#A1");
2141 // create value
2142 createdKey.SetValue ("Installed", true);
2143 // get value
2144 object value = createdKey.GetValue ("Installed");
2145 // value should exist
2146 Assert.IsNotNull (value, "#A2");
2147 // type of value should be string
2148 Assert.AreEqual (typeof (string), value.GetType (), "#A3");
2149 // ensure value matches
2150 Assert.AreEqual (true.ToString (), value, "#A4");
2151 }
2152
2153 using (RegistryKey openedKey = Registry.CurrentUser.OpenSubKey (subKeyName)) {
2154 object value = openedKey.GetValue ("Installed");
2155 Assert.IsNotNull (value, "#B1");
2156 Assert.AreEqual (typeof (string), value.GetType (), "#B2");
2157 Assert.AreEqual (true.ToString (), value, "#B3");
2158 }
2159 } finally {
2160 // clean-up
2161 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
2162 }
2163 }
2164
2165 [Test] // SetValue (String, Object)
2166 public void SetValue1_Byte ()
2167 {
2168 string subKeyName = Guid.NewGuid ().ToString ();
2169
2170 try {
2171 using (RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName)) {
2172 // we created a new subkey, so value should not exist
2173 Assert.IsNull (createdKey.GetValue ("Flags"), "#A1");
2174 // create value
2175 createdKey.SetValue ("Flags", (byte) 5);
2176 // get value
2177 object value = createdKey.GetValue ("Flags");
2178 // value should exist
2179 Assert.IsNotNull (value, "#A2");
2180 // type of value should be string
2181 Assert.AreEqual (typeof (string), value.GetType (), "#A3");
2182 // ensure value matches
2183 Assert.AreEqual ("5", value, "#A4");
2184 }
2185
2186 using (RegistryKey openedKey = Registry.CurrentUser.OpenSubKey (subKeyName)) {
2187 object value = openedKey.GetValue ("Flags");
2188 Assert.IsNotNull (value, "#B1");
2189 Assert.AreEqual (typeof (string), value.GetType (), "#B2");
2190 Assert.AreEqual ("5", value, "#B3");
2191 }
2192 } finally {
2193 // clean-up
2194 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
2195 }
2196 }
2197
2198 [Test] // SetValue (String, Object)
2199 public void SetValue1_ByteArray ()
2200 {
2201 string subKeyName = Guid.NewGuid ().ToString ();
2202
2203 try {
2204 using (RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName)) {
2205 // we created a new subkey, so value should not exist
2206 Assert.IsNull (createdKey.GetValue ("Flags"), "#A1");
2207 // create value
2208 createdKey.SetValue ("Flags", new byte [] { 1, 5 });
2209 // get value
2210 object value = createdKey.GetValue ("Flags");
2211 // value should exist
2212 Assert.IsNotNull (value, "#A2");
2213 // type of value should be string
2214 Assert.AreEqual (typeof (byte []), value.GetType (), "#3");
2215 // ensure value matches
2216 Assert.AreEqual (new byte [] { 1, 5 }, value, "#4");
2217 }
2218
2219 using (RegistryKey openedKey = Registry.CurrentUser.OpenSubKey (subKeyName)) {
2220 object value = openedKey.GetValue ("Flags");
2221 Assert.IsNotNull (value, "#B1");
2222 Assert.AreEqual (typeof (byte []), value.GetType (), "#B2");
2223 Assert.AreEqual (new byte [] { 1, 5 }, value, "#B3");
2224 }
2225 } finally {
2226 // clean-up
2227 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
2228 }
2229 }
2230
2231 [Test] // SetValue (String, Object)
2232 public void SetValue1_DateTime ()
2233 {
2234 string subKeyName = Guid.NewGuid ().ToString ();
2235
2236 try {
2237 object rawValue = DateTime.Now;
2238
2239 using (RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName)) {
2240 // we created a new subkey, so value should not exist
2241 Assert.IsNull (createdKey.GetValue ("Path"), "#A1");
2242 // create value
2243 createdKey.SetValue ("Path", rawValue);
2244 // get value
2245 object value = createdKey.GetValue ("Path");
2246 // value should exist
2247 Assert.IsNotNull (value, "#A2");
2248 // type of value should be string
2249 Assert.AreEqual (typeof (string), value.GetType (), "#A3");
2250 // ensure value matches
2251 Assert.AreEqual (rawValue.ToString (), value, "#A4");
2252 }
2253
2254 using (RegistryKey openedKey = Registry.CurrentUser.OpenSubKey (subKeyName)) {
2255 object value = openedKey.GetValue ("Path");
2256 Assert.IsNotNull (value, "#B1");
2257 Assert.AreEqual (typeof (string), value.GetType (), "#B2");
2258 Assert.AreEqual (rawValue.ToString (), value, "#B3");
2259 }
2260 } finally {
2261 // clean-up
2262 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
2263 }
2264 }
2265
2266 [Test]
2267 public void SetValue_Int32 ()
2268 {
2269 string subKeyName = Guid.NewGuid ().ToString ();
2270
2271 try {
2272 using (RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName)) {
2273 // we created a new subkey, so value should not exist
2274 Assert.IsNull (createdKey.GetValue ("RefCount"), "#A1");
2275 // create value
2276 createdKey.SetValue ("RefCount", 5);
2277 // get value
2278 object value = createdKey.GetValue ("RefCount");
2279 // value should exist
2280 Assert.IsNotNull (value, "#A2");
2281 // type of value should be int
2282 Assert.AreEqual (typeof (int), value.GetType (), "#A3");
2283 // ensure value matches
2284 Assert.AreEqual (5, value, "#A4");
2285 }
2286
2287 using (RegistryKey openedKey = Registry.CurrentUser.OpenSubKey (subKeyName)) {
2288 object value = openedKey.GetValue ("RefCount");
2289 Assert.IsNotNull (value, "#B1");
2290 Assert.AreEqual (typeof (int), value.GetType (), "#B2");
2291 Assert.AreEqual (5, value, "#B3");
2292 }
2293 } finally {
2294 // clean-up
2295 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
2296 }
2297 }
2298
2299 [Test] // SetValue (String, Object)
2300 public void SetValue1_Int64 ()
2301 {
2302 string subKeyName = Guid.NewGuid ().ToString ();
2303
2304 try {
2305 using (RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName)) {
2306 // we created a new subkey, so value should not exist
2307 Assert.IsNull (createdKey.GetValue ("Ticks"), "#A1");
2308 // create value
2309 createdKey.SetValue ("Ticks", 500L);
2310 // get value
2311 object value = createdKey.GetValue ("Ticks");
2312 // value should exist
2313 Assert.IsNotNull (value, "#A2");
2314 // type of value should be string
2315 Assert.AreEqual (typeof (string), value.GetType (), "#A3");
2316 // ensure value matches
2317 Assert.AreEqual ("500", value, "#A4");
2318 }
2319
2320 using (RegistryKey openedKey = Registry.CurrentUser.OpenSubKey (subKeyName)) {
2321 object value = openedKey.GetValue ("Ticks");
2322 Assert.IsNotNull (value, "#B1");
2323 Assert.AreEqual (typeof (string), value.GetType (), "#B2");
2324 Assert.AreEqual ("500", value, "#B3");
2325 }
2326 } finally {
2327 // clean-up
2328 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
2329 }
2330 }
2331
2332 [Test] // SetValue (String, Object)
2333 public void SetValue1_String ()
2334 {
2335 string subKeyName = Guid.NewGuid ().ToString ();
2336
2337 try {
2338 using (RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName)) {
2339 // we created a new subkey, so value should not exist
2340 Assert.IsNull (createdKey.GetValue ("Path"), "#A1");
2341 // create value
2342 createdKey.SetValue ("Path", "/usr/lib/whatever");
2343 // get value
2344 object path = createdKey.GetValue ("Path");
2345 // value should exist
2346 Assert.IsNotNull (path, "#A2");
2347 // type of value should be string
2348 Assert.AreEqual (typeof (string), path.GetType (), "#A3");
2349 // ensure value matches
2350 Assert.AreEqual ("/usr/lib/whatever", path, "#A4");
2351 }
2352
2353 using (RegistryKey openedKey = Registry.CurrentUser.OpenSubKey (subKeyName)) {
2354 object path = openedKey.GetValue ("Path");
2355 Assert.IsNotNull (path, "#B1");
2356 Assert.AreEqual (typeof (string), path.GetType (), "#B2");
2357 Assert.AreEqual ("/usr/lib/whatever", path, "#B3");
2358 }
2359 } finally {
2360 // clean-up
2361 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
2362 }
2363 }
2364
2365 [Test] // SetValue (String, Object)
2366 public void SetValue1_StringArray ()
2367 {
2368 string subKeyName = Guid.NewGuid ().ToString ();
2369
2370 try {
2371 using (RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName)) {
2372 // we created a new subkey, so value should not exist
2373 Assert.IsNull (createdKey.GetValue ("DependsOnGroup"), "#A1");
2374 // create value
2375 createdKey.SetValue ("DependsOnGroup", new string [] { "A", "B" });
2376 // get value
2377 object value = createdKey.GetValue ("DependsOnGroup");
2378 // value should exist
2379 Assert.IsNotNull (value, "#A2");
2380 // type of value should be string
2381 Assert.AreEqual (typeof (string []), value.GetType (), "#A3");
2382 // ensure value matches
2383 Assert.AreEqual (new string [] { "A", "B" }, value, "#A4");
2384 }
2385
2386 using (RegistryKey openedKey = Registry.CurrentUser.OpenSubKey (subKeyName)) {
2387 object value = openedKey.GetValue ("DependsOnGroup");
2388 Assert.IsNotNull (value, "#B1");
2389 Assert.AreEqual (typeof (string []), value.GetType (), "#B2");
2390 Assert.AreEqual (new string [] { "A", "B" }, value, "#B3");
2391 }
2392 } finally {
2393 // clean-up
2394 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
2395 }
2396 }
2397
2398 [Test] // SetValue (String, Object)
2399 public void SetValue1_Key_ReadOnly ()
2400 {
2401 string subKeyName = Guid.NewGuid ().ToString ();
2402
2403 using (RegistryKey softwareKey = Registry.CurrentUser.OpenSubKey ("software")) {
2404 try {
2405 softwareKey.SetValue ("name1", "value1");
2406 Assert.Fail ("#1");
2407 } catch (UnauthorizedAccessException ex) {
2408 // Cannot write to the registry key
2409 Assert.AreEqual (typeof (UnauthorizedAccessException), ex.GetType (), "#2");
2410 Assert.IsNotNull (ex.Message, "#3");
2411 Assert.IsNull (ex.InnerException, "#4");
2412 }
2413 }
2414
2415 using (RegistryKey softwareKey = Registry.CurrentUser.OpenSubKey ("software", true)) {
2416 try {
2417 using (RegistryKey createdKey = softwareKey.CreateSubKey (subKeyName)) {
2418 }
2419
2420 using (RegistryKey createdKey = softwareKey.OpenSubKey (subKeyName)) {
2421 try {
2422 createdKey.SetValue ("name1", "value1");
2423 Assert.Fail ("#1");
2424 } catch (UnauthorizedAccessException ex) {
2425 // Cannot write to the registry key
2426 Assert.AreEqual (typeof (UnauthorizedAccessException), ex.GetType (), "#2");
2427 Assert.IsNotNull (ex.Message, "#3");
2428 Assert.IsNull (ex.InnerException, "#4");
2429 }
2430 }
2431 } finally {
2432 try {
2433 RegistryKey createdKey = softwareKey.OpenSubKey (subKeyName);
2434 if (createdKey != null) {
2435 createdKey.Close ();
2436 softwareKey.DeleteSubKeyTree (subKeyName);
2437 }
2438 } catch {
2439 }
2440 }
2441 }
2442 }
2443
2444 [Test] // SetValue (String, Object)
2445 public void SetValue1_Key_Removed ()
2446 {
2447 string subKeyName = Guid.NewGuid ().ToString ();
2448
2449 using (RegistryKey softwareKey = Registry.CurrentUser.OpenSubKey ("software", true)) {
2450 try {
2451 using (RegistryKey createdKey = softwareKey.CreateSubKey (subKeyName)) {
2452 softwareKey.DeleteSubKeyTree (subKeyName);
2453 Assert.IsNull (softwareKey.OpenSubKey (subKeyName), "#1");
2454 try {
2455 createdKey.SetValue ("name1", "value1");
2456 Assert.Fail ("#2");
2457 } catch (IOException ex) {
2458 // Illegal operation attempted on a registry key that
2459 // has been marked for deletion
2460 Assert.AreEqual (typeof (IOException), ex.GetType (), "#3");
2461 Assert.IsNotNull (ex.Message, "#4");
2462 Assert.IsNull (ex.InnerException, "#5");
2463 }
2464 }
2465 } finally {
2466 try {
2467 RegistryKey createdKey = softwareKey.OpenSubKey (subKeyName);
2468 if (createdKey != null) {
2469 createdKey.Close ();
2470 softwareKey.DeleteSubKeyTree (subKeyName);
2471 }
2472 } catch {
2473 }
2474 }
2475 }
2476 }
2477
2478 [Test] // SetValue (String, Object, RegistryValueKind)
2479 public void SetValue2_Key_ReadOnly ()
2480 {
2481 string subKeyName = Guid.NewGuid ().ToString ();
2482
2483 using (RegistryKey softwareKey = Registry.CurrentUser.OpenSubKey ("software")) {
2484 try {
2485 softwareKey.SetValue ("name1", "value1",
2486 RegistryValueKind.String);
2487 Assert.Fail ("#1");
2488 } catch (UnauthorizedAccessException ex) {
2489 // Cannot write to the registry key
2490 Assert.AreEqual (typeof (UnauthorizedAccessException), ex.GetType (), "#2");
2491 Assert.IsNotNull (ex.Message, "#3");
2492 Assert.IsNull (ex.InnerException, "#4");
2493 }
2494 }
2495
2496 using (RegistryKey softwareKey = Registry.CurrentUser.OpenSubKey ("software", true)) {
2497 try {
2498 using (RegistryKey createdKey = softwareKey.CreateSubKey (subKeyName)) {
2499 }
2500
2501 using (RegistryKey createdKey = softwareKey.OpenSubKey (subKeyName)) {
2502 try {
2503 createdKey.SetValue ("name1", "value1",
2504 RegistryValueKind.String);
2505 Assert.Fail ("#1");
2506 } catch (UnauthorizedAccessException ex) {
2507 // Cannot write to the registry key
2508 Assert.AreEqual (typeof (UnauthorizedAccessException), ex.GetType (), "#2");
2509 Assert.IsNotNull (ex.Message, "#3");
2510 Assert.IsNull (ex.InnerException, "#4");
2511 }
2512 }
2513 } finally {
2514 try {
2515 RegistryKey createdKey = softwareKey.OpenSubKey (subKeyName);
2516 if (createdKey != null) {
2517 createdKey.Close ();
2518 softwareKey.DeleteSubKeyTree (subKeyName);
2519 }
2520 } catch {
2521 }
2522 }
2523 }
2524 }
2525
2526 [Test] // SetValue (String, Object, RegistryValueKind)
2527 public void SetValue2_Key_Removed ()
2528 {
2529 string subKeyName = Guid.NewGuid ().ToString ();
2530
2531 using (RegistryKey softwareKey = Registry.CurrentUser.OpenSubKey ("software", true)) {
2532 try {
2533 using (RegistryKey createdKey = softwareKey.CreateSubKey (subKeyName)) {
2534 softwareKey.DeleteSubKeyTree (subKeyName);
2535 Assert.IsNull (softwareKey.OpenSubKey (subKeyName), "#1");
2536 try {
2537 createdKey.SetValue ("name1", "value1",
2538 RegistryValueKind.String);
2539 Assert.Fail ("#2");
2540 } catch (IOException ex) {
2541 // Illegal operation attempted on a registry key that
2542 // has been marked for deletion
2543 Assert.AreEqual (typeof (IOException), ex.GetType (), "#3");
2544 Assert.IsNotNull (ex.Message, "#4");
2545 Assert.IsNull (ex.InnerException, "#5");
2546 }
2547 }
2548 } finally {
2549 try {
2550 RegistryKey createdKey = softwareKey.OpenSubKey (subKeyName);
2551 if (createdKey != null) {
2552 createdKey.Close ();
2553 softwareKey.DeleteSubKeyTree (subKeyName);
2554 }
2555 } catch {
2556 }
2557 }
2558 }
2559 }
2560
2561 [Test] // SetValue (String, Object, RegistryValueKind)
2562 public void SetValue2_Name_Empty ()
2563 {
2564 string subKeyName = Guid.NewGuid ().ToString ();
2565
2566 RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName);
2567 try {
2568 createdKey.SetValue (string.Empty, "value1",
2569 RegistryValueKind.String);
2570 string [] names = createdKey.GetValueNames ();
2571 Assert.IsNotNull (names, "#A1");
2572 Assert.AreEqual (1, names.Length, "#A2");
2573 Assert.IsNotNull (names [0], "#A3");
2574 Assert.AreEqual (string.Empty, names [0], "#A4");
2575 Assert.IsNotNull (createdKey.GetValue (string.Empty), "#A5");
2576 Assert.AreEqual ("value1", createdKey.GetValue (string.Empty), "#A6");
2577 Assert.IsNotNull (createdKey.GetValue (null), "#A7");
2578 Assert.AreEqual ("value1", createdKey.GetValue (null), "#A8");
2579
2580 createdKey.SetValue (null, "value2",
2581 RegistryValueKind.String);
2582 names = createdKey.GetValueNames ();
2583 Assert.IsNotNull (names, "#B1");
2584 Assert.AreEqual (1, names.Length, "#B2");
2585 Assert.IsNotNull (names [0], "#B3");
2586 Assert.AreEqual (string.Empty, names [0], "#B4");
2587 Assert.IsNotNull (createdKey.GetValue (string.Empty), "#B5");
2588 Assert.AreEqual ("value2", createdKey.GetValue (string.Empty), "#B6");
2589 Assert.IsNotNull (createdKey.GetValue (null), "#B7");
2590 Assert.AreEqual ("value2", createdKey.GetValue (null), "#B8");
2591 } finally {
2592 // clean-up
2593 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
2594 }
2595 }
2596
2597 [Test] // SetValue (String, Object, RegistryValueKind)
2598 public void SetValue2_Name_MaxLength ()
2599 {
2600 string subKeyName = Guid.NewGuid ().ToString ();
2601
2602 try {
2603 using (RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName)) {
2604 string name = new string ('a', 254);
2605
2606 createdKey.SetValue (name, "value1",
2607 RegistryValueKind.String);
2608 Assert.IsNotNull (createdKey.GetValue (name), "#A1");
2609 createdKey.DeleteValue (name);
2610 Assert.IsNull (createdKey.GetValue (name), "#A2");
2611
2612 name = new string ('a', 255);
2613
2614 createdKey.SetValue (name, "value2",
2615 RegistryValueKind.String);
2616 Assert.IsNotNull (createdKey.GetValue (name), "#B1");
2617 createdKey.DeleteValue (name);
2618 Assert.IsNull (createdKey.GetValue (name), "#B2");
2619
2620 name = new string ('a', 256);
2621
2622 try {
2623 createdKey.SetValue (name, "value2",
2624 RegistryValueKind.String);
2625 Assert.Fail ("#C1");
2626 } catch (ArgumentException ex) {
2627 // Registry subkeys should not be
2628 // greater than 255 characters
2629 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
2630 Assert.IsNull (ex.InnerException, "#C3");
2631 Assert.IsNotNull (ex.Message, "#C4");
2632 Assert.IsTrue (ex.Message.IndexOf ("255") != -1, "#C5");
2633 Assert.IsNull (ex.ParamName, "#C6");
2634 }
2635 }
2636 } finally {
2637 try {
2638 RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName);
2639 if (createdKey != null) {
2640 createdKey.Close ();
2641 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
2642 }
2643 } catch {
2644 }
2645 }
2646 }
2647
2648 [Test] // SetValue (String, Object, RegistryValueKind)
2649 public void SetValue2_Name_Null ()
2650 {
2651 string subKeyName = Guid.NewGuid ().ToString ();
2652
2653 RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName);
2654 try {
2655 createdKey.SetValue (null, "value1",
2656 RegistryValueKind.String);
2657 string [] names = createdKey.GetValueNames ();
2658 Assert.IsNotNull (names, "#A1");
2659 Assert.AreEqual (1, names.Length, "#A2");
2660 Assert.IsNotNull (names [0], "#A3");
2661 Assert.AreEqual (string.Empty, names [0], "#A4");
2662 Assert.IsNotNull (createdKey.GetValue (string.Empty), "#A5");
2663 Assert.AreEqual ("value1", createdKey.GetValue (string.Empty), "#A6");
2664 Assert.IsNotNull (createdKey.GetValue (null), "#A7");
2665 Assert.AreEqual ("value1", createdKey.GetValue (null), "#A8");
2666
2667 createdKey.SetValue (string.Empty, "value2",
2668 RegistryValueKind.String);
2669 names = createdKey.GetValueNames ();
2670 Assert.IsNotNull (names, "#B1");
2671 Assert.AreEqual (1, names.Length, "#B2");
2672 Assert.IsNotNull (names [0], "#B3");
2673 Assert.AreEqual (string.Empty, names [0], "#B4");
2674 Assert.IsNotNull (createdKey.GetValue (string.Empty), "#B5");
2675 Assert.AreEqual ("value2", createdKey.GetValue (string.Empty), "#B6");
2676 Assert.IsNotNull (createdKey.GetValue (null), "#B7");
2677 Assert.AreEqual ("value2", createdKey.GetValue (null), "#B8");
2678 } finally {
2679 // clean-up
2680 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
2681 }
2682 }
2683
2684 [Test] // SetValue (String, Object, RegistryValueKind)
2685 public void SetValue2_Value_Null ()
2686 {
2687 string subKeyName = Guid.NewGuid ().ToString ();
2688
2689 RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName);
2690 try {
2691 try {
2692 createdKey.SetValue ("Name", null,
2693 RegistryValueKind.String);
2694 Assert.Fail ("#1");
2695 } catch (ArgumentNullException ex) {
2696 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
2697 Assert.IsNull (ex.InnerException, "#3");
2698 Assert.IsNotNull (ex.Message, "#4");
2699 Assert.AreEqual ("value", ex.ParamName, "#5");
2700 }
2701 } finally {
2702 // clean-up
2703 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
2704 }
2705 }
2706
2707 [Test]
2708 public void SubKeyCount ()
2709 {
2710 string subKeyName = Guid.NewGuid ().ToString ();
2711
2712 try {
2713 using (RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName)) {
2714 // check if key was successfully created
2715 Assert.IsNotNull (createdKey, "#A1");
2716 using (RegistryKey subKey = createdKey.CreateSubKey ("monotemp1")) {
2717 subKey.Close ();
2718 }
2719 Assert.AreEqual (1, createdKey.SubKeyCount, "#A2");
2720 using (RegistryKey subKey = createdKey.CreateSubKey ("monotemp2")) {
2721 subKey.Close ();
2722 }
2723 Assert.AreEqual (2, createdKey.SubKeyCount, "#A3");
2724 }
2725 using (RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName)) {
2726 Assert.IsNotNull (createdKey, "#B1");
2727 Assert.AreEqual (2, createdKey.SubKeyCount, "#B2");
2728
2729 using (RegistryKey createdKey2 = Registry.CurrentUser.OpenSubKey (subKeyName, true)) {
2730 Assert.IsNotNull (createdKey2, "#B3");
2731 Assert.AreEqual (2, createdKey2.SubKeyCount, "#B4");
2732 createdKey2.DeleteSubKey ("monotemp1");
2733 Assert.AreEqual (1, createdKey2.SubKeyCount, "#B5");
2734 }
2735 Assert.AreEqual (1, createdKey.SubKeyCount, "#B6");
2736 }
2737 } finally {
2738 try {
2739 RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName);
2740 if (createdKey != null) {
2741 createdKey.Close ();
2742 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
2743 }
2744 } catch {
2745 }
2746 }
2747 }
2748
2749 [Test]
2750 public void SubKeyCount_Key_Removed ()
2751 {
2752 string subKeyName = Guid.NewGuid ().ToString ();
2753
2754 try {
2755 using (RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName)) {
2756 // check if key was successfully created
2757 Assert.IsNotNull (createdKey, "#A1");
2758 using (RegistryKey subKey = createdKey.CreateSubKey ("monotemp1")) {
2759 subKey.Close ();
2760 }
2761 Assert.AreEqual (1, createdKey.SubKeyCount, "#A2");
2762 using (RegistryKey subKey = createdKey.CreateSubKey ("monotemp2")) {
2763 subKey.Close ();
2764 }
2765 Assert.AreEqual (2, createdKey.SubKeyCount, "#A3");
2766 }
2767 using (RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName)) {
2768 Assert.IsNotNull (createdKey, "#B1");
2769 Assert.AreEqual (2, createdKey.SubKeyCount, "#B2");
2770
2771 // remove created key
2772 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
2773
2774 try {
2775 Assert.Fail ("#C1: " + createdKey.SubKeyCount);
2776 } catch (IOException ex) {
2777 // Illegal operation attempted on a registry key that
2778 // has been marked for deletion
2779 Assert.AreEqual (typeof (IOException), ex.GetType (), "#14");
2780 Assert.IsNotNull (ex.Message, "#15");
2781 Assert.IsNull (ex.InnerException, "#16");
2782 }
2783 }
2784 } finally {
2785 try {
2786 RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName);
2787 if (createdKey != null) {
2788 createdKey.Close ();
2789 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
2790 }
2791 } catch {
2792 }
2793 }
2794 }
2795
2796 [Test]
2797 public void ValueCount ()
2798 {
2799 string subKeyName = Guid.NewGuid ().ToString ();
2800
2801 try {
2802 using (RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName)) {
2803 // check if key was successfully created
2804 Assert.IsNotNull (createdKey, "#A1");
2805 Assert.AreEqual (0, createdKey.ValueCount, "#A2");
2806 createdKey.SetValue ("name1", "value1");
2807 Assert.AreEqual (1, createdKey.ValueCount, "#A3");
2808 createdKey.SetValue ("name2", "value2");
2809 Assert.AreEqual (2, createdKey.ValueCount, "#A4");
2810 createdKey.SetValue ("name2", "value2b");
2811 Assert.AreEqual (2, createdKey.ValueCount, "#A5");
2812 createdKey.SetValue ("name3", "value3");
2813 Assert.AreEqual (3, createdKey.ValueCount, "#A6");
2814 }
2815 using (RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName)) {
2816 Assert.IsNotNull (createdKey, "#B1");
2817 Assert.AreEqual (3, createdKey.ValueCount, "#B2");
2818
2819 using (RegistryKey createdKey2 = Registry.CurrentUser.OpenSubKey (subKeyName, true)) {
2820 Assert.IsNotNull (createdKey2, "#B3");
2821 Assert.AreEqual (3, createdKey2.ValueCount, "#B4");
2822 createdKey2.DeleteValue ("name2");
2823 Assert.AreEqual (2, createdKey2.ValueCount, "#B5");
2824 }
2825 Assert.AreEqual (2, createdKey.ValueCount, "#B6");
2826 }
2827 } finally {
2828 try {
2829 RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName);
2830 if (createdKey != null) {
2831 createdKey.Close ();
2832 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
2833 }
2834 } catch {
2835 }
2836 }
2837 }
2838
2839 [Test]
2840 public void ValueCount_Key_Removed ()
2841 {
2842 string subKeyName = Guid.NewGuid ().ToString ();
2843
2844 try {
2845 using (RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName)) {
2846 // check if key was successfully created
2847 Assert.IsNotNull (createdKey, "#A1");
2848 Assert.AreEqual (0, createdKey.ValueCount, "#A2");
2849 createdKey.SetValue ("name1", "value1");
2850 Assert.AreEqual (1, createdKey.ValueCount, "#A3");
2851 createdKey.SetValue ("name2", "value2");
2852 Assert.AreEqual (2, createdKey.ValueCount, "#A4");
2853 createdKey.SetValue ("name2", "value2b");
2854 Assert.AreEqual (2, createdKey.ValueCount, "#A5");
2855 createdKey.SetValue ("name3", "value3");
2856 Assert.AreEqual (3, createdKey.ValueCount, "#A6");
2857 }
2858 using (RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName)) {
2859 Assert.IsNotNull (createdKey, "#B1");
2860 Assert.AreEqual (3, createdKey.ValueCount, "#B2");
2861
2862 // remove created key
2863 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
2864
2865 try {
2866 Assert.Fail ("#C1: " + createdKey.ValueCount);
2867 } catch (IOException ex) {
2868 // Illegal operation attempted on a registry key that
2869 // has been marked for deletion
2870 Assert.AreEqual (typeof (IOException), ex.GetType (), "#14");
2871 Assert.IsNotNull (ex.Message, "#15");
2872 Assert.IsNull (ex.InnerException, "#16");
2873 }
2874 }
2875 } finally {
2876 try {
2877 RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName);
2878 if (createdKey != null) {
2879 createdKey.Close ();
2880 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
2881 }
2882 } catch {
2883 }
2884 }
2885 }
2886
2887 [Test]
2888 public void bug79051 ()
2889 {
2890 string subKeyName = Guid.NewGuid ().ToString ();
2891
2892 using (RegistryKey softwareKey = Registry.CurrentUser.OpenSubKey ("software", true)) {
2893 try {
2894 using (RegistryKey createdKey = softwareKey.CreateSubKey (subKeyName)) {
2895 createdKey.SetValue ("test", "whatever");
2896 createdKey.Close ();
2897 softwareKey.DeleteSubKeyTree (subKeyName);
2898 }
2899 } finally {
2900 try {
2901 RegistryKey createdKey = softwareKey.OpenSubKey (subKeyName);
2902 if (createdKey != null) {
2903 createdKey.Close ();
2904 softwareKey.DeleteSubKeyTree (subKeyName);
2905 }
2906 } catch {
2907 }
2908 }
2909 }
2910 }
2911
2912 [Test]
2913 public void bug79059 ()
2914 {
2915 string subKeyName = Guid.NewGuid ().ToString ();
2916
2917 using (RegistryKey softwareKey = Registry.CurrentUser.OpenSubKey ("software", true)) {
2918 try {
2919 using (RegistryKey createdKey = softwareKey.CreateSubKey (subKeyName)) {
2920 using (RegistryKey softwareKey2 = Registry.CurrentUser.OpenSubKey ("software")) {
2921 }
2922 createdKey.Close ();
2923 softwareKey.DeleteSubKeyTree (subKeyName);
2924 }
2925 } finally {
2926 try {
2927 RegistryKey createdKey = softwareKey.OpenSubKey (subKeyName);
2928 if (createdKey != null) {
2929 createdKey.Close ();
2930 softwareKey.DeleteSubKeyTree (subKeyName);
2931 }
2932 } catch {
2933 }
2934 }
2935 }
2936 }
2937
2938 [Test]
2939 public void bugnew1 ()
2940 {
2941 string subKeyName = Guid.NewGuid ().ToString ();
2942
2943 using (RegistryKey softwareKey = Registry.CurrentUser.OpenSubKey ("software", true)) {
2944 try {
2945 using (RegistryKey createdKey = softwareKey.CreateSubKey (subKeyName)) {
2946 createdKey.SetValue ("name1", "value1");
2947
2948 RegistryKey testKey = null;
2949 try {
2950 testKey = createdKey.OpenSubKey ("test", true);
2951 if (testKey == null)
2952 testKey = createdKey.CreateSubKey ("test");
2953 testKey.SetValue ("another", "one");
2954 } finally {
2955 if (testKey != null)
2956 testKey.Close ();
2957 }
2958
2959 createdKey.SetValue ("name2", "value2");
2960 Assert.IsNotNull (createdKey.GetValue ("name1"), "#2");
2961 Assert.AreEqual ("value1", createdKey.GetValue ("name1"), "#3");
2962 Assert.IsNotNull (createdKey.GetValue ("name2"), "#4");
2963 Assert.AreEqual ("value2", createdKey.GetValue ("name2"), "#5");
2964
2965 string [] names = createdKey.GetValueNames ();
2966 Assert.IsNotNull (names, "#6");
2967 Assert.AreEqual (2, names.Length, "#7");
2968 Assert.AreEqual ("name1", names [0], "#8");
2969 Assert.AreEqual ("name2", names [1], "#9");
2970
2971 softwareKey.DeleteSubKeyTree (subKeyName);
2972
2973 using (RegistryKey openedKey = softwareKey.OpenSubKey (subKeyName, true)) {
2974 Assert.IsNull (openedKey, "#10");
2975 }
2976
2977 Assert.IsNull (createdKey.GetValue ("name1"), "#11");
2978 Assert.IsNull (createdKey.GetValue ("name2"), "#12");
2979
2980 try {
2981 createdKey.GetValueNames ();
2982 Assert.Fail ("#13");
2983 } catch (IOException ex) {
2984 // Illegal operation attempted on a registry key that
2985 // has been marked for deletion
2986 Assert.AreEqual (typeof (IOException), ex.GetType (), "#14");
2987 Assert.IsNotNull (ex.Message, "#15");
2988 Assert.IsNull (ex.InnerException, "#16");
2989 }
2990
2991 try {
2992 createdKey.SetValue ("name1", "value1");
2993 Assert.Fail ("#17");
2994 } catch (IOException ex) {
2995 // Illegal operation attempted on a registry key that
2996 // has been marked for deletion
2997 Assert.AreEqual (typeof (IOException), ex.GetType (), "#18");
2998 Assert.IsNotNull (ex.Message, "#19");
2999 Assert.IsNull (ex.InnerException, "#20");
3000 }
3001
3002 try {
3003 createdKey.SetValue ("newname", "value1");
3004 Assert.Fail ("#21");
3005 } catch (IOException ex) {
3006 // Illegal operation attempted on a registry key that
3007 // has been marked for deletion
3008 Assert.AreEqual (typeof (IOException), ex.GetType (), "#22");
3009 Assert.IsNotNull (ex.Message, "#23");
3010 Assert.IsNull (ex.InnerException, "#24");
3011 }
3012
3013 Assert.IsNull (createdKey.OpenSubKey ("test"), "#25");
3014 Assert.IsNull (createdKey.OpenSubKey ("test", true), "#26");
3015 Assert.IsNull (createdKey.OpenSubKey ("new"), "#27");
3016 Assert.IsNull (createdKey.OpenSubKey ("new", true), "#28");
3017
3018 try {
3019 createdKey.CreateSubKey ("new");
3020 Assert.Fail ("#29");
3021 } catch (IOException ex) {
3022 // Illegal operation attempted on a registry key that
3023 // has been marked for deletion
3024 Assert.AreEqual (typeof (IOException), ex.GetType (), "#30");
3025 Assert.IsNotNull (ex.Message, "#31");
3026 Assert.IsNull (ex.InnerException, "#32");
3027 }
3028 }
3029 } finally {
3030 try {
3031 RegistryKey createdKey = softwareKey.OpenSubKey (subKeyName);
3032 if (createdKey != null) {
3033 createdKey.Close ();
3034 softwareKey.DeleteSubKeyTree (subKeyName);
3035 }
3036 } catch {
3037 }
3038 }
3039 }
3040 }
3041
3042 [Test]
3043 public void bugnew2 () // values cannot be written on registry root (hive)
3044 {
3045 string [] names = Registry.CurrentUser.GetValueNames ();
3046 Assert.IsNotNull (names, "#1");
3047 Registry.CurrentUser.SetValue ("name1", "value1");
3048 Assert.IsNotNull (Registry.CurrentUser.GetValue ("name1"), "#2");
3049 Assert.AreEqual ("value1", Registry.CurrentUser.GetValue ("name1"), "#3");
3050 string [] newNames = Registry.CurrentUser.GetValueNames ();
3051 Assert.IsNotNull (newNames, "#4");
3052 Assert.AreEqual (names.Length + 1, newNames.Length, "#5");
3053 Registry.CurrentUser.DeleteValue ("name1");
3054 }
3055
3056 [Test]
3057 public void bugnew3 () // on Windows, key cannot be closed twice
3058 {
3059 string subKeyName = Guid.NewGuid ().ToString ();
3060
3061 try {
3062 using (RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName)) {
3063 createdKey.Close ();
3064 }
3065
3066 RegistryKey openedKey = Registry.CurrentUser.OpenSubKey (subKeyName);
3067 openedKey.Close ();
3068 openedKey.Close ();
3069 } finally {
3070 try {
3071 RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName);
3072 if (createdKey != null) {
3073 createdKey.Close ();
3074 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
3075 }
3076 } catch {
3077 }
3078 }
3079 }
3080
3081 [Test]
3082 public void bugnew4 () // Key cannot be flushed once it has been closed
3083 {
3084 string subKeyName = Guid.NewGuid ().ToString ();
3085
3086 try {
3087 using (RegistryKey createdKey = Registry.CurrentUser.CreateSubKey (subKeyName)) {
3088 createdKey.Close ();
3089 }
3090
3091 RegistryKey openedKey = Registry.CurrentUser.OpenSubKey (subKeyName);
3092 openedKey.Close ();
3093 openedKey.Flush ();
3094 } finally {
3095 try {
3096 RegistryKey createdKey = Registry.CurrentUser.OpenSubKey (subKeyName);
3097 if (createdKey != null) {
3098 createdKey.Close ();
3099 Registry.CurrentUser.DeleteSubKeyTree (subKeyName);
3100 }
3101 } catch {
3102 }
3103 }
3104 }
3105
3106 private bool RunningOnUnix {
3107 get {
3108 int p = (int) Environment.OSVersion.Platform;
3109 return ((p == 4) || (p == 128) || (p == 6));
3110 }
3111 }
3112 }
3113 }
git-svn mirror of mcs