?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Mono BCL test fixes so XM can run them (#4210)
[mono-project.git] / mcs / class / corlib / Test / System / AppDomainTest.cs
blob61e6a764534426216122856dba783860e8915efe
1 //
2 // AppDomainTest.cs - NUnit Test Cases for AppDomain
3 //
4 // Author:
5 // Sebastien Pouliot (sebastien@ximian.com)
6 //
7 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
8 // Copyright 2011 Xamarin Inc (http://www.xamarin.com).
9 //
10 // Permission is hereby granted, free of charge, to any person obtaining
11 // a copy of this software and associated documentation files (the
12 // "Software"), to deal in the Software without restriction, including
13 // without limitation the rights to use, copy, modify, merge, publish,
14 // distribute, sublicense, and/or sell copies of the Software, and to
15 // permit persons to whom the Software is furnished to do so, subject to
16 // the following conditions:
17 //
18 // The above copyright notice and this permission notice shall be
19 // included in all copies or substantial portions of the Software.
20 //
21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
22 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
23 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
24 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
25 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
26 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
27 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
28 //
29
30 #if !MOBILE && !MONOMAC
31
32 using NUnit.Framework;
33 using System;
34 using System.Collections;
35 using System.Collections.Generic;
36 using System.Configuration.Assemblies;
37 using System.Globalization;
38 using System.IO;
39 using System.Reflection;
40 using System.Reflection.Emit;
41 using System.Runtime.InteropServices;
42 using System.Security;
43 using System.Security.Permissions;
44 using System.Security.Policy;
45 using System.Security.Principal;
46
47 namespace MonoTests.System
48 {
49 [TestFixture]
50 public class AppDomainTest
51 {
52 private AppDomain ad;
53 private ArrayList files = new ArrayList ();
54 private string tempDir;
55
56 [SetUp]
57 public void SetUp ()
58 {
59 tempDir = Path.Combine (Path.GetTempPath (), Environment.UserName);
60 tempDir = Path.Combine (tempDir, "MonoTests.System.AppDomainTest");
61 if (!Directory.Exists (tempDir)) {
62 Directory.CreateDirectory (tempDir);
63 }
64 }
65
66 [TearDown]
67 public void TearDown ()
68 {
69 if (ad != null) {
70 try {
71 AppDomain.Unload (ad);
72 ad = null;
73 } catch { } // do not affect unit test results in TearDown
74 }
75 foreach (string fname in files) {
76 File.Delete (fname);
77 }
78 files.Clear ();
79 }
80
81 [Test] // bug #80934
82 public void ConfigurationFile_Relative ()
83 {
84 // Note:
85 // We use Environment.GetCommandLineArgs () to get the location of
86 // the entry assembly in the default domain (since the default domain
87 // is not exposed by any API)
88 //
89 // MS returns a lower-case path in Environment.GetCommandLineArgs ()
90 // and hence we need to perform a case-insensitive comparison
91 // if the Assert involves that path
92
93 string configFile = "test.config";
94 string appBase = null;
95 string expectedConfigFile = null;
96 string expectedAppBase = null;
97
98 // do not set ApplicationBase
99 appBase = Path.GetDirectoryName (Environment.GetCommandLineArgs () [0]);
100 expectedAppBase = appBase [appBase.Length - 1] == Path.DirectorySeparatorChar ?
101 appBase : appBase + Path.DirectorySeparatorChar;
102 expectedConfigFile = Path.Combine (appBase, configFile);
103 AppDomainSetup setup = new AppDomainSetup();
104 setup.ConfigurationFile = configFile;
105 ad = CreateTestDomain (setup, true);
106 CrossDomainTester cdt = CreateCrossDomainTester (ad);
107 if (RunningOnUnix) {
108 Assert.AreEqual (expectedConfigFile, cdt.GetConfigurationFile (), "#A1");
109 Assert.AreEqual (expectedAppBase, cdt.GetApplicationBase (), "#A2");
110 } else {
111 Assert.IsTrue (string.Compare (expectedConfigFile, cdt.GetConfigurationFile (), true) == 0, "#A1");
112 Assert.IsTrue (string.Compare (expectedAppBase, cdt.GetApplicationBase (), true) == 0, "#A2");
113 }
114 AppDomain.Unload (ad);
115
116 // set ApplicationBase
117 appBase = Path.GetTempPath ();
118 expectedAppBase = appBase [appBase.Length - 1] == Path.DirectorySeparatorChar ?
119 appBase : appBase + Path.DirectorySeparatorChar;
120 expectedConfigFile = Path.Combine (appBase, configFile);
121 setup = new AppDomainSetup ();
122 setup.ApplicationBase = appBase;
123 setup.ConfigurationFile = configFile;
124 ad = CreateTestDomain (setup, true);
125 cdt = CreateCrossDomainTester (ad);
126 Assert.AreEqual (expectedConfigFile, cdt.GetConfigurationFile (), "#B1");
127 Assert.AreEqual (expectedAppBase, cdt.GetApplicationBase (), "#B2");
128 AppDomain.Unload (ad);
129 }
130
131 [Test] // bug #80934
132 public void ConfigurationFile_Absolute ()
133 {
134 // Note:
135 // We use Environment.GetCommandLineArgs () to get the location of
136 // the entry assembly in the default domain (since the default domain
137 // is not exposed by any API)
138 //
139 // MS returns a lower-case path in Environment.GetCommandLineArgs ()
140 // and hence on Windows we need to perform a case-insensitive
141 // comparison if the Assert involves that path
142
143 string configFile = Path.Combine (tempDir, "test.config");
144 string appBase = null;
145 string expectedAppBase = null;
146
147 // do not set ApplicationBase
148 appBase = Path.GetDirectoryName (Environment.GetCommandLineArgs () [0]);
149 expectedAppBase = appBase [appBase.Length - 1] == Path.DirectorySeparatorChar ?
150 appBase : appBase + Path.DirectorySeparatorChar;
151 AppDomainSetup setup = new AppDomainSetup ();
152 setup.ConfigurationFile = configFile;
153 ad = CreateTestDomain (setup, true);
154 CrossDomainTester cdt = CreateCrossDomainTester (ad);
155 Assert.AreEqual (configFile, cdt.GetConfigurationFile (), "#A1");
156 if (RunningOnUnix) {
157 Assert.AreEqual (expectedAppBase, cdt.GetApplicationBase (), "#A2");
158 } else {
159 Assert.IsTrue (string.Compare (expectedAppBase, cdt.GetApplicationBase (), true) == 0, "#A2");
160 }
161 AppDomain.Unload (ad);
162
163 // set ApplicationBase
164 appBase = Path.GetTempPath ();
165 expectedAppBase = appBase [appBase.Length - 1] == Path.DirectorySeparatorChar ?
166 appBase : appBase + Path.DirectorySeparatorChar;
167 setup = new AppDomainSetup ();
168 setup.ApplicationBase = appBase;
169 setup.ConfigurationFile = configFile;
170 ad = CreateTestDomain (setup, true);
171 cdt = CreateCrossDomainTester (ad);
172 Assert.AreEqual (configFile, cdt.GetConfigurationFile (), "#B1");
173 Assert.AreEqual (expectedAppBase, cdt.GetApplicationBase (), "#B2");
174 AppDomain.Unload (ad);
175 }
176
177 [Test] // bug #80934
178 public void ConfigurationFile_Null ()
179 {
180 // Note:
181 // We use Environment.GetCommandLineArgs () to get the location of
182 // the entry assembly in the default domain (since the default domain
183 // is not exposed by any API)
184 //
185 // MS returns a lower-case path in Environment.GetCommandLineArgs ()
186 // and hence we need to perform a case-insensitive comparison
187 // if the Assert involves that path
188
189 string appBase = null;
190 string expectedAppBase = null;
191 string expectedConfigFile = null;
192
193 // do not set ApplicationBase
194 appBase = Path.GetDirectoryName (Environment.GetCommandLineArgs () [0]);
195 expectedAppBase = appBase [appBase.Length - 1] == Path.DirectorySeparatorChar ?
196 appBase : appBase + Path.DirectorySeparatorChar;
197 expectedConfigFile = Environment.GetCommandLineArgs () [0] + ".config";
198 AppDomainSetup setup = new AppDomainSetup ();
199 setup.ConfigurationFile = null;
200 ad = CreateTestDomain (setup, true);
201 CrossDomainTester cdt = CreateCrossDomainTester (ad);
202 if (RunningOnUnix) {
203 Assert.AreEqual (expectedConfigFile, cdt.GetConfigurationFile (), "#A1");
204 Assert.AreEqual (expectedAppBase, cdt.GetApplicationBase (), "#A2");
205 } else {
206 Assert.IsTrue (string.Compare (expectedConfigFile, cdt.GetConfigurationFile (), true) == 0, "#A1");
207 Assert.IsTrue (string.Compare (expectedAppBase, cdt.GetApplicationBase (), true) == 0, "#A2");
208 }
209 AppDomain.Unload (ad);
210
211 // set ApplicationBase
212 appBase = Path.GetTempPath ();
213 expectedAppBase = appBase [appBase.Length - 1] == Path.DirectorySeparatorChar ?
214 appBase : appBase + Path.DirectorySeparatorChar;
215 expectedConfigFile = Path.Combine (appBase, Path.GetFileName (Environment.GetCommandLineArgs () [0]) + ".config");
216 setup = new AppDomainSetup ();
217 setup.ApplicationBase = appBase;
218 setup.ConfigurationFile = null;
219 ad = CreateTestDomain (setup, true);
220 cdt = CreateCrossDomainTester (ad);
221 if (RunningOnUnix) {
222 Assert.AreEqual (expectedConfigFile, cdt.GetConfigurationFile (), "#B1");
223 } else {
224 Assert.IsTrue (string.Compare (expectedConfigFile, cdt.GetConfigurationFile (), true) == 0, "#B1");
225 }
226 Assert.AreEqual (expectedAppBase, cdt.GetApplicationBase (), "#B2");
227 AppDomain.Unload (ad);
228 }
229
230 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess)
231 public void DefineDynamicAssembly1_Access_Invalid ()
232 {
233 AssemblyName name = new AssemblyName ();
234 name.Name = "DefineDynamicAssembly1";
235
236 try {
237 AppDomain.CurrentDomain.DefineDynamicAssembly (
238 name, AssemblyBuilderAccess.Run |
239 (AssemblyBuilderAccess) 666);
240 Assert.Fail ("#1");
241 } catch (ArgumentException ex) {
242 // Illegal enum value: 667
243 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
244 Assert.IsNull (ex.InnerException, "#3");
245 Assert.IsNotNull (ex.Message, "#4");
246 Assert.IsTrue (ex.Message.IndexOf ("667") != -1, "#5");
247 Assert.IsNotNull (ex.ParamName, "#6");
248 Assert.AreEqual ("access", ex.ParamName, "#7");
249 }
250 }
251
252 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess)
253 public void DefineDynamicAssembly1_Name_InvalidChars ()
254 {
255 string [] invalid_char_names = new string [] {
256 "\tAB",
257 " AB",
258 "\rAB",
259 "A/B",
260 ":AB",
261 "B:A",
262 "B\\A",
263 "BA\\"};
264
265 AssemblyName name = new AssemblyName ();
266
267 foreach (string invalid_name in invalid_char_names) {
268 name.Name = invalid_name;
269 try {
270 AppDomain.CurrentDomain.DefineDynamicAssembly (
271 name,
272 AssemblyBuilderAccess.Run);
273 Assert.Fail ("#1:" + invalid_name);
274 } catch (ArgumentException ex) {
275 // Assembly names may not begin with whitespace
276 // or contain the characters '/', '\' or ':'
277 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2:" + invalid_name);
278 Assert.IsNull (ex.InnerException, "#3:" + invalid_name);
279 Assert.IsNotNull (ex.Message, "#4:" + invalid_name);
280 Assert.IsTrue (ex.Message.IndexOf ("'/'") != -1, "#5:" + invalid_name);
281 Assert.IsTrue (ex.Message.IndexOf ("'\\'") != -1, "#6:" + invalid_name);
282 Assert.IsTrue (ex.Message.IndexOf ("':'") != -1, "#7:" + invalid_name);
283 Assert.IsNull (ex.ParamName, "#8:" + invalid_name);
284 }
285 }
286 }
287
288 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess)
289 public void DefineDynamicAssembly1_Name_Null ()
290 {
291 try {
292 AppDomain.CurrentDomain.DefineDynamicAssembly (
293 (AssemblyName) null,
294 AssemblyBuilderAccess.Run);
295 Assert.Fail ("#A1");
296 } catch (ArgumentNullException ex) {
297 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
298 Assert.IsNull (ex.InnerException, "#A3");
299 Assert.IsNotNull (ex.Message, "#A4");
300 Assert.IsNotNull (ex.ParamName, "#A5");
301 Assert.AreEqual ("name", ex.ParamName, "#A6");
302 }
303
304 AssemblyName name = new AssemblyName ();
305
306 try {
307 AppDomain.CurrentDomain.DefineDynamicAssembly (
308 name,
309 AssemblyBuilderAccess.Run);
310 Assert.Fail ("#B1");
311 } catch (ArgumentException ex) {
312 // AssemblyName.Name cannot be null or an empty string
313 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
314 Assert.IsNull (ex.InnerException, "#B3");
315 Assert.IsNotNull (ex.Message, "#B4");
316 Assert.IsNull (ex.ParamName, "#B5");
317 }
318
319 name.Name = string.Empty;
320
321 try {
322 AppDomain.CurrentDomain.DefineDynamicAssembly (
323 name,
324 AssemblyBuilderAccess.Run);
325 Assert.Fail ("#C1");
326 } catch (ArgumentException ex) {
327 // AssemblyName.Name cannot be null or an empty string
328 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
329 Assert.IsNull (ex.InnerException, "#C3");
330 Assert.IsNotNull (ex.Message, "#C4");
331 Assert.IsNull (ex.ParamName, "#C5");
332 }
333 }
334
335 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, Evidence)
336 public void DefineDynamicAssembly2_Access_Invalid ()
337 {
338 AssemblyName name = new AssemblyName ();
339 name.Name = "DefineDynamicAssembly2";
340
341 try {
342 AppDomain.CurrentDomain.DefineDynamicAssembly (
343 name, AssemblyBuilderAccess.Run |
344 (AssemblyBuilderAccess) 666,
345 AppDomain.CurrentDomain.Evidence);
346 Assert.Fail ("#1");
347 } catch (ArgumentException ex) {
348 // Illegal enum value: 667
349 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
350 Assert.IsNull (ex.InnerException, "#3");
351 Assert.IsNotNull (ex.Message, "#4");
352 Assert.IsTrue (ex.Message.IndexOf ("667") != -1, "#5");
353 Assert.IsNotNull (ex.ParamName, "#6");
354 Assert.AreEqual ("access", ex.ParamName, "#7");
355 }
356 }
357
358 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, Evidence)
359 public void DefineDynamicAssembly2_Name_InvalidChars ()
360 {
361 string [] invalid_char_names = new string [] {
362 "\tAB",
363 " AB",
364 "\rAB",
365 "A/B",
366 ":AB",
367 "B:A",
368 "B\\A",
369 "BA\\"};
370
371 AssemblyName name = new AssemblyName ();
372
373 foreach (string invalid_name in invalid_char_names) {
374 name.Name = invalid_name;
375 try {
376 AppDomain.CurrentDomain.DefineDynamicAssembly (
377 name,
378 AssemblyBuilderAccess.Run,
379 AppDomain.CurrentDomain.Evidence);
380 Assert.Fail ("#1:" + invalid_name);
381 } catch (ArgumentException ex) {
382 // Assembly names may not begin with whitespace
383 // or contain the characters '/', '\' or ':'
384 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2:" + invalid_name);
385 Assert.IsNull (ex.InnerException, "#3:" + invalid_name);
386 Assert.IsNotNull (ex.Message, "#4:" + invalid_name);
387 Assert.IsTrue (ex.Message.IndexOf ("'/'") != -1, "#5:" + invalid_name);
388 Assert.IsTrue (ex.Message.IndexOf ("'\\'") != -1, "#6:" + invalid_name);
389 Assert.IsTrue (ex.Message.IndexOf ("':'") != -1, "#7:" + invalid_name);
390 Assert.IsNull (ex.ParamName, "#8:" + invalid_name);
391 }
392 }
393 }
394
395 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, Evidence)
396 public void DefineDynamicAssembly2_Name_Null ()
397 {
398 try {
399 AppDomain.CurrentDomain.DefineDynamicAssembly (
400 (AssemblyName) null,
401 AssemblyBuilderAccess.Run,
402 AppDomain.CurrentDomain.Evidence);
403 Assert.Fail ("#A1");
404 } catch (ArgumentNullException ex) {
405 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
406 Assert.IsNull (ex.InnerException, "#A3");
407 Assert.IsNotNull (ex.Message, "#A4");
408 Assert.IsNotNull (ex.ParamName, "#A5");
409 Assert.AreEqual ("name", ex.ParamName, "#A6");
410 }
411
412 AssemblyName name = new AssemblyName ();
413
414 try {
415 AppDomain.CurrentDomain.DefineDynamicAssembly (
416 name,
417 AssemblyBuilderAccess.Run,
418 AppDomain.CurrentDomain.Evidence);
419 Assert.Fail ("#B1");
420 } catch (ArgumentException ex) {
421 // AssemblyName.Name cannot be null or an empty string
422 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
423 Assert.IsNull (ex.InnerException, "#B3");
424 Assert.IsNotNull (ex.Message, "#B4");
425 Assert.IsNull (ex.ParamName, "#B5");
426 }
427
428 name.Name = string.Empty;
429
430 try {
431 AppDomain.CurrentDomain.DefineDynamicAssembly (
432 name,
433 AssemblyBuilderAccess.Run,
434 AppDomain.CurrentDomain.Evidence);
435 Assert.Fail ("#C1");
436 } catch (ArgumentException ex) {
437 // AssemblyName.Name cannot be null or an empty string
438 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
439 Assert.IsNull (ex.InnerException, "#C3");
440 Assert.IsNotNull (ex.Message, "#C4");
441 Assert.IsNull (ex.ParamName, "#C5");
442 }
443 }
444
445 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, String)
446 public void DefineDynamicAssembly3_Access_Invalid ()
447 {
448 AssemblyName name = new AssemblyName ();
449 name.Name = "DefineDynamicAssembly3";
450
451 try {
452 AppDomain.CurrentDomain.DefineDynamicAssembly (
453 name, AssemblyBuilderAccess.Run |
454 (AssemblyBuilderAccess) 666,
455 Path.GetTempPath ());
456 Assert.Fail ("#1");
457 } catch (ArgumentException ex) {
458 // Illegal enum value: 667
459 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
460 Assert.IsNull (ex.InnerException, "#3");
461 Assert.IsNotNull (ex.Message, "#4");
462 Assert.IsTrue (ex.Message.IndexOf ("667") != -1, "#5");
463 Assert.IsNotNull (ex.ParamName, "#6");
464 Assert.AreEqual ("access", ex.ParamName, "#7");
465 }
466 }
467
468 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, String)
469 public void DefineDynamicAssembly3_Name_InvalidChars ()
470 {
471 string [] invalid_char_names = new string [] {
472 "\tAB",
473 " AB",
474 "\rAB",
475 "A/B",
476 ":AB",
477 "B:A",
478 "B\\A",
479 "BA\\"};
480
481 AssemblyName name = new AssemblyName ();
482
483 foreach (string invalid_name in invalid_char_names) {
484 name.Name = invalid_name;
485 try {
486 AppDomain.CurrentDomain.DefineDynamicAssembly (
487 name,
488 AssemblyBuilderAccess.Run,
489 Path.GetTempPath ());
490 Assert.Fail ("#1:" + invalid_name);
491 } catch (ArgumentException ex) {
492 // Assembly names may not begin with whitespace
493 // or contain the characters '/', '\' or ':'
494 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2:" + invalid_name);
495 Assert.IsNull (ex.InnerException, "#3:" + invalid_name);
496 Assert.IsNotNull (ex.Message, "#4:" + invalid_name);
497 Assert.IsTrue (ex.Message.IndexOf ("'/'") != -1, "#5:" + invalid_name);
498 Assert.IsTrue (ex.Message.IndexOf ("'\\'") != -1, "#6:" + invalid_name);
499 Assert.IsTrue (ex.Message.IndexOf ("':'") != -1, "#7:" + invalid_name);
500 Assert.IsNull (ex.ParamName, "#8:" + invalid_name);
501 }
502 }
503 }
504
505 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, String)
506 public void DefineDynamicAssembly3_Name_Null ()
507 {
508 try {
509 AppDomain.CurrentDomain.DefineDynamicAssembly (
510 (AssemblyName) null,
511 AssemblyBuilderAccess.Run,
512 Path.GetTempPath ());
513 Assert.Fail ("#A1");
514 } catch (ArgumentNullException ex) {
515 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
516 Assert.IsNull (ex.InnerException, "#A3");
517 Assert.IsNotNull (ex.Message, "#A4");
518 Assert.IsNotNull (ex.ParamName, "#A5");
519 Assert.AreEqual ("name", ex.ParamName, "#A6");
520 }
521
522 AssemblyName name = new AssemblyName ();
523
524 try {
525 AppDomain.CurrentDomain.DefineDynamicAssembly (
526 name,
527 AssemblyBuilderAccess.Run,
528 Path.GetTempPath ());
529 Assert.Fail ("#B1");
530 } catch (ArgumentException ex) {
531 // AssemblyName.Name cannot be null or an empty string
532 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
533 Assert.IsNull (ex.InnerException, "#B3");
534 Assert.IsNotNull (ex.Message, "#B4");
535 Assert.IsNull (ex.ParamName, "#B5");
536 }
537
538 name.Name = string.Empty;
539
540 try {
541 AppDomain.CurrentDomain.DefineDynamicAssembly (
542 name,
543 AssemblyBuilderAccess.Run,
544 Path.GetTempPath ());
545 Assert.Fail ("#C1");
546 } catch (ArgumentException ex) {
547 // AssemblyName.Name cannot be null or an empty string
548 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
549 Assert.IsNull (ex.InnerException, "#C3");
550 Assert.IsNotNull (ex.Message, "#C4");
551 Assert.IsNull (ex.ParamName, "#C5");
552 }
553 }
554
555 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, String, Evidence)
556 public void DefineDynamicAssembly4_Access_Invalid ()
557 {
558 AssemblyName name = new AssemblyName ();
559 name.Name = "DefineDynamicAssembly4";
560
561 try {
562 AppDomain.CurrentDomain.DefineDynamicAssembly (
563 name, AssemblyBuilderAccess.Run |
564 (AssemblyBuilderAccess) 666,
565 Path.GetTempPath (),
566 AppDomain.CurrentDomain.Evidence);
567 Assert.Fail ("#1");
568 } catch (ArgumentException ex) {
569 // Illegal enum value: 667
570 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
571 Assert.IsNull (ex.InnerException, "#3");
572 Assert.IsNotNull (ex.Message, "#4");
573 Assert.IsTrue (ex.Message.IndexOf ("667") != -1, "#5");
574 Assert.IsNotNull (ex.ParamName, "#6");
575 Assert.AreEqual ("access", ex.ParamName, "#7");
576 }
577 }
578
579 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, String, Evidence)
580 public void DefineDynamicAssembly4_Name_InvalidChars ()
581 {
582 string [] invalid_char_names = new string [] {
583 "\tAB",
584 " AB",
585 "\rAB",
586 "A/B",
587 ":AB",
588 "B:A",
589 "B\\A",
590 "BA\\"};
591
592 AssemblyName name = new AssemblyName ();
593
594 foreach (string invalid_name in invalid_char_names) {
595 name.Name = invalid_name;
596 try {
597 AppDomain.CurrentDomain.DefineDynamicAssembly (
598 name,
599 AssemblyBuilderAccess.Run,
600 Path.GetTempPath (),
601 AppDomain.CurrentDomain.Evidence);
602 Assert.Fail ("#1:" + invalid_name);
603 } catch (ArgumentException ex) {
604 // Assembly names may not begin with whitespace
605 // or contain the characters '/', '\' or ':'
606 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2:" + invalid_name);
607 Assert.IsNull (ex.InnerException, "#3:" + invalid_name);
608 Assert.IsNotNull (ex.Message, "#4:" + invalid_name);
609 Assert.IsTrue (ex.Message.IndexOf ("'/'") != -1, "#5:" + invalid_name);
610 Assert.IsTrue (ex.Message.IndexOf ("'\\'") != -1, "#6:" + invalid_name);
611 Assert.IsTrue (ex.Message.IndexOf ("':'") != -1, "#7:" + invalid_name);
612 Assert.IsNull (ex.ParamName, "#8:" + invalid_name);
613 }
614 }
615 }
616
617 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, String, Evidence)
618 public void DefineDynamicAssembly4_Name_Null ()
619 {
620 try {
621 AppDomain.CurrentDomain.DefineDynamicAssembly (
622 (AssemblyName) null,
623 AssemblyBuilderAccess.Run,
624 Path.GetTempPath (),
625 AppDomain.CurrentDomain.Evidence);
626 Assert.Fail ("#A1");
627 } catch (ArgumentNullException ex) {
628 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
629 Assert.IsNull (ex.InnerException, "#A3");
630 Assert.IsNotNull (ex.Message, "#A4");
631 Assert.IsNotNull (ex.ParamName, "#A5");
632 Assert.AreEqual ("name", ex.ParamName, "#A6");
633 }
634
635 AssemblyName name = new AssemblyName ();
636
637 try {
638 AppDomain.CurrentDomain.DefineDynamicAssembly (
639 name,
640 AssemblyBuilderAccess.Run,
641 Path.GetTempPath (),
642 AppDomain.CurrentDomain.Evidence);
643 Assert.Fail ("#B1");
644 } catch (ArgumentException ex) {
645 // AssemblyName.Name cannot be null or an empty string
646 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
647 Assert.IsNull (ex.InnerException, "#B3");
648 Assert.IsNotNull (ex.Message, "#B4");
649 Assert.IsNull (ex.ParamName, "#B5");
650 }
651
652 name.Name = string.Empty;
653
654 try {
655 AppDomain.CurrentDomain.DefineDynamicAssembly (
656 name,
657 AssemblyBuilderAccess.Run,
658 Path.GetTempPath (),
659 AppDomain.CurrentDomain.Evidence);
660 Assert.Fail ("#C1");
661 } catch (ArgumentException ex) {
662 // AssemblyName.Name cannot be null or an empty string
663 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
664 Assert.IsNull (ex.InnerException, "#C3");
665 Assert.IsNotNull (ex.Message, "#C4");
666 Assert.IsNull (ex.ParamName, "#C5");
667 }
668 }
669
670 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, PermissionSet, PermissionSet, PermissionSet)
671 public void DefineDynamicAssembly5_Access_Invalid ()
672 {
673 AssemblyName name = new AssemblyName ();
674 name.Name = "DefineDynamicAssembly5";
675
676 try {
677 AppDomain.CurrentDomain.DefineDynamicAssembly (
678 name, AssemblyBuilderAccess.Run |
679 (AssemblyBuilderAccess) 666,
680 (PermissionSet) null,
681 (PermissionSet) null,
682 (PermissionSet) null);
683 Assert.Fail ("#1");
684 } catch (ArgumentException ex) {
685 // Illegal enum value: 667
686 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
687 Assert.IsNull (ex.InnerException, "#3");
688 Assert.IsNotNull (ex.Message, "#4");
689 Assert.IsTrue (ex.Message.IndexOf ("667") != -1, "#5");
690 Assert.IsNotNull (ex.ParamName, "#6");
691 Assert.AreEqual ("access", ex.ParamName, "#7");
692 }
693 }
694
695 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, PermissionSet, PermissionSet, PermissionSet)
696 public void DefineDynamicAssembly5_Name_InvalidChars ()
697 {
698 string [] invalid_char_names = new string [] {
699 "\tAB",
700 " AB",
701 "\rAB",
702 "A/B",
703 ":AB",
704 "B:A",
705 "B\\A",
706 "BA\\"};
707
708 AssemblyName name = new AssemblyName ();
709
710 foreach (string invalid_name in invalid_char_names) {
711 name.Name = invalid_name;
712 try {
713 AppDomain.CurrentDomain.DefineDynamicAssembly (
714 name,
715 AssemblyBuilderAccess.Run,
716 (PermissionSet) null,
717 (PermissionSet) null,
718 (PermissionSet) null);
719 Assert.Fail ("#1:" + invalid_name);
720 } catch (ArgumentException ex) {
721 // Assembly names may not begin with whitespace
722 // or contain the characters '/', '\' or ':'
723 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2:" + invalid_name);
724 Assert.IsNull (ex.InnerException, "#3:" + invalid_name);
725 Assert.IsNotNull (ex.Message, "#4:" + invalid_name);
726 Assert.IsTrue (ex.Message.IndexOf ("'/'") != -1, "#5:" + invalid_name);
727 Assert.IsTrue (ex.Message.IndexOf ("'\\'") != -1, "#6:" + invalid_name);
728 Assert.IsTrue (ex.Message.IndexOf ("':'") != -1, "#7:" + invalid_name);
729 Assert.IsNull (ex.ParamName, "#8:" + invalid_name);
730 }
731 }
732 }
733
734 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, PermissionSet, PermissionSet, PermissionSet)
735 public void DefineDynamicAssembly5_Name_Null ()
736 {
737 try {
738 AppDomain.CurrentDomain.DefineDynamicAssembly (
739 (AssemblyName) null,
740 AssemblyBuilderAccess.Run,
741 (PermissionSet) null,
742 (PermissionSet) null,
743 (PermissionSet) null);
744 Assert.Fail ("#A1");
745 } catch (ArgumentNullException ex) {
746 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
747 Assert.IsNull (ex.InnerException, "#A3");
748 Assert.IsNotNull (ex.Message, "#A4");
749 Assert.IsNotNull (ex.ParamName, "#A5");
750 Assert.AreEqual ("name", ex.ParamName, "#A6");
751 }
752
753 AssemblyName name = new AssemblyName ();
754
755 try {
756 AppDomain.CurrentDomain.DefineDynamicAssembly (
757 name,
758 AssemblyBuilderAccess.Run,
759 (PermissionSet) null,
760 (PermissionSet) null,
761 (PermissionSet) null);
762 Assert.Fail ("#B1");
763 } catch (ArgumentException ex) {
764 // AssemblyName.Name cannot be null or an empty string
765 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
766 Assert.IsNull (ex.InnerException, "#B3");
767 Assert.IsNotNull (ex.Message, "#B4");
768 Assert.IsNull (ex.ParamName, "#B5");
769 }
770
771 name.Name = string.Empty;
772
773 try {
774 AppDomain.CurrentDomain.DefineDynamicAssembly (
775 name,
776 AssemblyBuilderAccess.Run,
777 (PermissionSet) null,
778 (PermissionSet) null,
779 (PermissionSet) null);
780 Assert.Fail ("#C1");
781 } catch (ArgumentException ex) {
782 // AssemblyName.Name cannot be null or an empty string
783 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
784 Assert.IsNull (ex.InnerException, "#C3");
785 Assert.IsNotNull (ex.Message, "#C4");
786 Assert.IsNull (ex.ParamName, "#C5");
787 }
788 }
789
790 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, Evidence, PermissionSet, PermissionSet, PermissionSet)
791 public void DefineDynamicAssembly6_Access_Invalid ()
792 {
793 AssemblyName name = new AssemblyName ();
794 name.Name = "DefineDynamicAssembly6";
795
796 try {
797 AppDomain.CurrentDomain.DefineDynamicAssembly (
798 name, AssemblyBuilderAccess.Run |
799 (AssemblyBuilderAccess) 666,
800 AppDomain.CurrentDomain.Evidence,
801 (PermissionSet) null,
802 (PermissionSet) null,
803 (PermissionSet) null);
804 Assert.Fail ("#1");
805 } catch (ArgumentException ex) {
806 // Illegal enum value: 667
807 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
808 Assert.IsNull (ex.InnerException, "#3");
809 Assert.IsNotNull (ex.Message, "#4");
810 Assert.IsTrue (ex.Message.IndexOf ("667") != -1, "#5");
811 Assert.IsNotNull (ex.ParamName, "#6");
812 Assert.AreEqual ("access", ex.ParamName, "#7");
813 }
814 }
815
816 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, Evidence, PermissionSet, PermissionSet, PermissionSet)
817 public void DefineDynamicAssembly6_Name_InvalidChars ()
818 {
819 string [] invalid_char_names = new string [] {
820 "\tAB",
821 " AB",
822 "\rAB",
823 "A/B",
824 ":AB",
825 "B:A",
826 "B\\A",
827 "BA\\"};
828
829 AssemblyName name = new AssemblyName ();
830
831 foreach (string invalid_name in invalid_char_names) {
832 name.Name = invalid_name;
833 try {
834 AppDomain.CurrentDomain.DefineDynamicAssembly (
835 name,
836 AssemblyBuilderAccess.Run,
837 AppDomain.CurrentDomain.Evidence,
838 (PermissionSet) null,
839 (PermissionSet) null,
840 (PermissionSet) null);
841 Assert.Fail ("#1:" + invalid_name);
842 } catch (ArgumentException ex) {
843 // Assembly names may not begin with whitespace
844 // or contain the characters '/', '\' or ':'
845 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2:" + invalid_name);
846 Assert.IsNull (ex.InnerException, "#3:" + invalid_name);
847 Assert.IsNotNull (ex.Message, "#4:" + invalid_name);
848 Assert.IsTrue (ex.Message.IndexOf ("'/'") != -1, "#5:" + invalid_name);
849 Assert.IsTrue (ex.Message.IndexOf ("'\\'") != -1, "#6:" + invalid_name);
850 Assert.IsTrue (ex.Message.IndexOf ("':'") != -1, "#7:" + invalid_name);
851 Assert.IsNull (ex.ParamName, "#8:" + invalid_name);
852 }
853 }
854 }
855
856 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, Evidence, PermissionSet, PermissionSet, PermissionSet)
857 public void DefineDynamicAssembly6_Name_Null ()
858 {
859 try {
860 AppDomain.CurrentDomain.DefineDynamicAssembly (
861 (AssemblyName) null,
862 AssemblyBuilderAccess.Run,
863 AppDomain.CurrentDomain.Evidence,
864 (PermissionSet) null,
865 (PermissionSet) null,
866 (PermissionSet) null);
867 Assert.Fail ("#A1");
868 } catch (ArgumentNullException ex) {
869 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
870 Assert.IsNull (ex.InnerException, "#A3");
871 Assert.IsNotNull (ex.Message, "#A4");
872 Assert.IsNotNull (ex.ParamName, "#A5");
873 Assert.AreEqual ("name", ex.ParamName, "#A6");
874 }
875
876 AssemblyName name = new AssemblyName ();
877
878 try {
879 AppDomain.CurrentDomain.DefineDynamicAssembly (
880 name,
881 AssemblyBuilderAccess.Run,
882 AppDomain.CurrentDomain.Evidence,
883 (PermissionSet) null,
884 (PermissionSet) null,
885 (PermissionSet) null);
886 Assert.Fail ("#B1");
887 } catch (ArgumentException ex) {
888 // AssemblyName.Name cannot be null or an empty string
889 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
890 Assert.IsNull (ex.InnerException, "#B3");
891 Assert.IsNotNull (ex.Message, "#B4");
892 Assert.IsNull (ex.ParamName, "#B5");
893 }
894
895 name.Name = string.Empty;
896
897 try {
898 AppDomain.CurrentDomain.DefineDynamicAssembly (
899 name,
900 AssemblyBuilderAccess.Run,
901 AppDomain.CurrentDomain.Evidence,
902 (PermissionSet) null,
903 (PermissionSet) null,
904 (PermissionSet) null);
905 Assert.Fail ("#C1");
906 } catch (ArgumentException ex) {
907 // AssemblyName.Name cannot be null or an empty string
908 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
909 Assert.IsNull (ex.InnerException, "#C3");
910 Assert.IsNotNull (ex.Message, "#C4");
911 Assert.IsNull (ex.ParamName, "#C5");
912 }
913 }
914
915 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, String, PermissionSet, PermissionSet, PermissionSet)
916 public void DefineDynamicAssembly7_Access_Invalid ()
917 {
918 AssemblyName name = new AssemblyName ();
919 name.Name = "DefineDynamicAssembly7";
920
921 try {
922 AppDomain.CurrentDomain.DefineDynamicAssembly (
923 name, AssemblyBuilderAccess.Run |
924 (AssemblyBuilderAccess) 666,
925 Path.GetTempPath (),
926 (PermissionSet) null,
927 (PermissionSet) null,
928 (PermissionSet) null);
929 Assert.Fail ("#1");
930 } catch (ArgumentException ex) {
931 // Illegal enum value: 667
932 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
933 Assert.IsNull (ex.InnerException, "#3");
934 Assert.IsNotNull (ex.Message, "#4");
935 Assert.IsTrue (ex.Message.IndexOf ("667") != -1, "#5");
936 Assert.IsNotNull (ex.ParamName, "#6");
937 Assert.AreEqual ("access", ex.ParamName, "#7");
938 }
939 }
940
941 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, String, PermissionSet, PermissionSet, PermissionSet)
942 public void DefineDynamicAssembly7_Name_InvalidChars ()
943 {
944 string [] invalid_char_names = new string [] {
945 "\tAB",
946 " AB",
947 "\rAB",
948 "A/B",
949 ":AB",
950 "B:A",
951 "B\\A",
952 "BA\\"};
953
954 AssemblyName name = new AssemblyName ();
955
956 foreach (string invalid_name in invalid_char_names) {
957 name.Name = invalid_name;
958 try {
959 AppDomain.CurrentDomain.DefineDynamicAssembly (
960 name,
961 AssemblyBuilderAccess.Run,
962 Path.GetTempPath (),
963 (PermissionSet) null,
964 (PermissionSet) null,
965 (PermissionSet) null);
966 Assert.Fail ("#1:" + invalid_name);
967 } catch (ArgumentException ex) {
968 // Assembly names may not begin with whitespace
969 // or contain the characters '/', '\' or ':'
970 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2:" + invalid_name);
971 Assert.IsNull (ex.InnerException, "#3:" + invalid_name);
972 Assert.IsNotNull (ex.Message, "#4:" + invalid_name);
973 Assert.IsTrue (ex.Message.IndexOf ("'/'") != -1, "#5:" + invalid_name);
974 Assert.IsTrue (ex.Message.IndexOf ("'\\'") != -1, "#6:" + invalid_name);
975 Assert.IsTrue (ex.Message.IndexOf ("':'") != -1, "#7:" + invalid_name);
976 Assert.IsNull (ex.ParamName, "#8:" + invalid_name);
977 }
978 }
979 }
980
981 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, String, PermissionSet, PermissionSet, PermissionSet)
982 public void DefineDynamicAssembly7_Name_Null ()
983 {
984 try {
985 AppDomain.CurrentDomain.DefineDynamicAssembly (
986 (AssemblyName) null,
987 AssemblyBuilderAccess.Run,
988 Path.GetTempPath (),
989 (PermissionSet) null,
990 (PermissionSet) null,
991 (PermissionSet) null);
992 Assert.Fail ("#A1");
993 } catch (ArgumentNullException ex) {
994 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
995 Assert.IsNull (ex.InnerException, "#A3");
996 Assert.IsNotNull (ex.Message, "#A4");
997 Assert.IsNotNull (ex.ParamName, "#A5");
998 Assert.AreEqual ("name", ex.ParamName, "#A6");
999 }
1000
1001 AssemblyName name = new AssemblyName ();
1002
1003 try {
1004 AppDomain.CurrentDomain.DefineDynamicAssembly (
1005 name,
1006 AssemblyBuilderAccess.Run,
1007 Path.GetTempPath (),
1008 (PermissionSet) null,
1009 (PermissionSet) null,
1010 (PermissionSet) null);
1011 Assert.Fail ("#B1");
1012 } catch (ArgumentException ex) {
1013 // AssemblyName.Name cannot be null or an empty string
1014 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1015 Assert.IsNull (ex.InnerException, "#B3");
1016 Assert.IsNotNull (ex.Message, "#B4");
1017 Assert.IsNull (ex.ParamName, "#B5");
1018 }
1019
1020 name.Name = string.Empty;
1021
1022 try {
1023 AppDomain.CurrentDomain.DefineDynamicAssembly (
1024 name,
1025 AssemblyBuilderAccess.Run,
1026 Path.GetTempPath (),
1027 (PermissionSet) null,
1028 (PermissionSet) null,
1029 (PermissionSet) null);
1030 Assert.Fail ("#C1");
1031 } catch (ArgumentException ex) {
1032 // AssemblyName.Name cannot be null or an empty string
1033 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
1034 Assert.IsNull (ex.InnerException, "#C3");
1035 Assert.IsNotNull (ex.Message, "#C4");
1036 Assert.IsNull (ex.ParamName, "#C5");
1037 }
1038 }
1039
1040 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, String, Evidence, PermissionSet, PermissionSet, PermissionSet)
1041 public void DefineDynamicAssembly8_Access_Invalid ()
1042 {
1043 AssemblyName name = new AssemblyName ();
1044 name.Name = "DefineDynamicAssembly8";
1045
1046 try {
1047 AppDomain.CurrentDomain.DefineDynamicAssembly (
1048 name, AssemblyBuilderAccess.Run |
1049 (AssemblyBuilderAccess) 666,
1050 Path.GetTempPath (),
1051 AppDomain.CurrentDomain.Evidence,
1052 (PermissionSet) null,
1053 (PermissionSet) null,
1054 (PermissionSet) null);
1055 Assert.Fail ("#1");
1056 } catch (ArgumentException ex) {
1057 // Illegal enum value: 667
1058 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1059 Assert.IsNull (ex.InnerException, "#3");
1060 Assert.IsNotNull (ex.Message, "#4");
1061 Assert.IsTrue (ex.Message.IndexOf ("667") != -1, "#5");
1062 Assert.IsNotNull (ex.ParamName, "#6");
1063 Assert.AreEqual ("access", ex.ParamName, "#7");
1064 }
1065 }
1066
1067 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, String, Evidence, PermissionSet, PermissionSet, PermissionSet)
1068 public void DefineDynamicAssembly8_Name_InvalidChars ()
1069 {
1070 string [] invalid_char_names = new string [] {
1071 "\tAB",
1072 " AB",
1073 "\rAB",
1074 "A/B",
1075 ":AB",
1076 "B:A",
1077 "B\\A",
1078 "BA\\"};
1079
1080 AssemblyName name = new AssemblyName ();
1081
1082 foreach (string invalid_name in invalid_char_names) {
1083 name.Name = invalid_name;
1084 try {
1085 AppDomain.CurrentDomain.DefineDynamicAssembly (
1086 name,
1087 AssemblyBuilderAccess.Run,
1088 Path.GetTempPath (),
1089 AppDomain.CurrentDomain.Evidence,
1090 (PermissionSet) null,
1091 (PermissionSet) null,
1092 (PermissionSet) null);
1093 Assert.Fail ("#1:" + invalid_name);
1094 } catch (ArgumentException ex) {
1095 // Assembly names may not begin with whitespace
1096 // or contain the characters '/', '\' or ':'
1097 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2:" + invalid_name);
1098 Assert.IsNull (ex.InnerException, "#3:" + invalid_name);
1099 Assert.IsNotNull (ex.Message, "#4:" + invalid_name);
1100 Assert.IsTrue (ex.Message.IndexOf ("'/'") != -1, "#5:" + invalid_name);
1101 Assert.IsTrue (ex.Message.IndexOf ("'\\'") != -1, "#6:" + invalid_name);
1102 Assert.IsTrue (ex.Message.IndexOf ("':'") != -1, "#7:" + invalid_name);
1103 Assert.IsNull (ex.ParamName, "#8:" + invalid_name);
1104 }
1105 }
1106 }
1107
1108 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, String, Evidence, PermissionSet, PermissionSet, PermissionSet)
1109 public void DefineDynamicAssembly8_Name_Null ()
1110 {
1111 try {
1112 AppDomain.CurrentDomain.DefineDynamicAssembly (
1113 (AssemblyName) null,
1114 AssemblyBuilderAccess.Run,
1115 Path.GetTempPath (),
1116 AppDomain.CurrentDomain.Evidence,
1117 (PermissionSet) null,
1118 (PermissionSet) null,
1119 (PermissionSet) null);
1120 Assert.Fail ("#A1");
1121 } catch (ArgumentNullException ex) {
1122 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
1123 Assert.IsNull (ex.InnerException, "#A3");
1124 Assert.IsNotNull (ex.Message, "#A4");
1125 Assert.IsNotNull (ex.ParamName, "#A5");
1126 Assert.AreEqual ("name", ex.ParamName, "#A6");
1127 }
1128
1129 AssemblyName name = new AssemblyName ();
1130
1131 try {
1132 AppDomain.CurrentDomain.DefineDynamicAssembly (
1133 name,
1134 AssemblyBuilderAccess.Run,
1135 Path.GetTempPath (),
1136 AppDomain.CurrentDomain.Evidence,
1137 (PermissionSet) null,
1138 (PermissionSet) null,
1139 (PermissionSet) null);
1140 Assert.Fail ("#B1");
1141 } catch (ArgumentException ex) {
1142 // AssemblyName.Name cannot be null or an empty string
1143 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1144 Assert.IsNull (ex.InnerException, "#B3");
1145 Assert.IsNotNull (ex.Message, "#B4");
1146 Assert.IsNull (ex.ParamName, "#B5");
1147 }
1148
1149 name.Name = string.Empty;
1150
1151 try {
1152 AppDomain.CurrentDomain.DefineDynamicAssembly (
1153 name,
1154 AssemblyBuilderAccess.Run,
1155 Path.GetTempPath (),
1156 AppDomain.CurrentDomain.Evidence,
1157 (PermissionSet) null,
1158 (PermissionSet) null,
1159 (PermissionSet) null);
1160 Assert.Fail ("#C1");
1161 } catch (ArgumentException ex) {
1162 // AssemblyName.Name cannot be null or an empty string
1163 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
1164 Assert.IsNull (ex.InnerException, "#C3");
1165 Assert.IsNotNull (ex.Message, "#C4");
1166 Assert.IsNull (ex.ParamName, "#C5");
1167 }
1168 }
1169
1170 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, String, Evidence, PermissionSet, PermissionSet, PermissionSet, Boolean)
1171 public void DefineDynamicAssembly9_Access_Invalid ()
1172 {
1173 AssemblyName name = new AssemblyName ();
1174 name.Name = "DefineDynamicAssembly9";
1175
1176 try {
1177 AppDomain.CurrentDomain.DefineDynamicAssembly (
1178 name, AssemblyBuilderAccess.Run |
1179 (AssemblyBuilderAccess) 666,
1180 Path.GetTempPath (),
1181 AppDomain.CurrentDomain.Evidence,
1182 (PermissionSet) null,
1183 (PermissionSet) null,
1184 (PermissionSet) null,
1185 true);
1186 Assert.Fail ("#1");
1187 } catch (ArgumentException ex) {
1188 // Illegal enum value: 667
1189 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1190 Assert.IsNull (ex.InnerException, "#3");
1191 Assert.IsNotNull (ex.Message, "#4");
1192 Assert.IsTrue (ex.Message.IndexOf ("667") != -1, "#5");
1193 Assert.IsNotNull (ex.ParamName, "#6");
1194 Assert.AreEqual ("access", ex.ParamName, "#7");
1195 }
1196 }
1197
1198 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, String, Evidence, PermissionSet, PermissionSet, PermissionSet, Boolean)
1199 public void DefineDynamicAssembly9_Name_InvalidChars ()
1200 {
1201 string [] invalid_char_names = new string [] {
1202 "\tAB",
1203 " AB",
1204 "\rAB",
1205 "A/B",
1206 ":AB",
1207 "B:A",
1208 "B\\A",
1209 "BA\\"};
1210
1211 AssemblyName name = new AssemblyName ();
1212
1213 foreach (string invalid_name in invalid_char_names) {
1214 name.Name = invalid_name;
1215 try {
1216 AppDomain.CurrentDomain.DefineDynamicAssembly (
1217 name,
1218 AssemblyBuilderAccess.Run,
1219 Path.GetTempPath (),
1220 AppDomain.CurrentDomain.Evidence,
1221 (PermissionSet) null,
1222 (PermissionSet) null,
1223 (PermissionSet) null,
1224 true);
1225 Assert.Fail ("#1:" + invalid_name);
1226 } catch (ArgumentException ex) {
1227 // Assembly names may not begin with whitespace
1228 // or contain the characters '/', '\' or ':'
1229 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2:" + invalid_name);
1230 Assert.IsNull (ex.InnerException, "#3:" + invalid_name);
1231 Assert.IsNotNull (ex.Message, "#4:" + invalid_name);
1232 Assert.IsTrue (ex.Message.IndexOf ("'/'") != -1, "#5:" + invalid_name);
1233 Assert.IsTrue (ex.Message.IndexOf ("'\\'") != -1, "#6:" + invalid_name);
1234 Assert.IsTrue (ex.Message.IndexOf ("':'") != -1, "#7:" + invalid_name);
1235 Assert.IsNull (ex.ParamName, "#8:" + invalid_name);
1236 }
1237 }
1238 }
1239
1240 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, String, Evidence, PermissionSet, PermissionSet, PermissionSet, Boolean)
1241 public void DefineDynamicAssembly9_Name_Null ()
1242 {
1243 try {
1244 AppDomain.CurrentDomain.DefineDynamicAssembly (
1245 (AssemblyName) null,
1246 AssemblyBuilderAccess.Run,
1247 Path.GetTempPath (),
1248 AppDomain.CurrentDomain.Evidence,
1249 (PermissionSet) null,
1250 (PermissionSet) null,
1251 (PermissionSet) null,
1252 true);
1253 Assert.Fail ("#A1");
1254 } catch (ArgumentNullException ex) {
1255 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
1256 Assert.IsNull (ex.InnerException, "#A3");
1257 Assert.IsNotNull (ex.Message, "#A4");
1258 Assert.IsNotNull (ex.ParamName, "#A5");
1259 Assert.AreEqual ("name", ex.ParamName, "#A6");
1260 }
1261
1262 AssemblyName name = new AssemblyName ();
1263
1264 try {
1265 AppDomain.CurrentDomain.DefineDynamicAssembly (
1266 name,
1267 AssemblyBuilderAccess.Run,
1268 Path.GetTempPath (),
1269 AppDomain.CurrentDomain.Evidence,
1270 (PermissionSet) null,
1271 (PermissionSet) null,
1272 (PermissionSet) null,
1273 true);
1274 Assert.Fail ("#B1");
1275 } catch (ArgumentException ex) {
1276 // AssemblyName.Name cannot be null or an empty string
1277 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1278 Assert.IsNull (ex.InnerException, "#B3");
1279 Assert.IsNotNull (ex.Message, "#B4");
1280 Assert.IsNull (ex.ParamName, "#B5");
1281 }
1282
1283 name.Name = string.Empty;
1284
1285 try {
1286 AppDomain.CurrentDomain.DefineDynamicAssembly (
1287 name,
1288 AssemblyBuilderAccess.Run,
1289 Path.GetTempPath (),
1290 AppDomain.CurrentDomain.Evidence,
1291 (PermissionSet) null,
1292 (PermissionSet) null,
1293 (PermissionSet) null,
1294 true);
1295 Assert.Fail ("#C1");
1296 } catch (ArgumentException ex) {
1297 // AssemblyName.Name cannot be null or an empty string
1298 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
1299 Assert.IsNull (ex.InnerException, "#C3");
1300 Assert.IsNotNull (ex.Message, "#C4");
1301 Assert.IsNull (ex.ParamName, "#C5");
1302 }
1303 }
1304
1305 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, String, Evidence, PermissionSet, PermissionSet, PermissionSet, Boolean, IEnumerable<CustomAttributeBuilder>)
1306 public void DefineDynamicAssembly10_Access_Invalid ()
1307 {
1308 AssemblyName name = new AssemblyName ();
1309 name.Name = "DefineDynamicAssembly10";
1310
1311 try {
1312 AppDomain.CurrentDomain.DefineDynamicAssembly (
1313 name, AssemblyBuilderAccess.Run |
1314 (AssemblyBuilderAccess) 666,
1315 Path.GetTempPath (),
1316 AppDomain.CurrentDomain.Evidence,
1317 (PermissionSet) null,
1318 (PermissionSet) null,
1319 (PermissionSet) null,
1320 true,
1321 new List<CustomAttributeBuilder> ());
1322 Assert.Fail ("#1");
1323 } catch (ArgumentException ex) {
1324 // Illegal enum value: 667
1325 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1326 Assert.IsNull (ex.InnerException, "#3");
1327 Assert.IsNotNull (ex.Message, "#4");
1328 Assert.IsTrue (ex.Message.IndexOf ("667") != -1, "#5");
1329 Assert.IsNotNull (ex.ParamName, "#6");
1330 Assert.AreEqual ("access", ex.ParamName, "#7");
1331 }
1332 }
1333
1334 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, String, Evidence, PermissionSet, PermissionSet, PermissionSet, Boolean, IEnumerable<CustomAttributeBuilder>)
1335 public void DefineDynamicAssembly10_Name_InvalidChars ()
1336 {
1337 string [] invalid_char_names = new string [] {
1338 "\tAB",
1339 " AB",
1340 "\rAB",
1341 "A/B",
1342 ":AB",
1343 "B:A",
1344 "B\\A",
1345 "BA\\"};
1346
1347 AssemblyName name = new AssemblyName ();
1348
1349 foreach (string invalid_name in invalid_char_names) {
1350 name.Name = invalid_name;
1351 try {
1352 AppDomain.CurrentDomain.DefineDynamicAssembly (
1353 name,
1354 AssemblyBuilderAccess.Run,
1355 Path.GetTempPath (),
1356 AppDomain.CurrentDomain.Evidence,
1357 (PermissionSet) null,
1358 (PermissionSet) null,
1359 (PermissionSet) null,
1360 true,
1361 new List<CustomAttributeBuilder> ());
1362 Assert.Fail ("#1:" + invalid_name);
1363 } catch (ArgumentException ex) {
1364 // Assembly names may not begin with whitespace
1365 // or contain the characters '/', '\' or ':'
1366 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2:" + invalid_name);
1367 Assert.IsNull (ex.InnerException, "#3:" + invalid_name);
1368 Assert.IsNotNull (ex.Message, "#4:" + invalid_name);
1369 Assert.IsTrue (ex.Message.IndexOf ("'/'") != -1, "#5:" + invalid_name);
1370 Assert.IsTrue (ex.Message.IndexOf ("'\\'") != -1, "#6:" + invalid_name);
1371 Assert.IsTrue (ex.Message.IndexOf ("':'") != -1, "#7:" + invalid_name);
1372 Assert.IsNull (ex.ParamName, "#8:" + invalid_name);
1373 }
1374 }
1375 }
1376
1377 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, String, Evidence, PermissionSet, PermissionSet, PermissionSet, Boolean, IEnumerable<CustomAttributeBuilder>)
1378 public void DefineDynamicAssembly10_Name_Null ()
1379 {
1380 try {
1381 AppDomain.CurrentDomain.DefineDynamicAssembly (
1382 (AssemblyName) null,
1383 AssemblyBuilderAccess.Run,
1384 Path.GetTempPath (),
1385 AppDomain.CurrentDomain.Evidence,
1386 (PermissionSet) null,
1387 (PermissionSet) null,
1388 (PermissionSet) null,
1389 true,
1390 new List<CustomAttributeBuilder> ());
1391 Assert.Fail ("#A1");
1392 } catch (ArgumentNullException ex) {
1393 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
1394 Assert.IsNull (ex.InnerException, "#A3");
1395 Assert.IsNotNull (ex.Message, "#A4");
1396 Assert.IsNotNull (ex.ParamName, "#A5");
1397 Assert.AreEqual ("name", ex.ParamName, "#A6");
1398 }
1399
1400 AssemblyName name = new AssemblyName ();
1401
1402 try {
1403 AppDomain.CurrentDomain.DefineDynamicAssembly (
1404 name,
1405 AssemblyBuilderAccess.Run,
1406 Path.GetTempPath (),
1407 AppDomain.CurrentDomain.Evidence,
1408 (PermissionSet) null,
1409 (PermissionSet) null,
1410 (PermissionSet) null,
1411 true,
1412 new List<CustomAttributeBuilder> ());
1413 Assert.Fail ("#B1");
1414 } catch (ArgumentException ex) {
1415 // AssemblyName.Name cannot be null or an empty string
1416 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1417 Assert.IsNull (ex.InnerException, "#B3");
1418 Assert.IsNotNull (ex.Message, "#B4");
1419 Assert.IsNull (ex.ParamName, "#B5");
1420 }
1421
1422 name.Name = string.Empty;
1423
1424 try {
1425 AppDomain.CurrentDomain.DefineDynamicAssembly (
1426 name,
1427 AssemblyBuilderAccess.Run,
1428 Path.GetTempPath (),
1429 AppDomain.CurrentDomain.Evidence,
1430 (PermissionSet) null,
1431 (PermissionSet) null,
1432 (PermissionSet) null,
1433 true,
1434 new List<CustomAttributeBuilder> ());
1435 Assert.Fail ("#C1");
1436 } catch (ArgumentException ex) {
1437 // AssemblyName.Name cannot be null or an empty string
1438 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
1439 Assert.IsNull (ex.InnerException, "#C3");
1440 Assert.IsNotNull (ex.Message, "#C4");
1441 Assert.IsNull (ex.ParamName, "#C5");
1442 }
1443 }
1444
1445 [Test] // DefineDynamicAssembly (AssemblyName name, AssemblyBuilderAccess, IEnumerable<CustomAttributeBuilder>)
1446 public void DefineDynamicAssembly11 ()
1447 {
1448 List<CustomAttributeBuilder> cattrs;
1449 AssemblyBuilder ab;
1450 Attribute attr;
1451 AssemblyName name;
1452 string assemblyFile;
1453 string current_dir = Directory.GetCurrentDirectory ();
1454
1455 name = new AssemblyName ();
1456 name.Name = "DefineDynamicAssembly11A";
1457
1458 cattrs = new List<CustomAttributeBuilder> ();
1459 cattrs.Add (new CustomAttributeBuilder (typeof (AssemblyVersionAttribute).
1460 GetConstructor (new Type [] { typeof (string) }),
1461 new object [] { "1.2.3.4"}));
1462 cattrs.Add (new CustomAttributeBuilder (typeof (AssemblyCultureAttribute).
1463 GetConstructor (new Type [] { typeof (string) }),
1464 new object [] { "nl-BE"}));
1465 cattrs.Add (new CustomAttributeBuilder (typeof (AssemblyAlgorithmIdAttribute).
1466 GetConstructor (new Type [] { typeof (AssemblyHashAlgorithm) }),
1467 new object [] { AssemblyHashAlgorithm.MD5 }));
1468 cattrs.Add (new CustomAttributeBuilder (typeof (AssemblyFlagsAttribute).
1469 GetConstructor (new Type [] { typeof (uint) }),
1470 new object [] { (uint)0x0100 }));
1471 cattrs.Add (new CustomAttributeBuilder (typeof (CLSCompliantAttribute).
1472 GetConstructor (new Type [] { typeof (bool) }),
1473 new object [] { true }));
1474
1475 ab = AppDomain.CurrentDomain.DefineDynamicAssembly (
1476 name, AssemblyBuilderAccess.Save, cattrs);
1477
1478 ab.SetCustomAttribute (new CustomAttributeBuilder (typeof (ComVisibleAttribute).
1479 GetConstructor (new Type [] { typeof (bool) }),
1480 new object [] { true }));
1481
1482 ab.Save ("DefineDynamicAssembly11A.dll");
1483
1484 assemblyFile = Path.Combine (current_dir, "DefineDynamicAssembly11A.dll");
1485
1486 try {
1487 AssemblyName an = AssemblyName.GetAssemblyName (assemblyFile);
1488 Assert.AreEqual (CultureInfo.InvariantCulture, an.CultureInfo, "#A1");
1489 Assert.AreEqual (AssemblyNameFlags.None, an.Flags, "#A2");
1490 Assert.AreEqual ("DefineDynamicAssembly11A, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null", an.FullName, "#A3");
1491 Assert.IsNull (an.GetPublicKey (), "#A4");
1492 Assert.AreEqual (new byte [0], an.GetPublicKeyToken (), "#A5");
1493 Assert.AreEqual (AssemblyHashAlgorithm.SHA1, an.HashAlgorithm, "#A6");
1494 Assert.IsNull (an.KeyPair, "#A7");
1495 Assert.AreEqual ("DefineDynamicAssembly11A", an.Name, "#A8");
1496 //Assert.AreEqual (ProcessorArchitecture.MSIL, an.ProcessorArchitecture, "#A9");
1497 Assert.AreEqual (an.FullName, an.ToString (), "#A10");
1498 Assert.AreEqual (new Version (0, 0, 0, 0), an.Version, "#A11");
1499 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine, an.VersionCompatibility, "#A12");
1500
1501 Assembly a;
1502
1503 using (FileStream fs = File.OpenRead (assemblyFile)) {
1504 byte [] buffer = new byte [fs.Length];
1505 fs.Read (buffer, 0, buffer.Length);
1506 a = Assembly.Load (buffer);
1507 }
1508
1509 attr = Attribute.GetCustomAttribute (a, typeof (AssemblyVersionAttribute));
1510 Assert.IsNotNull (attr, "#A13a");
1511 Assert.AreEqual ("1.2.3.4", ((AssemblyVersionAttribute) attr).Version, "#A13b");
1512 attr = Attribute.GetCustomAttribute (a, typeof (AssemblyCultureAttribute));
1513 Assert.IsNotNull (attr, "#A14a");
1514 Assert.AreEqual ("nl-BE", ((AssemblyCultureAttribute) attr).Culture, "#A14b");
1515 attr = Attribute.GetCustomAttribute (a, typeof (AssemblyAlgorithmIdAttribute));
1516 Assert.IsNotNull (attr, "#A15a");
1517 Assert.AreEqual ((uint) AssemblyHashAlgorithm.MD5, ((AssemblyAlgorithmIdAttribute) attr).AlgorithmId, "#A15b");
1518 attr = Attribute.GetCustomAttribute (a, typeof (AssemblyFlagsAttribute));
1519 Assert.IsNotNull (attr, "#A16a");
1520 Assert.AreEqual ((uint) 0x0100, ((AssemblyFlagsAttribute) attr).Flags, "#A16b");
1521 attr = Attribute.GetCustomAttribute (a, typeof (CLSCompliantAttribute));
1522 Assert.IsNotNull (attr, "#A17a");
1523 Assert.IsTrue (((CLSCompliantAttribute) attr).IsCompliant, "#A17b");
1524 attr = Attribute.GetCustomAttribute (a, typeof (ComVisibleAttribute));
1525 Assert.IsNotNull (attr, "#A18a");
1526 Assert.IsTrue (((ComVisibleAttribute) attr).Value, "#A18b");
1527 } finally {
1528 File.Delete (assemblyFile);
1529 }
1530
1531 name = new AssemblyName ();
1532 name.CultureInfo = new CultureInfo ("fr-BE");
1533 name.KeyPair = new StrongNameKeyPair (keyPair);
1534 name.Name = "DefineDynamicAssembly11B";
1535 name.Version = new Version (3, 2, 4, 1);
1536
1537 cattrs = new List<CustomAttributeBuilder> ();
1538 cattrs.Add (new CustomAttributeBuilder (typeof (AssemblyVersionAttribute).
1539 GetConstructor (new Type [] { typeof (string) }),
1540 new object [] { "1.2.3.4"}));
1541 cattrs.Add (new CustomAttributeBuilder (typeof (AssemblyCultureAttribute).
1542 GetConstructor (new Type [] { typeof (string) }),
1543 new object [] { "nl-BE"}));
1544 cattrs.Add (new CustomAttributeBuilder (typeof (AssemblyAlgorithmIdAttribute).
1545 GetConstructor (new Type [] { typeof (AssemblyHashAlgorithm) }),
1546 new object [] { AssemblyHashAlgorithm.MD5 }));
1547 cattrs.Add (new CustomAttributeBuilder (typeof (AssemblyFlagsAttribute).
1548 GetConstructor (new Type [] { typeof (uint) }),
1549 new object [] { (uint)0x0100 }));
1550 cattrs.Add (new CustomAttributeBuilder (typeof (CLSCompliantAttribute).
1551 GetConstructor (new Type [] { typeof (bool) }),
1552 new object [] { true }));
1553
1554 ab = AppDomain.CurrentDomain.DefineDynamicAssembly (
1555 name, AssemblyBuilderAccess.Save, cattrs);
1556
1557 ab.SetCustomAttribute (new CustomAttributeBuilder (typeof (ComVisibleAttribute).
1558 GetConstructor (new Type [] { typeof (bool) }),
1559 new object [] { true }));
1560
1561 ab.Save ("DefineDynamicAssembly11B.dll");
1562
1563 assemblyFile = Path.Combine (current_dir, "DefineDynamicAssembly11B.dll");
1564
1565 try {
1566 AssemblyName an = AssemblyName.GetAssemblyName (assemblyFile);
1567 Assert.AreEqual ("fr-BE", an.CultureInfo.Name, "#B1");
1568 Assert.AreEqual (AssemblyNameFlags.PublicKey, an.Flags, "#B2");
1569 Assert.AreEqual ("DefineDynamicAssembly11B, Version=3.2.4.1, Culture=fr-BE, PublicKeyToken=ce5276d8687ec6dc", an.FullName, "#B3");
1570 Assert.AreEqual (publicKey, an.GetPublicKey (), "#B4");
1571 Assert.AreEqual (pk_token, an.GetPublicKeyToken (), "#B5");
1572 Assert.AreEqual (AssemblyHashAlgorithm.SHA1, an.HashAlgorithm, "#B6");
1573 Assert.IsNull (an.KeyPair, "#B7");
1574 Assert.AreEqual ("DefineDynamicAssembly11B", an.Name, "#B8");
1575 //Assert.AreEqual (ProcessorArchitecture.MSIL, an.ProcessorArchitecture, "#B9");
1576 Assert.AreEqual (an.FullName, an.ToString (), "#B10");
1577 Assert.AreEqual (new Version (3, 2, 4, 1), an.Version, "#B11");
1578 Assert.AreEqual (AssemblyVersionCompatibility.SameMachine, an.VersionCompatibility, "#B12");
1579
1580 Assembly a;
1581
1582 using (FileStream fs = File.OpenRead (assemblyFile)) {
1583 byte [] buffer = new byte [fs.Length];
1584 fs.Read (buffer, 0, buffer.Length);
1585 a = Assembly.Load (buffer);
1586 }
1587
1588 attr = Attribute.GetCustomAttribute (a, typeof (AssemblyVersionAttribute));
1589 Assert.IsNotNull (attr, "#B13a");
1590 Assert.AreEqual ("1.2.3.4", ((AssemblyVersionAttribute) attr).Version, "#B13b");
1591 attr = Attribute.GetCustomAttribute (a, typeof (AssemblyCultureAttribute));
1592 Assert.IsNotNull (attr, "#B14a");
1593 Assert.AreEqual ("nl-BE", ((AssemblyCultureAttribute) attr).Culture, "#B14b");
1594 attr = Attribute.GetCustomAttribute (a, typeof (AssemblyAlgorithmIdAttribute));
1595 Assert.IsNotNull (attr, "#B15a");
1596 Assert.AreEqual ((uint) AssemblyHashAlgorithm.MD5, ((AssemblyAlgorithmIdAttribute) attr).AlgorithmId, "#B15b");
1597 attr = Attribute.GetCustomAttribute (a, typeof (AssemblyFlagsAttribute));
1598 Assert.IsNotNull (attr, "#B16a");
1599 Assert.AreEqual ((uint) 0x0100, ((AssemblyFlagsAttribute) attr).Flags, "#B16b");
1600 attr = Attribute.GetCustomAttribute (a, typeof (CLSCompliantAttribute));
1601 Assert.IsNotNull (attr, "#B17a");
1602 Assert.IsTrue (((CLSCompliantAttribute) attr).IsCompliant, "#B17b");
1603 attr = Attribute.GetCustomAttribute (a, typeof (ComVisibleAttribute));
1604 Assert.IsNotNull (attr, "#B18a");
1605 Assert.IsTrue (((ComVisibleAttribute) attr).Value, "#B18b");
1606 } finally {
1607 File.Delete (assemblyFile);
1608 }
1609 }
1610
1611 [Test] // DefineDynamicAssembly (AssemblyName name, AssemblyBuilderAccess, IEnumerable<CustomAttributeBuilder>)
1612 public void DefineDynamicAssembly11_Access_Invalid ()
1613 {
1614 AssemblyName name = new AssemblyName ();
1615 name.Name = "DefineDynamicAssembly11";
1616
1617 try {
1618 AppDomain.CurrentDomain.DefineDynamicAssembly (
1619 name, AssemblyBuilderAccess.Run |
1620 (AssemblyBuilderAccess) 666,
1621 new List<CustomAttributeBuilder> ());
1622 Assert.Fail ("#1");
1623 } catch (ArgumentException ex) {
1624 // Illegal enum value: 667
1625 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1626 Assert.IsNull (ex.InnerException, "#3");
1627 Assert.IsNotNull (ex.Message, "#4");
1628 Assert.IsTrue (ex.Message.IndexOf ("667") != -1, "#5");
1629 Assert.IsNotNull (ex.ParamName, "#6");
1630 Assert.AreEqual ("access", ex.ParamName, "#7");
1631 }
1632 }
1633
1634 [Test] // DefineDynamicAssembly (AssemblyName name, AssemblyBuilderAccess, IEnumerable<CustomAttributeBuilder>)
1635 public void DefineDynamicAssembly11_Name_InvalidChars ()
1636 {
1637 string [] invalid_char_names = new string [] {
1638 "\tAB",
1639 " AB",
1640 "\rAB",
1641 "A/B",
1642 ":AB",
1643 "B:A",
1644 "B\\A",
1645 "BA\\"};
1646
1647 AssemblyName name = new AssemblyName ();
1648
1649 foreach (string invalid_name in invalid_char_names) {
1650 name.Name = invalid_name;
1651 try {
1652 AppDomain.CurrentDomain.DefineDynamicAssembly (
1653 name,
1654 AssemblyBuilderAccess.Run,
1655 new List<CustomAttributeBuilder> ());
1656 Assert.Fail ("#1:" + invalid_name);
1657 } catch (ArgumentException ex) {
1658 // Assembly names may not begin with whitespace
1659 // or contain the characters '/', '\' or ':'
1660 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2:" + invalid_name);
1661 Assert.IsNull (ex.InnerException, "#3:" + invalid_name);
1662 Assert.IsNotNull (ex.Message, "#4:" + invalid_name);
1663 Assert.IsTrue (ex.Message.IndexOf ("'/'") != -1, "#5:" + invalid_name);
1664 Assert.IsTrue (ex.Message.IndexOf ("'\\'") != -1, "#6:" + invalid_name);
1665 Assert.IsTrue (ex.Message.IndexOf ("':'") != -1, "#7:" + invalid_name);
1666 Assert.IsNull (ex.ParamName, "#8:" + invalid_name);
1667 }
1668 }
1669 }
1670
1671 [Test] // DefineDynamicAssembly (AssemblyName, AssemblyBuilderAccess, String, Evidence, PermissionSet, PermissionSet, PermissionSet, Boolean, IEnumerable<CustomAttributeBuilder>)
1672 public void DefineDynamicAssembly11_Name_Null ()
1673 {
1674 try {
1675 AppDomain.CurrentDomain.DefineDynamicAssembly (
1676 (AssemblyName) null,
1677 AssemblyBuilderAccess.Run,
1678 new List<CustomAttributeBuilder> ());
1679 Assert.Fail ("#A1");
1680 } catch (ArgumentNullException ex) {
1681 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
1682 Assert.IsNull (ex.InnerException, "#A3");
1683 Assert.IsNotNull (ex.Message, "#A4");
1684 Assert.IsNotNull (ex.ParamName, "#A5");
1685 Assert.AreEqual ("name", ex.ParamName, "#A6");
1686 }
1687
1688 AssemblyName name = new AssemblyName ();
1689
1690 try {
1691 AppDomain.CurrentDomain.DefineDynamicAssembly (
1692 name,
1693 AssemblyBuilderAccess.Run,
1694 new List<CustomAttributeBuilder> ());
1695 Assert.Fail ("#B1");
1696 } catch (ArgumentException ex) {
1697 // AssemblyName.Name cannot be null or an empty string
1698 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1699 Assert.IsNull (ex.InnerException, "#B3");
1700 Assert.IsNotNull (ex.Message, "#B4");
1701 Assert.IsNull (ex.ParamName, "#B5");
1702 }
1703
1704 name.Name = string.Empty;
1705
1706 try {
1707 AppDomain.CurrentDomain.DefineDynamicAssembly (
1708 name,
1709 AssemblyBuilderAccess.Run,
1710 new List<CustomAttributeBuilder> ());
1711 Assert.Fail ("#C1");
1712 } catch (ArgumentException ex) {
1713 // AssemblyName.Name cannot be null or an empty string
1714 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
1715 Assert.IsNull (ex.InnerException, "#C3");
1716 Assert.IsNotNull (ex.Message, "#C4");
1717 Assert.IsNull (ex.ParamName, "#C5");
1718 }
1719 }
1720
1721 [Test] // ExecuteAssemblyByName (String)
1722 public void ExecuteAssemblyByName1_NoEntryPoint ()
1723 {
1724 try {
1725 AppDomain.CurrentDomain.ExecuteAssemblyByName ("mscorlib");
1726 Assert.Fail ("#1");
1727 } catch (MissingMethodException ex) {
1728 // Entry point not found in assembly '...'
1729 Assert.AreEqual (typeof (MissingMethodException), ex.GetType (), "#2");
1730 Assert.IsNull (ex.InnerException, "#3");
1731 Assert.IsNotNull (ex.Message, "#4");
1732 Assert.IsTrue (ex.Message.IndexOf (typeof (object).Assembly.FullName) != -1, "#5");
1733 }
1734 }
1735
1736 [Test] // ExecuteAssemblyByName (String, Evidence)
1737 public void ExecuteAssemblyByName2_NoEntryPoint ()
1738 {
1739 try {
1740 AppDomain.CurrentDomain.ExecuteAssemblyByName (
1741 "mscorlib", (Evidence) null);
1742 Assert.Fail ("#1");
1743 } catch (MissingMethodException ex) {
1744 // Entry point not found in assembly '...'
1745 Assert.AreEqual (typeof (MissingMethodException), ex.GetType (), "#2");
1746 Assert.IsNull (ex.InnerException, "#3");
1747 Assert.IsNotNull (ex.Message, "#4");
1748 Assert.IsTrue (ex.Message.IndexOf (typeof (object).Assembly.FullName) != -1, "#5");
1749 }
1750 }
1751
1752 [Test] // ExecuteAssemblyByName (String, Evidence, String [])
1753 public void ExecuteAssemblyByName3_NoEntryPoint ()
1754 {
1755 try {
1756 AppDomain.CurrentDomain.ExecuteAssemblyByName (
1757 "mscorlib", (Evidence) null,
1758 new string [0]);
1759 Assert.Fail ("#1");
1760 } catch (MissingMethodException ex) {
1761 // Entry point not found in assembly '...'
1762 Assert.AreEqual (typeof (MissingMethodException), ex.GetType (), "#2");
1763 Assert.IsNull (ex.InnerException, "#3");
1764 Assert.IsNotNull (ex.Message, "#4");
1765 Assert.IsTrue (ex.Message.IndexOf (typeof (object).Assembly.FullName) != -1, "#5");
1766 }
1767 }
1768
1769 [Test] // ExecuteAssemblyByName (AssemblyName, Evidence, String [])
1770 public void ExecuteAssemblyByName4_NoEntryPoint ()
1771 {
1772 AssemblyName aname = new AssemblyName ("mscorlib");
1773
1774 try {
1775 AppDomain.CurrentDomain.ExecuteAssemblyByName (
1776 aname, (Evidence) null, new string [0]);
1777 Assert.Fail ("#1");
1778 } catch (MissingMethodException ex) {
1779 // Entry point not found in assembly '...'
1780 Assert.AreEqual (typeof (MissingMethodException), ex.GetType (), "#2");
1781 Assert.IsNull (ex.InnerException, "#3");
1782 Assert.IsNotNull (ex.Message, "#4");
1783 Assert.IsTrue (ex.Message.IndexOf (typeof (object).Assembly.FullName) != -1, "#5");
1784 }
1785 }
1786
1787 [Test]
1788 public void SetThreadPrincipal ()
1789 {
1790 IIdentity i = new GenericIdentity ("sebastien@ximian.com", "rfc822");
1791 IPrincipal p = new GenericPrincipal (i, null);
1792 ad = AppDomain.CreateDomain ("SetThreadPrincipal");
1793 ad.SetThreadPrincipal (p);
1794 }
1795
1796 [Test]
1797 [ExpectedException (typeof (ArgumentNullException))]
1798 public void SetThreadPrincipalNull ()
1799 {
1800 AppDomain.CurrentDomain.SetThreadPrincipal (null);
1801 }
1802
1803 [Test]
1804 [ExpectedException (typeof (PolicyException))]
1805 public void SetThreadPrincipalTwice ()
1806 {
1807 IIdentity i = new GenericIdentity ("sebastien@ximian.com", "rfc822");
1808 IPrincipal p = new GenericPrincipal (i, null);
1809 ad = AppDomain.CreateDomain ("SetThreadPrincipalTwice");
1810 ad.SetThreadPrincipal (p);
1811 // you only live twice (or so James told me ;-)
1812 ad.SetThreadPrincipal (p);
1813 }
1814
1815 [Test]
1816 [ExpectedException (typeof (AppDomainUnloadedException))]
1817 public void SetThreadPrincipalUnloaded ()
1818 {
1819 ad = AppDomain.CreateDomain ("Ximian");
1820 AppDomain.Unload (ad);
1821 IIdentity i = new GenericIdentity ("sebastien@ximian.com", "rfc822");
1822 IPrincipal p = new GenericPrincipal (i, null);
1823 ad.SetThreadPrincipal (p);
1824 }
1825
1826 [Test]
1827 public void SetPrincipalPolicy_NoPrincipal ()
1828 {
1829 AppDomain.CurrentDomain.SetPrincipalPolicy (PrincipalPolicy.NoPrincipal);
1830 }
1831
1832 [Test]
1833 public void SetPrincipalPolicy_UnauthenticatedPrincipal ()
1834 {
1835 AppDomain.CurrentDomain.SetPrincipalPolicy (PrincipalPolicy.UnauthenticatedPrincipal);
1836 }
1837
1838 [Test]
1839 public void SetPrincipalPolicy_WindowsPrincipal ()
1840 {
1841 AppDomain.CurrentDomain.SetPrincipalPolicy (PrincipalPolicy.WindowsPrincipal);
1842 }
1843
1844 [Test]
1845 [ExpectedException (typeof (AppDomainUnloadedException))]
1846 public void SetPrincipalPolicyUnloaded ()
1847 {
1848 ad = AppDomain.CreateDomain ("Ximian");
1849 AppDomain.Unload (ad);
1850 ad.SetPrincipalPolicy (PrincipalPolicy.NoPrincipal);
1851 }
1852
1853 [Test]
1854 public void CreateDomain_String ()
1855 {
1856 ad = AppDomain.CreateDomain ("CreateDomain_String");
1857 Assert.IsNotNull (ad.Evidence, "Evidence");
1858 // Evidence are copied (or referenced?) from default app domain
1859 // we can't get default so we use the current (which should have copied the default)
1860 Assert.AreEqual (AppDomain.CurrentDomain.Evidence.Count, ad.Evidence.Count, "Evidence.Count");
1861 }
1862
1863 [Test]
1864 [ExpectedException (typeof (ArgumentNullException))]
1865 public void CreateDomain_String_Null ()
1866 {
1867 ad = AppDomain.CreateDomain (null);
1868 }
1869
1870 [Test]
1871 [Category ("NotDotNet")]
1872 public void CreateDomain_StringEvidence ()
1873 {
1874 Evidence e = new Evidence ();
1875 ad = AppDomain.CreateDomain ("CreateDomain_StringEvidence", e);
1876 Assert.IsNotNull (ad.Evidence, "Evidence");
1877 Assert.AreEqual (0, ad.Evidence.Count, "Evidence.Count");
1878
1879 e.AddHost (new Zone (SecurityZone.MyComputer));
1880 Assert.AreEqual (0, ad.Evidence.Count, "Evidence.Count");
1881 // evidence isn't copied but referenced
1882 }
1883
1884 [Test]
1885 [ExpectedException (typeof (ArgumentNullException))]
1886 public void CreateDomain_StringNullEvidence ()
1887 {
1888 ad = AppDomain.CreateDomain (null, new Evidence ());
1889 }
1890
1891 [Test]
1892 public void CreateDomain_StringEvidenceNull ()
1893 {
1894 ad = AppDomain.CreateDomain ("CreateDomain_StringEvidenceNull", null);
1895 Assert.IsNotNull (ad.Evidence, "Evidence");
1896 // Evidence are copied (or referenced?) from default app domain
1897 // we can't get default so we use the current (which should have copied the default)
1898 Evidence e = AppDomain.CurrentDomain.Evidence;
1899 Assert.AreEqual (e.Count, ad.Evidence.Count, "Evidence.Count-1");
1900 e.AddHost (new Zone (SecurityZone.MyComputer));
1901 Assert.AreEqual (e.Count - 1, ad.Evidence.Count, "Evidence.Count-2");
1902 // evidence are copied
1903 }
1904
1905 [Test]
1906 [Category ("NotDotNet")]
1907 public void CreateDomain_StringEvidenceAppDomainSetup ()
1908 {
1909 Evidence e = new Evidence ();
1910 AppDomainSetup info = new AppDomainSetup ();
1911 info.ApplicationName = "ApplicationName";
1912
1913 ad = AppDomain.CreateDomain ("CreateDomain_StringEvidenceAppDomainSetup", e, info);
1914 Assert.IsNotNull (ad.Evidence, "Evidence");
1915 Assert.AreEqual (0, ad.Evidence.Count, "Evidence.Count");
1916 Assert.IsNotNull (ad.SetupInformation, "SetupInformation");
1917 Assert.AreEqual ("ApplicationName", ad.SetupInformation.ApplicationName);
1918
1919 e.AddHost (new Zone (SecurityZone.MyComputer));
1920 Assert.AreEqual (0, ad.Evidence.Count, "Evidence.Count");
1921 // evidence isn't copied but referenced
1922 }
1923
1924 [Test]
1925 [ExpectedException (typeof (ArgumentNullException))]
1926 public void CreateDomain_StringNullEvidenceAppDomainSetup ()
1927 {
1928 AppDomainSetup info = new AppDomainSetup ();
1929 ad = AppDomain.CreateDomain (null, new Evidence (), info);
1930 }
1931
1932 [Test]
1933 public void CreateDomain_StringEvidenceNullAppDomainSetup ()
1934 {
1935 AppDomainSetup info = new AppDomainSetup ();
1936 info.ApplicationName = "ApplicationName";
1937 ad = AppDomain.CreateDomain ("CreateDomain_StringEvidenceNullAppDomainSetup", null, info);
1938 Assert.IsNotNull (ad.Evidence, "Evidence");
1939 // Evidence are copied (or referenced?) from default app domain
1940 // we can't get default so we use the current (which should have copied the default)
1941 Assert.AreEqual (AppDomain.CurrentDomain.Evidence.Count, ad.Evidence.Count, "Evidence.Count");
1942 Assert.AreEqual ("ApplicationName", ad.SetupInformation.ApplicationName, "ApplicationName-1");
1943 info.ApplicationName = "Test";
1944 Assert.AreEqual ("Test", info.ApplicationName, "ApplicationName-2");
1945 Assert.AreEqual ("ApplicationName", ad.SetupInformation.ApplicationName, "ApplicationName-3");
1946 // copied
1947 }
1948
1949 [Test]
1950 [Category ("NotDotNet")]
1951 public void CreateDomain_StringEvidenceAppDomainSetupNull ()
1952 {
1953 Evidence e = new Evidence ();
1954 ad = AppDomain.CreateDomain ("CreateDomain_StringEvidenceAppDomainSetupNull", e, null);
1955 Assert.IsNotNull (ad.Evidence, "Evidence");
1956 Assert.AreEqual (0, ad.Evidence.Count, "Evidence.Count");
1957 // SetupInformation is copied from default app domain
1958 Assert.IsNotNull (ad.SetupInformation, "SetupInformation");
1959 }
1960
1961 [Test] // ExecuteAssembly (String)
1962 public void ExecuteAssembly1_NoEntryPoint ()
1963 {
1964 Assembly assembly = typeof (AppDomainTest).Assembly;
1965
1966 try {
1967 AppDomain.CurrentDomain.ExecuteAssembly (
1968 assembly.Location);
1969 Assert.Fail ("#1");
1970 } catch (MissingMethodException ex) {
1971 // Entry point not found in assembly '...'
1972 Assert.AreEqual (typeof (MissingMethodException), ex.GetType (), "#2");
1973 Assert.IsNull (ex.InnerException, "#3");
1974 Assert.IsNotNull (ex.Message, "#4");
1975 Assert.IsTrue (ex.Message.IndexOf (assembly.FullName) != -1, "#5");
1976 }
1977 }
1978
1979 [Test] // ExecuteAssembly (String, Evidence)
1980 public void ExecuteAssembly2_NoEntryPoint ()
1981 {
1982 Assembly assembly = typeof (AppDomainTest).Assembly;
1983
1984 try {
1985 AppDomain.CurrentDomain.ExecuteAssembly (
1986 assembly.Location,
1987 (Evidence) null);
1988 Assert.Fail ("#1");
1989 } catch (MissingMethodException ex) {
1990 // Entry point not found in assembly '...'
1991 Assert.AreEqual (typeof (MissingMethodException), ex.GetType (), "#2");
1992 Assert.IsNull (ex.InnerException, "#3");
1993 Assert.IsNotNull (ex.Message, "#4");
1994 Assert.IsTrue (ex.Message.IndexOf (assembly.FullName) != -1, "#5");
1995 }
1996 }
1997
1998 [Test] // ExecuteAssembly (String, Evidence, String [])
1999 public void ExecuteAssembly3_NoEntryPoint ()
2000 {
2001 Assembly assembly = typeof (AppDomainTest).Assembly;
2002
2003 try {
2004 AppDomain.CurrentDomain.ExecuteAssembly (
2005 assembly.Location,
2006 (Evidence) null,
2007 new string [0]);
2008 Assert.Fail ("#1");
2009 } catch (MissingMethodException ex) {
2010 // Entry point not found in assembly '...'
2011 Assert.AreEqual (typeof (MissingMethodException), ex.GetType (), "#2");
2012 Assert.IsNull (ex.InnerException, "#3");
2013 Assert.IsNotNull (ex.Message, "#4");
2014 Assert.IsTrue (ex.Message.IndexOf (assembly.FullName) != -1, "#5");
2015 }
2016 }
2017
2018 [Test] // ExecuteAssembly (String, Evidence, String [], Byte [], AssemblyHashAlgorithm)
2019 [Category ("NotWorking")] // Not implemented
2020 public void ExecuteAssembly4_NoEntryPoint ()
2021 {
2022 Assembly assembly = typeof (AppDomainTest).Assembly;
2023
2024 try {
2025 AppDomain.CurrentDomain.ExecuteAssembly (
2026 assembly.Location,
2027 (Evidence) null,
2028 new string [0],
2029 (byte []) null,
2030 AssemblyHashAlgorithm.SHA1);
2031 Assert.Fail ("#1");
2032 } catch (MissingMethodException ex) {
2033 // Entry point not found in assembly '...'
2034 Assert.AreEqual (typeof (MissingMethodException), ex.GetType (), "#2");
2035 Assert.IsNull (ex.InnerException, "#3");
2036 Assert.IsNotNull (ex.Message, "#4");
2037 Assert.IsTrue (ex.Message.IndexOf (assembly.FullName) != -1, "#5");
2038 }
2039 }
2040
2041 [Test] // bug #79720
2042 [Category ("NotWorking")]
2043 public void Load_Loaded_Ignore ()
2044 {
2045 int assemblyStartCount = AppDomain.CurrentDomain.GetAssemblies ().Length;
2046
2047 // PART A
2048
2049 string assemblyFile = Path.Combine (tempDir, "bug79720A.dll");
2050 AssemblyName aname = new AssemblyName ();
2051 aname.Name = "bug79720A";
2052 aname.Version = new Version (2, 4);
2053
2054 GenerateAssembly (aname, assemblyFile);
2055
2056 Assert.AreEqual (assemblyStartCount, AppDomain.CurrentDomain.GetAssemblies ().Length, "#A1");
2057
2058 aname = new AssemblyName ();
2059 aname.Name = "bug79720A";
2060 try {
2061 AppDomain.CurrentDomain.Load (aname);
2062 Assert.Fail ("#A2");
2063 } catch (FileNotFoundException) {
2064 }
2065
2066 aname = new AssemblyName ();
2067 aname.Name = "bug79720A";
2068 aname.Version = new Version (0, 0, 0, 0);
2069 try {
2070 AppDomain.CurrentDomain.Load (aname);
2071 Assert.Fail ("#A3");
2072 } catch (FileNotFoundException) {
2073 }
2074
2075 aname = new AssemblyName ();
2076 aname.Name = "bug79720A";
2077 aname.Version = new Version (2, 4);
2078 try {
2079 AppDomain.CurrentDomain.Load (aname);
2080 Assert.Fail ("#A4");
2081 } catch (FileNotFoundException) {
2082 }
2083
2084 Assert.AreEqual (assemblyStartCount, AppDomain.CurrentDomain.GetAssemblies ().Length, "#A5");
2085
2086 Assembly.LoadFrom (assemblyFile);
2087
2088 Assert.AreEqual (assemblyStartCount + 1, AppDomain.CurrentDomain.GetAssemblies ().Length, "#A6");
2089
2090 aname = new AssemblyName ();
2091 aname.Name = "bug79720A";
2092 try {
2093 AppDomain.CurrentDomain.Load (aname);
2094 Assert.Fail ("#A7");
2095 } catch (FileNotFoundException) {
2096 }
2097
2098 aname = new AssemblyName ();
2099 aname.Name = "bug79720A";
2100 aname.Version = new Version (0, 0, 0, 0);
2101 try {
2102 AppDomain.CurrentDomain.Load (aname);
2103 Assert.Fail ("#A8");
2104 } catch (FileNotFoundException) {
2105 }
2106
2107 aname = new AssemblyName ();
2108 aname.Name = "bug79720A";
2109 aname.Version = new Version (2, 4);
2110 try {
2111 AppDomain.CurrentDomain.Load (aname);
2112 Assert.Fail ("#A9");
2113 } catch (FileNotFoundException) {
2114 }
2115
2116 aname = new AssemblyName ();
2117 aname.Name = "bug79720A";
2118 aname.Version = new Version (2, 4);
2119 aname.CultureInfo = CultureInfo.InvariantCulture;
2120 try {
2121 AppDomain.CurrentDomain.Load (aname);
2122 Assert.Fail ("#A10");
2123 } catch (FileNotFoundException) {
2124 }
2125
2126 aname = new AssemblyName ();
2127 aname.Name = "bug79720A";
2128 aname.Version = new Version (2, 4, 0, 0);
2129 aname.CultureInfo = CultureInfo.InvariantCulture;
2130 try {
2131 AppDomain.CurrentDomain.Load (aname);
2132 Assert.Fail ("#A11");
2133 } catch (FileNotFoundException) {
2134 }
2135
2136 Assert.AreEqual (assemblyStartCount + 1, AppDomain.CurrentDomain.GetAssemblies ().Length, "#A12");
2137
2138 // PART B
2139
2140 assemblyFile = Path.Combine (tempDir, "bug79720B.dll");
2141 aname = new AssemblyName ();
2142 aname.Name = "bug79720B";
2143 aname.Version = new Version (2, 4, 1);
2144 aname.CultureInfo = new CultureInfo ("nl-BE");
2145
2146 GenerateAssembly (aname, assemblyFile);
2147
2148 Assert.AreEqual (assemblyStartCount + 1, AppDomain.CurrentDomain.GetAssemblies ().Length, "#B1");
2149
2150 aname = new AssemblyName ();
2151 aname.Name = "bug79720B";
2152 try {
2153 AppDomain.CurrentDomain.Load (aname);
2154 Assert.Fail ("#B2");
2155 } catch (FileNotFoundException) {
2156 }
2157
2158 aname = new AssemblyName ();
2159 aname.Name = "bug79720B";
2160 aname.Version = new Version (0, 0, 0, 0);
2161 try {
2162 AppDomain.CurrentDomain.Load (aname);
2163 Assert.Fail ("#B3");
2164 } catch (FileNotFoundException) {
2165 }
2166
2167 aname = new AssemblyName ();
2168 aname.Name = "bug79720B";
2169 aname.Version = new Version (2, 4, 1);
2170 try {
2171 AppDomain.CurrentDomain.Load (aname);
2172 Assert.Fail ("#B4");
2173 } catch (FileNotFoundException) {
2174 }
2175
2176 aname = new AssemblyName ();
2177 aname.Name = "bug79720B";
2178 aname.Version = new Version (2, 4, 1);
2179 aname.CultureInfo = new CultureInfo ("nl-BE");
2180 try {
2181 AppDomain.CurrentDomain.Load (aname);
2182 Assert.Fail ("#B5");
2183 } catch (FileNotFoundException) {
2184 }
2185
2186 Assert.AreEqual (assemblyStartCount + 1, AppDomain.CurrentDomain.GetAssemblies ().Length, "#B6");
2187
2188 Assembly.LoadFrom (assemblyFile);
2189
2190 Assert.AreEqual (assemblyStartCount + 2, AppDomain.CurrentDomain.GetAssemblies ().Length, "#B7");
2191
2192 aname = new AssemblyName ();
2193 aname.Name = "bug79720B";
2194 try {
2195 AppDomain.CurrentDomain.Load (aname);
2196 Assert.Fail ("#B8");
2197 } catch (FileNotFoundException) {
2198 }
2199
2200 aname = new AssemblyName ();
2201 aname.Name = "bug79720B";
2202 aname.Version = new Version (0, 0, 0, 0);
2203 try {
2204 AppDomain.CurrentDomain.Load (aname);
2205 Assert.Fail ("#B9");
2206 } catch (FileNotFoundException) {
2207 }
2208
2209 aname = new AssemblyName ();
2210 aname.Name = "bug79720B";
2211 aname.Version = new Version (2, 4, 1);
2212 try {
2213 AppDomain.CurrentDomain.Load (aname);
2214 Assert.Fail ("#B10");
2215 } catch (FileNotFoundException) {
2216 }
2217
2218 aname = new AssemblyName ();
2219 aname.Name = "bug79720B";
2220 aname.Version = new Version (2, 4, 1);
2221 aname.CultureInfo = new CultureInfo ("nl-BE");
2222 try {
2223 AppDomain.CurrentDomain.Load (aname);
2224 Assert.Fail ("#B11");
2225 } catch (FileNotFoundException) {
2226 }
2227
2228 Assert.AreEqual (assemblyStartCount + 2, AppDomain.CurrentDomain.GetAssemblies ().Length, "#B12");
2229
2230 // PART C
2231
2232 assemblyFile = Path.Combine (tempDir, "bug79720C.dll");
2233 aname = new AssemblyName ();
2234 aname.Name = "bug79720C";
2235 aname.CultureInfo = new CultureInfo ("nl-BE");
2236 aname.Version = new Version (2, 4);
2237 aname.KeyPair = new StrongNameKeyPair (keyPair);
2238
2239 GenerateAssembly (aname, assemblyFile);
2240
2241 Assert.AreEqual (assemblyStartCount + 2, AppDomain.CurrentDomain.GetAssemblies ().Length, "#C1");
2242
2243 aname = new AssemblyName ();
2244 aname.Name = "bug79720C";
2245 try {
2246 AppDomain.CurrentDomain.Load (aname);
2247 Assert.Fail ("#C2");
2248 } catch (FileNotFoundException) {
2249 }
2250
2251 aname = new AssemblyName ();
2252 aname.Name = "bug79720C";
2253 aname.Version = new Version (0, 0, 0, 0);
2254 try {
2255 AppDomain.CurrentDomain.Load (aname);
2256 Assert.Fail ("#C3");
2257 } catch (FileNotFoundException) {
2258 }
2259
2260 aname = new AssemblyName ();
2261 aname.Name = "bug79720C";
2262 aname.Version = new Version (2, 4, 1);
2263 try {
2264 AppDomain.CurrentDomain.Load (aname);
2265 Assert.Fail ("#C4");
2266 } catch (FileNotFoundException) {
2267 }
2268
2269 aname = new AssemblyName ();
2270 aname.Name = "bug79720C";
2271 aname.Version = new Version (2, 4, 1);
2272 aname.CultureInfo = new CultureInfo ("nl-BE");
2273 try {
2274 AppDomain.CurrentDomain.Load (aname);
2275 Assert.Fail ("#C5");
2276 } catch (FileNotFoundException) {
2277 }
2278
2279 aname = new AssemblyName ();
2280 aname.Name = "bug79720C";
2281 aname.Version = new Version (2, 4, 1);
2282 aname.CultureInfo = new CultureInfo ("nl-BE");
2283 aname.SetPublicKey (publicKey);
2284 try {
2285 AppDomain.CurrentDomain.Load (aname);
2286 Assert.Fail ("#C6");
2287 } catch (FileNotFoundException) {
2288 }
2289
2290 Assert.AreEqual (assemblyStartCount + 2, AppDomain.CurrentDomain.GetAssemblies ().Length, "#C7");
2291
2292 Assembly.LoadFrom (assemblyFile);
2293
2294 Assert.AreEqual (assemblyStartCount + 3, AppDomain.CurrentDomain.GetAssemblies ().Length, "#C8");
2295
2296 aname = new AssemblyName ();
2297 aname.Name = "bug79720C";
2298 try {
2299 AppDomain.CurrentDomain.Load (aname);
2300 Assert.Fail ("#C9");
2301 } catch (FileNotFoundException) {
2302 }
2303
2304 aname = new AssemblyName ();
2305 aname.Name = "bug79720C";
2306 aname.Version = new Version (0, 0, 0, 0);
2307 try {
2308 AppDomain.CurrentDomain.Load (aname);
2309 Assert.Fail ("#C10");
2310 } catch (FileNotFoundException) {
2311 }
2312
2313 aname = new AssemblyName ();
2314 aname.Name = "bug79720C";
2315 aname.Version = new Version (2, 4);
2316 try {
2317 AppDomain.CurrentDomain.Load (aname);
2318 Assert.Fail ("#C11");
2319 } catch (FileNotFoundException) {
2320 }
2321
2322 aname = new AssemblyName ();
2323 aname.Name = "bug79720C";
2324 aname.Version = new Version (2, 4);
2325 aname.CultureInfo = new CultureInfo ("nl-BE");
2326 try {
2327 AppDomain.CurrentDomain.Load (aname);
2328 Assert.Fail ("#C12");
2329 } catch (FileNotFoundException) {
2330 }
2331
2332 aname = new AssemblyName ();
2333 aname.Name = "bug79720C";
2334 aname.Version = new Version (2, 4);
2335 aname.CultureInfo = new CultureInfo ("nl-BE");
2336 aname.SetPublicKey (publicKey);
2337 try {
2338 AppDomain.CurrentDomain.Load (aname);
2339 Assert.Fail ("#C13");
2340 } catch (FileNotFoundException) {
2341 }
2342
2343 Assert.AreEqual (assemblyStartCount + 3, AppDomain.CurrentDomain.GetAssemblies ().Length, "#C14");
2344 }
2345
2346 [Test]
2347 [Category ("NotWorking")]
2348 public void Load_Loaded_Multiple ()
2349 {
2350 string cultureDir = Path.Combine (tempDir, "nl-BE");
2351 if (!Directory.Exists (cultureDir))
2352 Directory.CreateDirectory (cultureDir);
2353
2354 AppDomain ad = CreateTestDomain (tempDir, true);
2355 try {
2356 CrossDomainTester cdt = CreateCrossDomainTester (ad);
2357
2358 int assemblyCount = cdt.AssemblyCount;
2359
2360 // PART A
2361
2362 AssemblyName aname = new AssemblyName ();
2363 aname.Name = "multipleA";
2364 aname.Version = new Version (1, 2, 3, 4);
2365 cdt.GenerateAssembly (aname, Path.Combine (tempDir, "multipleA.dll"));
2366
2367 Assert.AreEqual (assemblyCount + 1, cdt.AssemblyCount, "#A1");
2368
2369 aname = new AssemblyName ();
2370 aname.Name = "multipleA";
2371 Assert.IsTrue (cdt.AssertLoad (aname), "#A2");
2372
2373 Assert.AreEqual (assemblyCount + 2, cdt.AssemblyCount, "#A3");
2374
2375 aname = new AssemblyName ();
2376 aname.Name = "multipleA";
2377 Assert.IsTrue (cdt.AssertLoad (aname), "#A4");
2378
2379 aname = new AssemblyName ();
2380 aname.Name = "multipleA";
2381 aname.CultureInfo = CultureInfo.InvariantCulture;
2382 Assert.IsTrue (cdt.AssertLoad (aname), "#A5");
2383
2384 aname = new AssemblyName ();
2385 aname.Name = "multipleA";
2386 aname.CultureInfo = CultureInfo.InvariantCulture;
2387 Assert.IsTrue (cdt.AssertLoad (aname), "#A6");
2388
2389 aname = new AssemblyName ();
2390 aname.Name = "multipleA";
2391 aname.CultureInfo = CultureInfo.InvariantCulture;
2392 aname.Version = new Version (1, 2, 3, 4);
2393 Assert.IsTrue (cdt.AssertLoad (aname), "#A7");
2394
2395 aname = new AssemblyName ();
2396 aname.Name = "multipleA";
2397 aname.CultureInfo = CultureInfo.InvariantCulture;
2398 aname.Version = new Version (1, 2, 3, 4);
2399 Assert.IsTrue (cdt.AssertLoad (aname), "#A8");
2400
2401 Assert.AreEqual (assemblyCount + 2, cdt.AssemblyCount, "#A9");
2402
2403 // PART B
2404
2405 aname = new AssemblyName ();
2406 aname.Name = "multipleB";
2407 aname.CultureInfo = new CultureInfo ("nl-BE");
2408 aname.Version = new Version (2, 4, 1, 0);
2409 cdt.GenerateAssembly (aname, Path.Combine (tempDir, "nl-BE/multipleB.dll"));
2410
2411 Assert.AreEqual (assemblyCount + 3, cdt.AssemblyCount, "#B1");
2412
2413 aname = new AssemblyName ();
2414 aname.Name = "multipleB";
2415 Assert.IsTrue (cdt.AssertLoad (aname), "#B2");
2416
2417 Assert.AreEqual (assemblyCount + 4, cdt.AssemblyCount, "#B3");
2418
2419 aname = new AssemblyName ();
2420 aname.Name = "multipleB";
2421 Assert.IsTrue (cdt.AssertLoad (aname), "#B4");
2422
2423 aname = new AssemblyName ();
2424 aname.Name = "multipleB";
2425 aname.CultureInfo = new CultureInfo ("nl-BE");
2426 Assert.IsTrue (cdt.AssertLoad (aname), "#B5");
2427
2428 aname = new AssemblyName ();
2429 aname.Name = "multipleB";
2430 aname.CultureInfo = new CultureInfo ("nl-BE");
2431 Assert.IsTrue (cdt.AssertLoad (aname), "#B6");
2432
2433 aname = new AssemblyName ();
2434 aname.Name = "multipleB";
2435 aname.CultureInfo = new CultureInfo ("nl-BE");
2436 aname.Version = new Version (2, 4, 1, 0);
2437 Assert.IsTrue (cdt.AssertLoad (aname), "#B7");
2438
2439 aname = new AssemblyName ();
2440 aname.Name = "multipleB";
2441 aname.CultureInfo = new CultureInfo ("nl-BE");
2442 aname.Version = new Version (2, 4, 1, 0);
2443 Assert.IsTrue (cdt.AssertLoad (aname), "#B8");
2444
2445 Assert.AreEqual (assemblyCount + 4, cdt.AssemblyCount, "#B9");
2446
2447 // PART C
2448
2449 aname = new AssemblyName ();
2450 aname.Name = "multipleC";
2451 aname.CultureInfo = new CultureInfo ("nl-BE");
2452 aname.Version = new Version (2, 4, 0, 0);
2453 aname.KeyPair = new StrongNameKeyPair (keyPair);
2454 cdt.GenerateAssembly (aname, Path.Combine (tempDir, "nl-BE/multipleC.dll"));
2455
2456 Assert.AreEqual (assemblyCount + 5, cdt.AssemblyCount, "#C1");
2457
2458 aname = new AssemblyName ();
2459 aname.Name = "multipleC";
2460 aname.CultureInfo = new CultureInfo ("nl-BE");
2461 aname.Version = new Version (2, 4, 0, 0);
2462 aname.SetPublicKey (publicKey);
2463 Assert.IsTrue (cdt.AssertLoad (aname), "#C2");
2464
2465 Assert.AreEqual (assemblyCount + 6, cdt.AssemblyCount, "#C3");
2466
2467 aname = new AssemblyName ();
2468 aname.Name = "multipleC";
2469 aname.CultureInfo = new CultureInfo ("nl-BE");
2470 aname.Version = new Version (2, 4, 0, 0);
2471 aname.SetPublicKey (publicKey);
2472 Assert.IsTrue (cdt.AssertLoad (aname), "#C4");
2473
2474 Assert.AreEqual (assemblyCount + 6, cdt.AssemblyCount, "#C5");
2475 } finally {
2476 AppDomain.Unload (ad);
2477 }
2478 }
2479
2480 [Test] // bug #79522
2481 [Category ("NotWorking")]
2482 public void Load_Manifest_Mismatch ()
2483 {
2484 string assemblyFile = Path.Combine (tempDir, "bug79522A.dll");
2485 AssemblyName aname = new AssemblyName ();
2486 aname.Name = "bug79522A";
2487 aname.Version = new Version (2, 4);
2488
2489 GenerateAssembly (aname, assemblyFile);
2490
2491 aname = new AssemblyName ();
2492 aname.CodeBase = assemblyFile;
2493 aname.Name = "whateveryouwant";
2494 aname.Version = new Version (1, 1);
2495
2496 // despite the fact that no assembly with the specified name
2497 // exists, the assembly pointed to by the CodeBase of the
2498 // AssemblyName will be loaded
2499 //
2500 // however the display name of the loaded assembly does not
2501 // match the display name of the AssemblyName, and as a result
2502 // a FileLoadException is thrown
2503 try {
2504 AppDomain.CurrentDomain.Load (aname);
2505 Assert.Fail ("#A1");
2506 } catch (FileLoadException) {
2507 }
2508
2509 // if we set CodeBase to some garbage, then we'll get a
2510 // FileNotFoundException instead
2511 aname.CodeBase = "whatever";
2512 try {
2513 AppDomain.CurrentDomain.Load (aname);
2514 Assert.Fail ("#A2");
2515 } catch (FileNotFoundException) {
2516 }
2517
2518 aname = new AssemblyName ();
2519 aname.Name = "bug79522A";
2520 aname.CodeBase = assemblyFile;
2521 AppDomain.CurrentDomain.Load (aname);
2522
2523 aname = new AssemblyName ();
2524 aname.Name = "bug79522A";
2525 aname.CodeBase = assemblyFile;
2526 aname.Version = new Version (2, 5);
2527 // the version number is not considered when comparing the manifest
2528 // of the assembly found using codebase
2529 AppDomain.CurrentDomain.Load (aname);
2530
2531 aname = new AssemblyName ();
2532 aname.Name = "bug79522A";
2533 aname.CodeBase = assemblyFile;
2534 aname.Version = new Version (2, 4, 1);
2535 // the version number is not considered when comparing the manifest
2536 // of the assembly found using codebase
2537 AppDomain.CurrentDomain.Load (aname);
2538
2539 // if version is set, then culture must also be set
2540 aname = new AssemblyName ();
2541 aname.Name = "bug79522A";
2542 aname.CodeBase = assemblyFile;
2543 aname.Version = new Version (2, 4);
2544 AppDomain.CurrentDomain.Load (aname);
2545
2546 // version number does not need to be set
2547 aname = new AssemblyName ();
2548 aname.Name = "bug79522A";
2549 aname.CodeBase = assemblyFile;
2550 aname.CultureInfo = CultureInfo.InvariantCulture;
2551 AppDomain.CurrentDomain.Load (aname);
2552
2553 // if set, the version number must match exactly
2554 aname = new AssemblyName ();
2555 aname.Name = "bug79522A";
2556 aname.CodeBase = assemblyFile;
2557 aname.CultureInfo = CultureInfo.InvariantCulture;
2558 aname.Version = new Version (2, 4);
2559 AppDomain.CurrentDomain.Load (aname);
2560
2561 // if both culture and version are set, then the version diff
2562 // is ignored
2563 aname = new AssemblyName ();
2564 aname.Name = "bug79522A";
2565 aname.CodeBase = assemblyFile;
2566 aname.CultureInfo = CultureInfo.InvariantCulture;
2567 aname.Version = new Version (2, 5);
2568 AppDomain.CurrentDomain.Load (aname);
2569
2570 // loaded assembly is not signed
2571 aname = new AssemblyName ();
2572 aname.Name = "bug79522A";
2573 aname.CodeBase = assemblyFile;
2574 aname.CultureInfo = CultureInfo.InvariantCulture;
2575 aname.Version = new Version (2, 4);
2576 aname.SetPublicKey (publicKey);
2577 try {
2578 AppDomain.CurrentDomain.Load (aname);
2579 Assert.Fail ("#A7");
2580 } catch (FileLoadException) {
2581 }
2582
2583 // if set, the culture must match
2584 aname = new AssemblyName ();
2585 aname.Name = "bug79522A";
2586 aname.CodeBase = assemblyFile;
2587 aname.Version = new Version (2, 4);
2588 aname.CultureInfo = new CultureInfo ("en-US");
2589 try {
2590 AppDomain.CurrentDomain.Load (aname);
2591 Assert.Fail ("#A8");
2592 } catch (FileLoadException) {
2593 }
2594
2595 // PART B
2596
2597 assemblyFile = Path.Combine (tempDir, "bug79522B.dll");
2598 aname = new AssemblyName ();
2599 aname.Name = "bug79522B";
2600 aname.CultureInfo = new CultureInfo ("nl-BE");
2601 aname.Version = new Version (2, 4, 1);
2602
2603 GenerateAssembly (aname, assemblyFile);
2604
2605 aname = new AssemblyName ();
2606 aname.CodeBase = assemblyFile;
2607 aname.Name = "whateveryouwant";
2608 aname.CultureInfo = new CultureInfo ("nl-BE");
2609 aname.Version = new Version (1, 1);
2610
2611 // despite the fact that no assembly with the specified name
2612 // exists, the assembly pointed to by the CodeBase of the
2613 // AssemblyName will be loaded
2614 //
2615 // however the display name of the loaded assembly does not
2616 // match the display name of the AssemblyName, and as a result
2617 // a FileLoadException is thrown
2618 try {
2619 AppDomain.CurrentDomain.Load (aname);
2620 Assert.Fail ("#B1");
2621 } catch (FileLoadException) {
2622 }
2623
2624 // if we set CodeBase to some garbage, then we'll get a
2625 // FileNotFoundException instead
2626 aname.CodeBase = "whatever";
2627 try {
2628 AppDomain.CurrentDomain.Load (aname);
2629 Assert.Fail ("#B2");
2630 } catch (FileNotFoundException) {
2631 }
2632
2633 aname = new AssemblyName ();
2634 aname.Name = "bug79522B";
2635 aname.CodeBase = assemblyFile;
2636 // the version number is not considered when comparing the manifest
2637 // of the assembly found using codebase
2638 AppDomain.CurrentDomain.Load (aname);
2639
2640 aname = new AssemblyName ();
2641 aname.Name = "bug79522B";
2642 aname.CodeBase = assemblyFile;
2643 aname.Version = new Version (5, 5);
2644 // the version number is not considered when comparing the manifest
2645 // of the assembly found using codebase
2646 AppDomain.CurrentDomain.Load (aname);
2647
2648 aname = new AssemblyName ();
2649 aname.Name = "bug79522B";
2650 aname.CodeBase = assemblyFile;
2651 aname.Version = new Version (2, 4, 1);
2652 AppDomain.CurrentDomain.Load (aname);
2653
2654 // version does not need to be set
2655 aname = new AssemblyName ();
2656 aname.Name = "bug79522B";
2657 aname.CodeBase = assemblyFile;
2658 aname.CultureInfo = new CultureInfo ("nl-BE");
2659 AppDomain.CurrentDomain.Load (aname);
2660
2661 // if both culture and version are set, then the version diff
2662 // is ignored
2663 aname = new AssemblyName ();
2664 aname.Name = "bug79522B";
2665 aname.CodeBase = assemblyFile;
2666 aname.CultureInfo = new CultureInfo ("nl-BE");
2667 aname.Version = new Version (6, 5);
2668 AppDomain.CurrentDomain.Load (aname);
2669
2670 // loaded assembly is not signed
2671 aname = new AssemblyName ();
2672 aname.Name = "bug79522B";
2673 aname.CodeBase = assemblyFile;
2674 aname.CultureInfo = new CultureInfo ("nl-BE");
2675 aname.SetPublicKey (publicKey);
2676 try {
2677 AppDomain.CurrentDomain.Load (aname);
2678 Assert.Fail ("#B5");
2679 } catch (FileLoadException) {
2680 }
2681
2682 // if set, the culture must match
2683 aname = new AssemblyName ();
2684 aname.Name = "bug79522B";
2685 aname.CodeBase = assemblyFile;
2686 aname.Version = new Version (2, 4, 1);
2687 aname.CultureInfo = new CultureInfo ("en-US");
2688 try {
2689 AppDomain.CurrentDomain.Load (aname);
2690 Assert.Fail ("#B6");
2691 } catch (FileLoadException) {
2692 }
2693
2694 // PART C
2695
2696 assemblyFile = Path.Combine (tempDir, "bug79522C.dll");
2697 aname = new AssemblyName ();
2698 aname.Name = "bug79522C";
2699 aname.CultureInfo = new CultureInfo ("nl-BE");
2700 aname.Version = new Version (2, 4);
2701 aname.KeyPair = new StrongNameKeyPair (keyPair);
2702
2703 GenerateAssembly (aname, assemblyFile);
2704
2705 aname = new AssemblyName ();
2706 aname.CodeBase = assemblyFile;
2707 aname.Name = "whateveryouwant";
2708 aname.CultureInfo = new CultureInfo ("nl-BE");
2709 aname.Version = new Version (1, 1);
2710 aname.SetPublicKey (publicKey);
2711
2712 // despite the fact that no assembly with the specified name
2713 // exists, the assembly pointed to by the CodeBase of the
2714 // AssemblyName will be loaded
2715 //
2716 // however the display name of the loaded assembly does not
2717 // match the display name of the AssemblyName, and as a result
2718 // a FileLoadException is thrown
2719 try {
2720 AppDomain.CurrentDomain.Load (aname);
2721 Assert.Fail ("#C1");
2722 } catch (FileLoadException) {
2723 }
2724
2725 // if we set CodeBase to some garbage, then we'll get a
2726 // FileNotFoundException instead
2727 aname.CodeBase = "whatever";
2728 try {
2729 AppDomain.CurrentDomain.Load (aname);
2730 Assert.Fail ("#C2");
2731 } catch (FileNotFoundException) {
2732 }
2733
2734 aname = new AssemblyName ();
2735 aname.Name = "bug79522C";
2736 aname.CodeBase = assemblyFile;
2737 AppDomain.CurrentDomain.Load (aname);
2738
2739 aname = new AssemblyName ();
2740 aname.Name = "bug79522C";
2741 aname.CodeBase = assemblyFile;
2742 aname.Version = new Version (5, 5);
2743 try {
2744 AppDomain.CurrentDomain.Load (aname);
2745 Assert.Fail ("#C3");
2746 } catch (FileLoadException) {
2747 }
2748
2749 aname = new AssemblyName ();
2750 aname.Name = "bug79522C";
2751 aname.CodeBase = assemblyFile;
2752 aname.Version = new Version (2, 4);
2753 AppDomain.CurrentDomain.Load (aname);
2754
2755 aname = new AssemblyName ();
2756 aname.Name = "bug79522C";
2757 aname.CodeBase = assemblyFile;
2758 aname.CultureInfo = new CultureInfo ("nl-BE");
2759 aname.Version = new Version (2, 4);
2760 AppDomain.CurrentDomain.Load (aname);
2761
2762 aname = new AssemblyName ();
2763 aname.Name = "bug79522C";
2764 aname.CodeBase = assemblyFile;
2765 aname.CultureInfo = new CultureInfo ("nl-BE");
2766 aname.SetPublicKey (publicKey);
2767 AppDomain.CurrentDomain.Load (aname);
2768
2769 aname = new AssemblyName ();
2770 aname.Name = "bug79522C";
2771 aname.CodeBase = assemblyFile;
2772 aname.CultureInfo = new CultureInfo ("nl-BE");
2773 AppDomain.CurrentDomain.Load (aname);
2774
2775 // if culture and version are set, then the version must match
2776 aname = new AssemblyName ();
2777 aname.Name = "bug79522C";
2778 aname.CodeBase = assemblyFile;
2779 aname.CultureInfo = new CultureInfo ("nl-BE");
2780 aname.SetPublicKey (publicKey);
2781 aname.Version = new Version (5, 6);
2782 try {
2783 AppDomain.CurrentDomain.Load (aname);
2784 Assert.Fail ("#C8");
2785 } catch (FileLoadException) {
2786 }
2787
2788 // publickey must match
2789 aname = new AssemblyName ();
2790 aname.Name = "bug79522C";
2791 aname.CodeBase = assemblyFile;
2792 aname.CultureInfo = new CultureInfo ("nl-BE");
2793 aname.Version = new Version (2, 4);
2794 aname.SetPublicKey (publicKey2);
2795 try {
2796 AppDomain.CurrentDomain.Load (aname);
2797 Assert.Fail ("#C9");
2798 } catch (SecurityException) {
2799 // Invalid assembly public key
2800 }
2801
2802 aname = new AssemblyName ();
2803 aname.Name = "bug79522C";
2804 aname.CodeBase = assemblyFile;
2805 aname.SetPublicKey (publicKey);
2806 aname.CultureInfo = new CultureInfo ("nl-BE");
2807 aname.Version = new Version (2, 4);
2808 AppDomain.CurrentDomain.Load (aname);
2809 }
2810
2811 [Test] // bug #79715
2812 public void Load_PartialVersion ()
2813 {
2814 AppDomain ad = CreateTestDomain (tempDir, true);
2815 try {
2816 CrossDomainTester cdt = CreateCrossDomainTester (ad);
2817
2818 AssemblyName aname = new AssemblyName ();
2819 aname.Name = "bug79715";
2820 aname.Version = new Version (1, 2, 3, 4);
2821 cdt.GenerateAssembly (aname, Path.Combine (tempDir, "bug79715.dll"));
2822
2823 aname = new AssemblyName ();
2824 aname.Name = "bug79715";
2825 aname.Version = new Version (1, 2);
2826 Assert.IsTrue (cdt.AssertLoad (aname), "#A1");
2827 Assert.IsTrue (cdt.AssertLoad (aname.FullName), "#A2");
2828
2829 aname = new AssemblyName ();
2830 aname.Name = "bug79715";
2831 aname.Version = new Version (1, 2, 3);
2832 Assert.IsTrue (cdt.AssertLoad (aname), "#B1");
2833 Assert.IsTrue (cdt.AssertLoad (aname.FullName), "#B2");
2834
2835 aname = new AssemblyName ();
2836 aname.Name = "bug79715";
2837 aname.Version = new Version (1, 2, 3, 4);
2838 Assert.IsTrue (cdt.AssertLoad (aname), "#C1");
2839 Assert.IsTrue (cdt.AssertLoad (aname.FullName), "#C2");
2840 } finally {
2841 AppDomain.Unload (ad);
2842 }
2843 }
2844
2845 [Test]
2846 [ExpectedException (typeof (ArgumentException))]
2847 public void Load_EmptyString ()
2848 {
2849 AppDomain.CurrentDomain.Load ("");
2850 }
2851
2852 [Test]
2853 public void SetAppDomainPolicy ()
2854 {
2855 ad = AppDomain.CreateDomain ("SetAppDomainPolicy_Null");
2856 ad.SetAppDomainPolicy (PolicyLevel.CreateAppDomainLevel ());
2857 // not much to see
2858 }
2859
2860 [Test]
2861 [ExpectedException (typeof (ArgumentNullException))]
2862 public void SetAppDomainPolicy_Null ()
2863 {
2864 ad = AppDomain.CreateDomain ("SetAppDomainPolicy_Null");
2865 ad.SetAppDomainPolicy (null);
2866 }
2867
2868 [Test]
2869 [ExpectedException (typeof (PolicyException))]
2870 public void SetAppDomainPolicy_Dual ()
2871 {
2872 ad = AppDomain.CreateDomain ("SetAppDomainPolicy_Dual");
2873 PolicyLevel pl = PolicyLevel.CreateAppDomainLevel ();
2874 PermissionSet ps = new PermissionSet (PermissionState.Unrestricted);
2875 pl.RootCodeGroup.PolicyStatement = new PolicyStatement (ps);
2876 ad.SetAppDomainPolicy (pl);
2877
2878 // only one time!
2879 pl = PolicyLevel.CreateAppDomainLevel ();
2880 ps = new PermissionSet (PermissionState.None);
2881 pl.RootCodeGroup.PolicyStatement = new PolicyStatement (ps);
2882 ad.SetAppDomainPolicy (pl);
2883 }
2884
2885 [Test]
2886 [ExpectedException (typeof (AppDomainUnloadedException))]
2887 public void SetAppDomainPolicy_Unloaded ()
2888 {
2889 ad = AppDomain.CreateDomain ("SetAppDomainPolicy_Unloaded");
2890 AppDomain.Unload (ad);
2891 ad.SetAppDomainPolicy (PolicyLevel.CreateAppDomainLevel ());
2892 }
2893
2894 [Test]
2895 [ExpectedException (typeof (ArgumentNullException))]
2896 public void GetData_Null ()
2897 {
2898 AppDomain.CurrentDomain.GetData (null);
2899 }
2900
2901 [Test]
2902 public void SetData ()
2903 {
2904 AppDomain.CurrentDomain.SetData ("data", "data");
2905 Assert.AreEqual ("data", AppDomain.CurrentDomain.GetData ("data"), "GetData");
2906 AppDomain.CurrentDomain.SetData ("data", null);
2907 Assert.IsNull (AppDomain.CurrentDomain.GetData ("data"), "GetData-Null");
2908 }
2909
2910 [Test]
2911 [ExpectedException (typeof (ArgumentNullException))]
2912 public void SetData_Null ()
2913 {
2914 AppDomain.CurrentDomain.SetData (null, "data");
2915 }
2916
2917 [Test]
2918 public void ApplyPolicy ()
2919 {
2920 ad = AppDomain.CreateDomain ("ApplyPolicy");
2921 string fullname = Assembly.GetExecutingAssembly ().FullName;
2922 string result = ad.ApplyPolicy (fullname);
2923 Assert.AreEqual (fullname, result, "ApplyPolicy");
2924 // doesn't even requires an assembly name
2925 Assert.AreEqual ("123", ad.ApplyPolicy ("123"), "Invalid FullName");
2926 }
2927
2928 [Test]
2929 [ExpectedException (typeof (ArgumentException))]
2930 public void ApplyPolicy_Empty ()
2931 {
2932 ad = AppDomain.CreateDomain ("ApplyPolicy_Empty");
2933 ad.ApplyPolicy (String.Empty);
2934 }
2935
2936 [Test]
2937 [ExpectedException (typeof (ArgumentNullException))]
2938 public void ApplyPolicy_Null ()
2939 {
2940 ad = AppDomain.CreateDomain ("ApplyPolicy_Null");
2941 ad.ApplyPolicy (null);
2942 }
2943
2944 [Test]
2945 public void DomainManager ()
2946 {
2947 Assert.IsNull (AppDomain.CurrentDomain.DomainManager, "CurrentDomain.DomainManager");
2948 ad = AppDomain.CreateDomain ("DomainManager");
2949 Assert.IsNull (ad.DomainManager, "ad.DomainManager");
2950 }
2951
2952 [Test]
2953 public void IsDefaultAppDomain ()
2954 {
2955 ad = AppDomain.CreateDomain ("ReflectionOnlyGetAssemblies");
2956 Assert.IsFalse (ad.IsDefaultAppDomain (), "IsDefaultAppDomain");
2957 // we have no public way to get the default appdomain
2958 }
2959
2960 static bool resolve_called;
2961
2962 [Test]
2963 public void AssemblyResolveParseError ()
2964 {
2965 AppDomain currentDomain = AppDomain.CurrentDomain;
2966 ResolveEventHandler d = ParseErrorResolve;
2967 currentDomain.AssemblyResolve += d;
2968 try {
2969 resolve_called = false;
2970 var a = Assembly.Load ("MyDynamicType, 1.0.0.0, Culture=neutral, PublicKeyToken=0738eb9f132ed756");
2971 Assert.Fail ();
2972 } catch (FileNotFoundException) {
2973 Assert.IsTrue (resolve_called);
2974 }
2975 currentDomain.AssemblyResolve -= d;
2976 }
2977
2978 static Assembly ParseErrorResolve (object sender, ResolveEventArgs args)
2979 {
2980 resolve_called = true;
2981 return null;
2982 }
2983
2984 [Test]
2985 public void ReflectionOnlyGetAssemblies ()
2986 {
2987 ad = AppDomain.CreateDomain ("ReflectionOnlyGetAssemblies");
2988 Assembly [] a = ad.ReflectionOnlyGetAssemblies ();
2989 Assert.IsNotNull (a, "ReflectionOnlyGetAssemblies");
2990 Assert.AreEqual (0, a.Length, "Count");
2991
2992 string assemblyFile = Path.Combine (tempDir, "bug499013.dll");
2993 AssemblyName aname = new AssemblyName ();
2994 aname.Name = "bug499013";
2995 aname.Version = new Version (2, 4);
2996
2997 GenerateAssembly (aname, assemblyFile);
2998
2999 Assembly.ReflectionOnlyLoadFrom (assemblyFile);
3000 foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies ())
3001 Assert.IsTrue (assembly.GetName ().Name != "bug499013");
3002 }
3003
3004 [Test]
3005 public void ReflectionOnlyAssemblyResolve ()
3006 {
3007 AppDomain.CurrentDomain.ReflectionOnlyAssemblyResolve += new ResolveEventHandler(CurrentDomain_ReflectionOnlyAssemblyResolve);
3008 Assembly asm = Assembly.ReflectionOnlyLoad(Assembly.LoadWithPartialName("System").FullName);
3009 asm.GetTypes();
3010 }
3011
3012 [Test]
3013 public void ResourceResolve ()
3014 {
3015 bool called = false;
3016
3017 ResolveEventHandler del = delegate (object sender, ResolveEventArgs args) {
3018 called = true;
3019 return null;
3020 };
3021 AppDomain.CurrentDomain.ResourceResolve += del;
3022 Stream st = Assembly.GetExecutingAssembly ().GetManifestResourceStream ("NOT_EXISTING");
3023 Assert.IsTrue (called);
3024 AppDomain.CurrentDomain.ResourceResolve -= del;
3025 }
3026
3027 private static Assembly CurrentDomain_ReflectionOnlyAssemblyResolve(object sender, ResolveEventArgs args)
3028 {
3029 return Assembly.ReflectionOnlyLoad(args.Name);
3030 }
3031
3032
3033 public class StuffToPick
3034 {
3035 public StuffToPick () {}
3036 public void Method () {}
3037 public int Property { get; set; }
3038 public event Action Event;
3039 public int Field;
3040 public void GenericMethod<T> () {}
3041
3042 public void Dummy ()
3043 {
3044 Event += delegate {};
3045 }
3046 }
3047
3048 public class StuffToPick<T>
3049 {
3050 public StuffToPick () {}
3051 public void Method () {}
3052 public int Property { get; set; }
3053 public event Action Event;
3054 public int Field;
3055 public void GenericMethod<U> () {}
3056
3057 public void Dummy ()
3058 {
3059 Event += delegate {};
3060 }
3061 }
3062
3063 static void TestSerialization (CrossDomainTester tester, object o)
3064 {
3065 Assert.AreSame (o, tester.ReturnArg0 (o), "serializing_type_" + o.GetType ());
3066 }
3067
3068 [Test] //BXC #12611
3069 public void ReflectionObjectsAreSerializableTest ()
3070 {
3071 ad = CreateTestDomain (tempDir, true);
3072 CrossDomainTester tester = CreateCrossDomainTester (ad);
3073
3074 TestSerialization (tester, typeof (StuffToPick));
3075 TestSerialization (tester, typeof (StuffToPick).GetConstructor(new Type [0]));
3076 TestSerialization (tester, typeof (StuffToPick).GetMethod ("Method"));
3077 TestSerialization (tester, typeof (StuffToPick).GetProperty ("Property"));
3078 TestSerialization (tester, typeof (StuffToPick).GetEvent ("Event"));
3079 TestSerialization (tester, typeof (StuffToPick).GetField ("Field"));
3080 TestSerialization (tester, typeof (StuffToPick).GetMethod ("GenericMethod"));
3081
3082 TestSerialization (tester, typeof (StuffToPick<>));
3083 TestSerialization (tester, typeof (StuffToPick<>).GetConstructor(new Type [0]));
3084 TestSerialization (tester, typeof (StuffToPick<>).GetMethod ("Method"));
3085 TestSerialization (tester, typeof (StuffToPick<>).GetProperty ("Property"));
3086 TestSerialization (tester, typeof (StuffToPick<>).GetEvent ("Event"));
3087 TestSerialization (tester, typeof (StuffToPick<>).GetField ("Field"));
3088 TestSerialization (tester, typeof (StuffToPick<>).GetMethod ("GenericMethod"));
3089
3090 TestSerialization (tester, typeof (StuffToPick<int>));
3091 TestSerialization (tester, typeof (StuffToPick<int>).GetConstructor(new Type [0]));
3092 TestSerialization (tester, typeof (StuffToPick<int>).GetMethod ("Method"));
3093 TestSerialization (tester, typeof (StuffToPick<int>).GetProperty ("Property"));
3094 TestSerialization (tester, typeof (StuffToPick<int>).GetEvent ("Event"));
3095 TestSerialization (tester, typeof (StuffToPick<int>).GetField ("Field"));
3096 TestSerialization (tester, typeof (StuffToPick<int>).GetMethod ("GenericMethod"));
3097 }
3098
3099 [Test] //BXC #12611
3100 public void GenericReflectionObjectsAreSerializableTest ()
3101 {
3102 ad = CreateTestDomain (tempDir, true);
3103 CrossDomainTester tester = CreateCrossDomainTester (ad);
3104
3105 TestSerialization (tester, typeof (StuffToPick).GetMethod ("GenericMethod").MakeGenericMethod (typeof (int)));
3106 TestSerialization (tester, typeof (StuffToPick<>).GetMethod ("GenericMethod").MakeGenericMethod (typeof (int)));
3107 TestSerialization (tester, typeof (StuffToPick<int>).GetMethod ("GenericMethod").MakeGenericMethod (typeof (int)));
3108 }
3109
3110 [Test]
3111 public void ShadowCopyTypeGetTypeMissingAssemblyTest ()
3112 {
3113 ad = CreateShadowCopyAppDomain (tempDir, true);
3114 CrossDomainTester tester = CreateCrossDomainTester (ad);
3115 tester.AssertLoadMissingAssemblyType ();
3116 }
3117
3118 [Test]
3119 public void ShadowCopyDontChangeAssemblyCodeBase ()
3120 {
3121 var setup = new AppDomainSetup ();
3122 setup.ApplicationBase = tempDir;
3123 setup.ApplicationName = "testdomain";
3124 setup.ShadowCopyFiles = "true";
3125 var ad = CreateTestDomain (setup, true);
3126
3127 string assemblyFile = Path.Combine (tempDir, "TestAssembly.dll");
3128 AssemblyName aname = new AssemblyName ();
3129 aname.Name = "TestAssembly";
3130 GenerateAssembly (aname, assemblyFile);
3131
3132 var tester = CreateCrossDomainTester (ad);
3133 var codeBaseFromShadowCopy = tester.LoadAndGetName ("TestAssembly");
3134 var expected = Assembly.LoadFrom (Path.Combine (tempDir, "TestAssembly.dll"));
3135 Assert.AreEqual (expected.GetName ().CodeBase, codeBaseFromShadowCopy);
3136 }
3137
3138 private static AppDomain CreateTestDomain (string baseDirectory, bool assemblyResolver)
3139 {
3140 AppDomainSetup setup = new AppDomainSetup ();
3141 setup.ApplicationBase = baseDirectory;
3142 setup.ApplicationName = "testdomain";
3143 return CreateTestDomain (setup, assemblyResolver);
3144 }
3145
3146 private static AppDomain CreateShadowCopyAppDomain (string baseDirectory, bool assemblyResolver)
3147 {
3148 AppDomainSetup setup = new AppDomainSetup ();
3149 setup.ApplicationBase = baseDirectory;
3150 setup.ApplicationName = "testdomain";
3151 setup.ShadowCopyFiles = "true";
3152 return CreateTestDomain (setup, assemblyResolver);
3153 }
3154
3155 private static AppDomain CreateTestDomain (AppDomainSetup setup, bool assemblyResolver)
3156 {
3157 AppDomain ad = AppDomain.CreateDomain ("testdomain",
3158 AppDomain.CurrentDomain.Evidence, setup);
3159
3160 if (assemblyResolver) {
3161 Assembly ea = Assembly.GetExecutingAssembly ();
3162 ad.CreateInstanceFrom (ea.CodeBase,
3163 typeof (AssemblyResolveHandler).FullName,
3164 false,
3165 BindingFlags.Public | BindingFlags.Instance,
3166 null,
3167 new object [] { ea.Location, ea.FullName },
3168 CultureInfo.InvariantCulture,
3169 null,
3170 null);
3171 }
3172
3173 return ad;
3174 }
3175
3176
3177 private static CrossDomainTester CreateCrossDomainTester (AppDomain domain)
3178 {
3179 Type testerType = typeof (CrossDomainTester);
3180 return (CrossDomainTester) domain.CreateInstanceAndUnwrap (
3181 testerType.Assembly.FullName, testerType.FullName, false,
3182 BindingFlags.Public | BindingFlags.Instance, null, new object [0],
3183 CultureInfo.InvariantCulture, new object [0], null);
3184 }
3185
3186 private static void GenerateAssembly (AssemblyName aname, string path)
3187 {
3188 AppDomain ad = CreateTestDomain (AppDomain.CurrentDomain.BaseDirectory,
3189 false);
3190 try {
3191 CrossDomainTester cdt = CreateCrossDomainTester (ad);
3192 cdt.GenerateAssembly (aname, path);
3193 } finally {
3194 AppDomain.Unload (ad);
3195 }
3196 }
3197
3198 private bool RunningOnUnix {
3199 get {
3200 // check for Unix platforms - see FAQ for more details
3201 // http://www.mono-project.com/FAQ:_Technical#How_to_detect_the_execution_platform_.3F
3202 int platform = (int) Environment.OSVersion.Platform;
3203 return ((platform == 4) || (platform == 128) || (platform == 6));
3204 }
3205 }
3206
3207 private class CrossDomainTester : MarshalByRefObject
3208 {
3209 public void GenerateAssembly (AssemblyName aname, string path)
3210 {
3211 AssemblyBuilder ab = AppDomain.CurrentDomain.DefineDynamicAssembly (
3212 aname, AssemblyBuilderAccess.Save, Path.GetDirectoryName (path));
3213 ab.Save (Path.GetFileName (path));
3214 }
3215
3216 public int AssemblyCount {
3217 get {
3218 return AppDomain.CurrentDomain.GetAssemblies ().Length;
3219 }
3220 }
3221
3222 public string GetApplicationBase ()
3223 {
3224 return AppDomain.CurrentDomain.SetupInformation.ApplicationBase;
3225 }
3226
3227 public string GetConfigurationFile ()
3228 {
3229 return AppDomain.CurrentDomain.SetupInformation.ConfigurationFile;
3230 }
3231
3232 public void Load (AssemblyName assemblyRef)
3233 {
3234 AppDomain.CurrentDomain.Load (assemblyRef);
3235 }
3236
3237 public void LoadFrom (string assemblyFile)
3238 {
3239 Assembly.LoadFrom (assemblyFile);
3240 }
3241
3242 public bool AssertLoad (AssemblyName assemblyRef)
3243 {
3244 try {
3245 AppDomain.CurrentDomain.Load (assemblyRef);
3246 return true;
3247 } catch {
3248 return false;
3249 }
3250 }
3251
3252 public bool AssertLoad (string assemblyString)
3253 {
3254 try {
3255 AppDomain.CurrentDomain.Load (assemblyString);
3256 return true;
3257 } catch {
3258 return false;
3259 }
3260 }
3261
3262 public void AssertLoadMissingAssemblyType ()
3263 {
3264 Assert.IsNull (Type.GetType ("A.B.C, MissingAssembly"));
3265 }
3266
3267 public bool AssertFileLoadException (AssemblyName assemblyRef)
3268 {
3269 try {
3270 AppDomain.CurrentDomain.Load (assemblyRef);
3271 return false;
3272 } catch (FileLoadException) {
3273 return true;
3274 }
3275 }
3276
3277 public object ReturnArg0 (object obj)
3278 {
3279 return obj;
3280 }
3281
3282 public string LoadAndGetName (string assemblyName)
3283 {
3284 var assembly = Assembly.Load (assemblyName);
3285 return assembly.GetName ().CodeBase;
3286 }
3287 }
3288
3289 [Serializable ()]
3290 private class AssemblyResolveHandler
3291 {
3292 public AssemblyResolveHandler (string assemblyFile, string assemblyName)
3293 {
3294 _assemblyFile = assemblyFile;
3295 _assemblyName = assemblyName;
3296
3297 AppDomain.CurrentDomain.AssemblyResolve +=
3298 new ResolveEventHandler (ResolveAssembly);
3299 }
3300
3301 private Assembly ResolveAssembly (object sender, ResolveEventArgs args)
3302 {
3303 if (args.Name == _assemblyName)
3304 return Assembly.LoadFrom (_assemblyFile);
3305
3306 return null;
3307 }
3308
3309 private readonly string _assemblyFile;
3310 private readonly string _assemblyName;
3311 }
3312
3313 static byte [] keyPair = {
3314 0x07, 0x02, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x52, 0x53, 0x41,
3315 0x32, 0x00, 0x04, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x3D, 0xBD,
3316 0x72, 0x08, 0xC6, 0x2B, 0x0E, 0xA8, 0xC1, 0xC0, 0x58, 0x07, 0x2B,
3317 0x63, 0x5F, 0x7C, 0x9A, 0xBD, 0xCB, 0x22, 0xDB, 0x20, 0xB2, 0xA9,
3318 0xDA, 0xDA, 0xEF, 0xE8, 0x00, 0x64, 0x2F, 0x5D, 0x8D, 0xEB, 0x78,
3319 0x02, 0xF7, 0xA5, 0x36, 0x77, 0x28, 0xD7, 0x55, 0x8D, 0x14, 0x68,
3320 0xDB, 0xEB, 0x24, 0x09, 0xD0, 0x2B, 0x13, 0x1B, 0x92, 0x6E, 0x2E,
3321 0x59, 0x54, 0x4A, 0xAC, 0x18, 0xCF, 0xC9, 0x09, 0x02, 0x3F, 0x4F,
3322 0xA8, 0x3E, 0x94, 0x00, 0x1F, 0xC2, 0xF1, 0x1A, 0x27, 0x47, 0x7D,
3323 0x10, 0x84, 0xF5, 0x14, 0xB8, 0x61, 0x62, 0x1A, 0x0C, 0x66, 0xAB,
3324 0xD2, 0x4C, 0x4B, 0x9F, 0xC9, 0x0F, 0x3C, 0xD8, 0x92, 0x0F, 0xF5,
3325 0xFF, 0xCE, 0xD7, 0x6E, 0x5C, 0x6F, 0xB1, 0xF5, 0x7D, 0xD3, 0x56,
3326 0xF9, 0x67, 0x27, 0xA4, 0xA5, 0x48, 0x5B, 0x07, 0x93, 0x44, 0x00,
3327 0x4A, 0xF8, 0xFF, 0xA4, 0xCB, 0x73, 0xC0, 0x6A, 0x62, 0xB4, 0xB7,
3328 0xC8, 0x92, 0x58, 0x87, 0xCD, 0x07, 0x0C, 0x7D, 0x6C, 0xC1, 0x4A,
3329 0xFC, 0x82, 0x57, 0x0E, 0x43, 0x85, 0x09, 0x75, 0x98, 0x51, 0xBB,
3330 0x35, 0xF5, 0x64, 0x83, 0xC7, 0x79, 0x89, 0x5C, 0x55, 0x36, 0x66,
3331 0xAB, 0x27, 0xA4, 0xD9, 0xD4, 0x7E, 0x6B, 0x67, 0x64, 0xC1, 0x54,
3332 0x4E, 0x37, 0xF1, 0x4E, 0xCA, 0xB3, 0xE5, 0x63, 0x91, 0x57, 0x12,
3333 0x14, 0xA6, 0xEA, 0x8F, 0x8F, 0x2B, 0xFE, 0xF3, 0xE9, 0x16, 0x08,
3334 0x2B, 0x86, 0xBC, 0x26, 0x0D, 0xD0, 0xC6, 0xC4, 0x1A, 0x72, 0x43,
3335 0x76, 0xDC, 0xFF, 0x28, 0x52, 0xA1, 0xDE, 0x8D, 0xFA, 0xD5, 0x1F,
3336 0x0B, 0xB5, 0x4F, 0xAF, 0x06, 0x79, 0x11, 0xEE, 0xA8, 0xEC, 0xD3,
3337 0x74, 0x55, 0xA2, 0x80, 0xFC, 0xF8, 0xD9, 0x50, 0x69, 0x48, 0x01,
3338 0xC2, 0x5A, 0x04, 0x56, 0xB4, 0x3E, 0x24, 0x32, 0x20, 0xB5, 0x2C,
3339 0xDE, 0xBB, 0xBD, 0x13, 0xFD, 0x13, 0xF7, 0x03, 0x3E, 0xE3, 0x37,
3340 0x84, 0x74, 0xE7, 0xD0, 0x5E, 0x9E, 0xB6, 0x26, 0xAE, 0x6E, 0xB0,
3341 0x55, 0x6A, 0x52, 0x63, 0x6F, 0x5A, 0x9D, 0xF2, 0x67, 0xD6, 0x61,
3342 0x4F, 0x7A, 0x45, 0xEE, 0x5C, 0x3D, 0x2B, 0x7C, 0xB2, 0x40, 0x79,
3343 0x54, 0x84, 0xD1, 0xBE, 0x61, 0x3E, 0x5E, 0xD6, 0x18, 0x8E, 0x14,
3344 0x98, 0xFC, 0x35, 0xBF, 0x5F, 0x1A, 0x20, 0x2E, 0x1A, 0xD8, 0xFF,
3345 0xC4, 0x6B, 0xC0, 0xC9, 0x7D, 0x06, 0xEF, 0x09, 0xF9, 0xF3, 0x69,
3346 0xFC, 0xBC, 0xA2, 0xE6, 0x80, 0x22, 0xB9, 0x79, 0x7E, 0xEF, 0x57,
3347 0x9F, 0x49, 0xE1, 0xBC, 0x0D, 0xB6, 0xA1, 0xFE, 0x8D, 0xBC, 0xBB,
3348 0xA3, 0x05, 0x02, 0x6B, 0x04, 0x45, 0xF7, 0x5D, 0xEE, 0x43, 0x06,
3349 0xD6, 0x9C, 0x94, 0x48, 0x1A, 0x0B, 0x9C, 0xBC, 0xB4, 0x4E, 0x93,
3350 0x60, 0x87, 0xCD, 0x58, 0xD6, 0x9A, 0x39, 0xA6, 0xC0, 0x7F, 0x8E,
3351 0xFF, 0x25, 0xC1, 0xD7, 0x2C, 0xF6, 0xF4, 0x6F, 0x24, 0x52, 0x0B,
3352 0x39, 0x42, 0x1B, 0x0D, 0x04, 0xC1, 0x93, 0x2A, 0x19, 0x1C, 0xF0,
3353 0xB1, 0x9B, 0xC1, 0x24, 0x6D, 0x1B, 0x0B, 0xDA, 0x1C, 0x8B, 0x72,
3354 0x48, 0xF0, 0x3E, 0x52, 0xBF, 0x0A, 0x84, 0x3A, 0x9B, 0xC8, 0x6D,
3355 0x13, 0x1E, 0x72, 0xF4, 0x46, 0x93, 0x88, 0x1A, 0x5F, 0x4C, 0x3C,
3356 0xE5, 0x9D, 0x6E, 0xBB, 0x4E, 0xDD, 0x5D, 0x1F, 0x11, 0x40, 0xF4,
3357 0xD7, 0xAF, 0xB3, 0xAB, 0x9A, 0x99, 0x15, 0xF0, 0xDC, 0xAA, 0xFF,
3358 0x9F, 0x2D, 0x9E, 0x56, 0x4F, 0x35, 0x5B, 0xBA, 0x06, 0x99, 0xEA,
3359 0xC6, 0xB4, 0x48, 0x51, 0x17, 0x1E, 0xD1, 0x95, 0x84, 0x81, 0x18,
3360 0xC0, 0xF1, 0x71, 0xDE, 0x44, 0x42, 0x02, 0x06, 0xAC, 0x0E, 0xA8,
3361 0xE2, 0xF3, 0x1F, 0x96, 0x1F, 0xBE, 0xB6, 0x1F, 0xB5, 0x3E, 0xF6,
3362 0x81, 0x05, 0x20, 0xFA, 0x2E, 0x40, 0x2E, 0x4D, 0xA0, 0x0E, 0xDA,
3363 0x42, 0x9C, 0x05, 0xAA, 0x9E, 0xAF, 0x5C, 0xF7, 0x3A, 0x3F, 0xBB,
3364 0x91, 0x73, 0x45, 0x27, 0xA8, 0xA2, 0x07, 0x4A, 0xEF, 0x59, 0x1E,
3365 0x97, 0x9D, 0xE0, 0x30, 0x5A, 0x83, 0xCE, 0x1E, 0x57, 0x32, 0x89,
3366 0x43, 0x41, 0x28, 0x7D, 0x14, 0x8D, 0x8B, 0x41, 0x1A, 0x56, 0x76,
3367 0x43, 0xDB, 0x64, 0x86, 0x41, 0x64, 0x8D, 0x4C, 0x91, 0x83, 0x4E,
3368 0xF5, 0x6C };
3369
3370 static byte [] publicKey2 = {
3371 0x07, 0x02, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x52, 0x53, 0x41,
3372 0x32, 0x00, 0x04, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x7F, 0x7C,
3373 0xEA, 0x4A, 0x28, 0x33, 0xD8, 0x3C, 0x86, 0x90, 0x86, 0x91, 0x11,
3374 0xBB, 0x30, 0x0D, 0x3D, 0x69, 0x04, 0x4C, 0x48, 0xF5, 0x4F, 0xE7,
3375 0x64, 0xA5, 0x82, 0x72, 0x5A, 0x92, 0xC4, 0x3D, 0xC5, 0x90, 0x93,
3376 0x41, 0xC9, 0x1D, 0x34, 0x16, 0x72, 0x2B, 0x85, 0xC1, 0xF3, 0x99,
3377 0x62, 0x07, 0x32, 0x98, 0xB7, 0xE4, 0xFA, 0x75, 0x81, 0x8D, 0x08,
3378 0xB9, 0xFD, 0xDB, 0x00, 0x25, 0x30, 0xC4, 0x89, 0x13, 0xB6, 0x43,
3379 0xE8, 0xCC, 0xBE, 0x03, 0x2E, 0x1A, 0x6A, 0x4D, 0x36, 0xB1, 0xEB,
3380 0x49, 0x26, 0x6C, 0xAB, 0xC4, 0x29, 0xD7, 0x8F, 0x25, 0x11, 0xA4,
3381 0x7C, 0x81, 0x61, 0x97, 0xCB, 0x44, 0x2D, 0x80, 0x49, 0x93, 0x48,
3382 0xA7, 0xC9, 0xAB, 0xDB, 0xCF, 0xA3, 0x34, 0xCB, 0x6B, 0x86, 0xE0,
3383 0x4D, 0x27, 0xFC, 0xA7, 0x4F, 0x36, 0xCA, 0x13, 0x42, 0xD3, 0x83,
3384 0xC4, 0x06, 0x6E, 0x12, 0xE0, 0xA1, 0x3D, 0x9F, 0xA9, 0xEC, 0xD1,
3385 0xC6, 0x08, 0x1B, 0x3D, 0xF5, 0xDB, 0x4C, 0xD4, 0xF0, 0x2C, 0xAA,
3386 0xFC, 0xBA, 0x18, 0x6F, 0x48, 0x7E, 0xB9, 0x47, 0x68, 0x2E, 0xF6,
3387 0x1E, 0x67, 0x1C, 0x7E, 0x0A, 0xCE, 0x10, 0x07, 0xC0, 0x0C, 0xAD,
3388 0x5E, 0xC1, 0x53, 0x70, 0xD5, 0xE7, 0x25, 0xCA, 0x37, 0x5E, 0x49,
3389 0x59, 0xD0, 0x67, 0x2A, 0xBE, 0x92, 0x36, 0x86, 0x8A, 0xBF, 0x3E,
3390 0x17, 0x04, 0xFB, 0x1F, 0x46, 0xC8, 0x10, 0x5C, 0x93, 0x02, 0x43,
3391 0x14, 0x96, 0x6A, 0xD9, 0x87, 0x17, 0x62, 0x7D, 0x3A, 0x45, 0xBE,
3392 0x35, 0xDE, 0x75, 0x0B, 0x2A, 0xCE, 0x7D, 0xF3, 0x19, 0x85, 0x4B,
3393 0x0D, 0x6F, 0x8D, 0x15, 0xA3, 0x60, 0x61, 0x28, 0x55, 0x46, 0xCE,
3394 0x78, 0x31, 0x04, 0x18, 0x3C, 0x56, 0x4A, 0x3F, 0xA4, 0xC9, 0xB1,
3395 0x41, 0xED, 0x22, 0x80, 0xA1, 0xB3, 0xE2, 0xC7, 0x1B, 0x62, 0x85,
3396 0xE4, 0x81, 0x39, 0xCB, 0x1F, 0x95, 0xCC, 0x61, 0x61, 0xDF, 0xDE,
3397 0xF3, 0x05, 0x68, 0xB9, 0x7D, 0x4F, 0xFF, 0xF3, 0xC0, 0x0A, 0x25,
3398 0x62, 0xD9, 0x8A, 0x8A, 0x9E, 0x99, 0x0B, 0xFB, 0x85, 0x27, 0x8D,
3399 0xF6, 0xD4, 0xE1, 0xB9, 0xDE, 0xB4, 0x16, 0xBD, 0xDF, 0x6A, 0x25,
3400 0x9C, 0xAC, 0xCD, 0x91, 0xF7, 0xCB, 0xC1, 0x81, 0x22, 0x0D, 0xF4,
3401 0x7E, 0xEC, 0x0C, 0x84, 0x13, 0x5A, 0x74, 0x59, 0x3F, 0x3E, 0x61,
3402 0x00, 0xD6, 0xB5, 0x4A, 0xA1, 0x04, 0xB5, 0xA7, 0x1C, 0x29, 0xD0,
3403 0xE1, 0x11, 0x19, 0xD7, 0x80, 0x5C, 0xEE, 0x08, 0x15, 0xEB, 0xC9,
3404 0xA8, 0x98, 0xF5, 0xA0, 0xF0, 0x92, 0x2A, 0xB0, 0xD3, 0xC7, 0x8C,
3405 0x8D, 0xBB, 0x88, 0x96, 0x4F, 0x18, 0xF0, 0x8A, 0xF9, 0x31, 0x9E,
3406 0x44, 0x94, 0x75, 0x6F, 0x78, 0x04, 0x10, 0xEC, 0xF3, 0xB0, 0xCE,
3407 0xA0, 0xBE, 0x7B, 0x25, 0xE1, 0xF7, 0x8A, 0xA8, 0xD4, 0x63, 0xC2,
3408 0x65, 0x47, 0xCC, 0x5C, 0xED, 0x7D, 0x8B, 0x07, 0x4D, 0x76, 0x29,
3409 0x53, 0xAC, 0x27, 0x8F, 0x5D, 0x78, 0x56, 0xFA, 0x99, 0x45, 0xA2,
3410 0xCC, 0x65, 0xC4, 0x54, 0x13, 0x9F, 0x38, 0x41, 0x7A, 0x61, 0x0E,
3411 0x0D, 0x34, 0xBC, 0x11, 0xAF, 0xE2, 0xF1, 0x8B, 0xFA, 0x2B, 0x54,
3412 0x6C, 0xA3, 0x6C, 0x09, 0x1F, 0x0B, 0x43, 0x9B, 0x07, 0x95, 0x83,
3413 0x3F, 0x97, 0x99, 0x89, 0xF5, 0x51, 0x41, 0xF6, 0x8E, 0x5D, 0xEF,
3414 0x6D, 0x24, 0x71, 0x41, 0x7A, 0xAF, 0xBE, 0x81, 0x71, 0xAB, 0x76,
3415 0x2F, 0x1A, 0x5A, 0xBA, 0xF3, 0xA6, 0x65, 0x7A, 0x80, 0x50, 0xCE,
3416 0x23, 0xC3, 0xC7, 0x53, 0xB0, 0x7C, 0x97, 0x77, 0x27, 0x70, 0x98,
3417 0xAE, 0xB5, 0x24, 0x66, 0xE1, 0x60, 0x39, 0x41, 0xDA, 0x54, 0x01,
3418 0x64, 0xFB, 0x10, 0x33, 0xCE, 0x8B, 0xBE, 0x27, 0xD4, 0x21, 0x57,
3419 0xCC, 0x0F, 0x1A, 0xC1, 0x3D, 0xF3, 0xCC, 0x39, 0xF0, 0x2F, 0xAE,
3420 0xF1, 0xC0, 0xCD, 0x3B, 0x23, 0x87, 0x49, 0x7E, 0x40, 0x32, 0x6A,
3421 0xD3, 0x96, 0x4A, 0xE5, 0x5E, 0x6E, 0x26, 0xFD, 0x8A, 0xCF, 0x7E,
3422 0xFC, 0x37, 0xDE, 0x39, 0x0C, 0x53, 0x81, 0x75, 0x08, 0xAF, 0x6B,
3423 0x39, 0x6C, 0xFB, 0xC9, 0x79, 0xC0, 0x9B, 0x5F, 0x34, 0x86, 0xB2,
3424 0xDE, 0xC4, 0x19, 0x84, 0x5F, 0x0E, 0xED, 0x9B, 0xB8, 0xD3, 0x17,
3425 0xDA, 0x78 };
3426
3427 static byte [] publicKey = {
3428 0x00, 0x24, 0x00, 0x00, 0x04, 0x80, 0x00, 0x00, 0x94, 0x00, 0x00,
3429 0x00, 0x06, 0x02, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x52, 0x53,
3430 0x41, 0x31, 0x00, 0x04, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x3d,
3431 0xbd, 0x72, 0x08, 0xc6, 0x2b, 0x0e, 0xa8, 0xc1, 0xc0, 0x58, 0x07,
3432 0x2b, 0x63, 0x5f, 0x7c, 0x9a, 0xbd, 0xcb, 0x22, 0xdb, 0x20, 0xb2,
3433 0xa9, 0xda, 0xda, 0xef, 0xe8, 0x00, 0x64, 0x2f, 0x5d, 0x8d, 0xeb,
3434 0x78, 0x02, 0xf7, 0xa5, 0x36, 0x77, 0x28, 0xd7, 0x55, 0x8d, 0x14,
3435 0x68, 0xdb, 0xeb, 0x24, 0x09, 0xd0, 0x2b, 0x13, 0x1b, 0x92, 0x6e,
3436 0x2e, 0x59, 0x54, 0x4a, 0xac, 0x18, 0xcf, 0xc9, 0x09, 0x02, 0x3f,
3437 0x4f, 0xa8, 0x3e, 0x94, 0x00, 0x1f, 0xc2, 0xf1, 0x1a, 0x27, 0x47,
3438 0x7d, 0x10, 0x84, 0xf5, 0x14, 0xb8, 0x61, 0x62, 0x1a, 0x0c, 0x66,
3439 0xab, 0xd2, 0x4c, 0x4b, 0x9f, 0xc9, 0x0f, 0x3c, 0xd8, 0x92, 0x0f,
3440 0xf5, 0xff, 0xce, 0xd7, 0x6e, 0x5c, 0x6f, 0xb1, 0xf5, 0x7d, 0xd3,
3441 0x56, 0xf9, 0x67, 0x27, 0xa4, 0xa5, 0x48, 0x5b, 0x07, 0x93, 0x44,
3442 0x00, 0x4a, 0xf8, 0xff, 0xa4, 0xcb };
3443
3444 static byte [] pk_token = { 0xce, 0x52, 0x76, 0xd8, 0x68, 0x7e, 0Xc6, 0xdc };
3445 }
3446 }
3447
3448 #endif
Mirror of the official Mono project git repository