2 // Microsoft.CSharp.* Test Cases
5 // Eric Lebel (ericlebel@yahoo.ca)
6 // Gert Driesen (drieseng@users.sourceforge.net)
13 using System.CodeDom.Compiler;
14 using System.Globalization;
16 using Microsoft.CSharp;
18 using NUnit.Framework;
20 using MonoTests.System.CodeDom.Compiler;
22 namespace MonoTests.Microsoft.CSharp
25 public class CodeGeneratorFromTypeTest_Class : CodeGeneratorFromTypeTestBase
27 private CodeTypeDeclaration _typeDeclaration;
28 private ICodeGenerator _codeGenerator;
30 #region Override implementation of CodeGeneratorTestBase
32 protected override ICodeGenerator CodeGenerator
34 get { return _codeGenerator; }
38 public override void SetUp ()
41 _typeDeclaration = new CodeTypeDeclaration ();
43 CodeDomProvider provider = new CSharpCodeProvider ();
44 _codeGenerator = provider.CreateGenerator ();
47 #endregion Override implementation of CodeGeneratorTestBase
49 #region Override implementation of CodeGeneratorFromTypeTestBase
51 protected override CodeTypeDeclaration TypeDeclaration
53 get { return _typeDeclaration; }
57 public override void DefaultTypeTest ()
59 string code = GenerateDefaultType (Options);
60 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
61 "public class {{{0}" +
62 "}}{0}", NewLine), code);
66 public void DefaultTypeTest_C ()
68 CodeGeneratorOptions options = new CodeGeneratorOptions ();
69 options.BracingStyle = "C";
71 string code = GenerateDefaultType (options);
72 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
75 "}}{0}", NewLine), code);
79 [ExpectedException (typeof (NullReferenceException))]
80 public override void NullTypeTest ()
82 GenerateNullType (Options);
86 public override void SimpleTypeTest ()
88 string code = GenerateSimpleType (Options);
89 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
90 "public class Test1 {{{0}" +
91 "}}{0}", NewLine), code);
95 public void SimpleTypeTest_C ()
97 CodeGeneratorOptions options = new CodeGeneratorOptions ();
98 options.BracingStyle = "C";
100 string code = GenerateSimpleType (options);
101 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
102 "public class Test1{0}" +
104 "}}{0}", NewLine), code);
108 public override void DerivedTypeTest ()
110 string code = GenerateDerivedType (Options);
111 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
113 "internal abstract class Test1 : int, System.Security.Principal.IIdentity, string, System.Security.IPermission {{{0}" +
115 "abstract class Test1 : int, System.Security.Principal.IIdentity, string, System.Security.IPermission {{{0}" +
117 "}}{0}", NewLine), code);
121 public override void AttributesAndTypeTest ()
123 string code = GenerateAttributesAndType (Options);
124 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
127 "public class Test1 {{{0}" +
128 "}}{0}", NewLine), code);
132 public override void EventMembersTypeTest1 ()
134 string code = GenerateEventMembersType1 (Options);
135 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
136 "public class Test1 {{{0}" +
140 " private event void ;{0}" +
141 "}}{0}", NewLine), code);
145 public override void EventMembersTypeTest2 ()
147 string code = GenerateEventMembersType2 (Options);
148 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
149 "public class Test1 {{{0}" +
151 " public event int Click;{0}" +
152 "}}{0}", NewLine), code);
156 public override void EventImplementationTypes ()
158 string code = GenerateEventImplementationTypes (Options);
159 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
160 "public class Test1 {{{0}" +
163 " internal event int Click;{0}" +
165 " /*FamANDAssem*/ internal event int Click;{0}" +
167 "}}{0}", NewLine), code);
171 /// Ensure no access modifiers are output if PrivateImplementationType
175 public override void EventPrivateImplementationType ()
177 string code = GenerateEventPrivateImplementationType (Options);
178 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
179 "public class Test1 {{{0}" +
181 " event int System.Int32.Click;{0}" +
182 "}}{0}", NewLine), code);
186 /// If both ImplementationTypes and PrivateImplementationType are set,
187 /// then only ImplementationTypes are output.
190 public override void EventImplementationTypeOrder ()
192 string code = GenerateEventImplementationTypeOrder (Options);
193 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
194 "public class Test1 {{{0}" +
196 " event int System.Int32.Click;{0}" +
197 "}}{0}", NewLine), code);
201 public override void FieldMembersAttributesTest ()
203 string code = GenerateFieldMembersAttributes (Options);
204 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
205 "public class Test1 {{{0}" +
209 " private void ;{0}" +
210 "}}{0}", NewLine), code);
214 public override void FieldMembersTypeTest ()
216 string code = GenerateFieldMembersType (MemberAttributes.Public, Options);
217 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
218 "public class Test1 {{{0}" +
220 " public int Name = 2;{0}" +
221 "}}{0}", NewLine), code);
225 public override void FieldNewSlotTest ()
227 string code = GenerateFieldMembersType (MemberAttributes.Assembly |
228 MemberAttributes.New, Options);
229 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
230 "public class Test1 {{{0}" +
232 " internal new int Name = 2;{0}" +
233 "}}{0}", NewLine), code);
237 public override void PropertyMembersTypeTest1 ()
239 string code = GeneratePropertyMembersAttributes (Options);
240 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
241 "public class Test1 {{{0}" +
245 " private void {{{0}" +
247 "}}{0}", NewLine), code);
251 public void PropertyMembersTypeTest1_C ()
253 CodeGeneratorOptions options = new CodeGeneratorOptions ();
254 options.BracingStyle = "C";
256 string code = GeneratePropertyMembersAttributes (options);
257 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
258 "public class Test1{0}" +
263 " private void {0}" +
266 "}}{0}", NewLine), code);
270 public override void PropertyMembersTypeTest2 ()
272 string code = GeneratePropertyMembersType (MemberAttributes.Public,
273 false, false, Options);
274 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
275 "public class Test1 {{{0}" +
277 " public virtual int Name {{{0}" +
279 "}}{0}", NewLine), code);
283 public override void PropertyMembersTypeGetOnly ()
285 string code = GeneratePropertyMembersType (MemberAttributes.Family,
286 true, false, Options);
287 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
288 "public class Test1 {{{0}" +
290 " protected virtual int Name {{{0}" +
294 "}}{0}", NewLine), code);
298 public override void PropertyMembersTypeSetOnly ()
300 string code = GeneratePropertyMembersType (MemberAttributes.Assembly,
301 false, true, Options);
302 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
303 "public class Test1 {{{0}" +
306 " internal virtual int Name {{{0}" +
308 " internal int Name {{{0}" +
313 "}}{0}", NewLine), code);
317 public override void PropertyMembersTypeGetSet ()
319 string code = GeneratePropertyMembersType (MemberAttributes.Family,
320 true, true, Options);
321 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
322 "public class Test1 {{{0}" +
324 " protected virtual int Name {{{0}" +
330 "}}{0}", NewLine), code);
334 public void PropertyMembersTypeGetSet_C ()
336 CodeGeneratorOptions options = new CodeGeneratorOptions ();
337 options.BracingStyle = "C";
339 string code = GeneratePropertyMembersType (MemberAttributes.Family,
340 true, true, options);
341 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
342 "public class Test1{0}" +
345 " protected virtual int Name{0}" +
354 "}}{0}", NewLine), code);
358 public override void PropertyMembersTypeFamilyOrAssembly ()
360 string code = GeneratePropertyMembersType (MemberAttributes.FamilyOrAssembly,
361 false, false, Options);
362 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
363 "public class Test1 {{{0}" +
365 " protected internal int Name {{{0}" +
367 "}}{0}", NewLine), code);
371 public override void PropertyMembersTypeAssembly ()
373 string code = GeneratePropertyMembersType (MemberAttributes.Assembly,
374 false, false, Options);
375 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
376 "public class Test1 {{{0}" +
379 " internal virtual int Name {{{0}" +
381 " internal int Name {{{0}" +
384 "}}{0}", NewLine), code);
388 /// Apparently VB.NET CodeDOM also allows properties that aren't indexers
389 /// to have parameters.
392 public override void PropertyParametersTest ()
394 string code = GeneratePropertyParameters (Options);
395 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
396 "public class Test1 {{{0}" +
398 " public virtual int Name {{{0}" +
400 "}}{0}", NewLine), code);
404 public override void PropertyIndexerTest1 ()
406 string code = GeneratePropertyIndexer (MemberAttributes.Public,
407 false, false, true, Options);
408 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
409 "public class Test1 {{{0}" +
411 " public virtual int this[object value1, ref int value2] {{{0}" +
413 "}}{0}", NewLine), code);
417 public override void PropertyIndexerTest2 ()
419 string code = GeneratePropertyIndexer (MemberAttributes.Public,
420 false, false, false, Options);
421 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
422 "public class Test1 {{{0}" +
424 " public virtual int iTem {{{0}" +
426 "}}{0}", NewLine), code);
430 public override void PropertyIndexerGetOnly ()
432 string code = GeneratePropertyIndexer (MemberAttributes.Family,
433 true, false, true, Options);
434 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
435 "public class Test1 {{{0}" +
437 " protected virtual int this[object value1, ref int value2] {{{0}" +
441 "}}{0}", NewLine), code);
445 public override void PropertyIndexerSetOnly ()
447 string code = GeneratePropertyIndexer (MemberAttributes.Family,
448 false, true, true, Options);
449 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
450 "public class Test1 {{{0}" +
452 " protected virtual int this[object value1, ref int value2] {{{0}" +
456 "}}{0}", NewLine), code);
460 public override void PropertyImplementationTypes ()
462 string code = GeneratePropertyImplementationTypes (Options);
463 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
464 "public class Test1 {{{0}" +
466 " public virtual int Name {{{0}" +
468 "}}{0}", NewLine), code);
472 /// Ensure that Overloads keyword is output for a property which has
473 /// explicitly been marked as Overloaded.
476 public override void PropertyOverloadsTest1 ()
478 string code = GeneratePropertyOverloads1 (Options);
479 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
480 "public class Test1 {{{0}" +
482 " protected virtual int Name {{{0}" +
484 "}}{0}", NewLine), code);
488 /// Ensure that Overloads keyword is output if multiple properties with
489 /// the same name are defined.
492 public override void PropertyOverloadsTest2 ()
494 string code = GeneratePropertyOverloads2 (Options);
495 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
496 "public class Test1 {{{0}" +
498 " public virtual int Name {{{0}" +
501 " private int Name {{{0}" +
503 "}}{0}", NewLine), code);
507 /// Ensure that a property with a PrivateImplementationType and with
508 /// the same name does not qualify as an overload.
511 public override void PropertyOverloadsTest3 ()
513 string code = GeneratePropertyOverloads3 (Options);
514 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
515 "public class Test1 {{{0}" +
517 " public virtual int Name {{{0}" +
520 " int System.Int32.Name {{{0}" +
522 "}}{0}", NewLine), code);
526 /// Ensure no access modifiers are output if PrivateImplementationType
527 /// is set. Default keyword is also not output in this case.
530 public override void PropertyPrivateImplementationType ()
532 string code = GeneratePropertyPrivateImplementationType (Options);
533 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
534 "public class Test1 {{{0}" +
536 " int System.Int32.this[object value1] {{{0}" +
538 "}}{0}", NewLine), code);
542 /// If both ImplementationTypes and PrivateImplementationType are set,
543 /// then only ImplementationTypes are output.
546 public override void PropertyImplementationTypeOrder ()
548 string code = GeneratePropertyImplementationTypeOrder (Options);
549 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
550 "public class Test1 {{{0}" +
552 " int System.Int32.this[object value1] {{{0}" +
554 "}}{0}", NewLine), code);
558 public override void PropertyNewSlotTest ()
560 string code = GeneratePropertyMembersType (MemberAttributes.Private |
561 MemberAttributes.New, true, true, Options);
562 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
563 "public class Test1 {{{0}" +
565 " private new int Name {{{0}" +
571 "}}{0}", NewLine), code);
575 public override void MethodMembersTypeTest1 ()
577 string code = GenerateMethodMembersType1 (Options);
578 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
579 "public class Test1 {{{0}" +
583 " private void () {{{0}" +
585 "}}{0}", NewLine), code);
589 public void MethodMembersTypeTest1_C ()
591 CodeGeneratorOptions options = new CodeGeneratorOptions ();
592 options.BracingStyle = "C";
594 string code = GenerateMethodMembersType1 (options);
595 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
596 "public class Test1{0}" +
601 " private void (){0}" +
604 "}}{0}", NewLine), code);
608 public override void MethodMembersTypeTest2 ()
610 string code = GenerateMethodMembersType2 (Options);
611 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
612 "public class Test1 {{{0}" +
614 " public virtual int Something(object value1, object value2, out int index, ref int count) {{{0}" +
616 "}}{0}", NewLine), code);
620 public override void MethodMembersTypeTest3 ()
622 string code = GenerateMethodMembersType3 (Options);
623 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
624 "public class Test1 {{{0}" +
626 " public virtual int Something([A()] [B()] object value, [C(A1=false, A2=true)] [D()] out int ) {{{0}" +
628 "}}{0}", NewLine), code);
632 public override void MethodImplementationTypes ()
634 string code = GenerateMethodImplementationTypes (Options);
635 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
636 "public class Test1 {{{0}" +
639 " internal virtual int Execute() {{{0}" +
641 " internal int Execute() {{{0}" +
644 "}}{0}", NewLine), code);
648 public override void MethodOverloadsTest1 ()
650 string code = GenerateMethodOverloads1 (Options);
651 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
652 "public class Test1 {{{0}" +
655 " internal virtual int Execute() {{{0}" +
657 " internal int Execute() {{{0}" +
660 "}}{0}", NewLine), code);
664 public override void MethodOverloadsTest2 ()
666 string code = GenerateMethodOverloads2 (Options);
667 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
668 "public class Test1 {{{0}" +
670 " public virtual void Execute() {{{0}" +
673 " private int Execute(object value1) {{{0}" +
675 "}}{0}", NewLine), code);
679 /// Ensure that a method with a PrivateImplementationType and with
680 /// the same name does not qualify as an overload.
683 public override void MethodOverloadsTest3 ()
685 string code = GenerateMethodOverloads3 (Options);
686 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
687 "public class Test1 {{{0}" +
689 " public virtual void Execute() {{{0}" +
692 " int System.Int32.Execute(object value1) {{{0}" +
694 "}}{0}", NewLine), code);
698 /// Ensure no access modifiers are output if PrivateImplementationType
702 public override void MethodPrivateImplementationType ()
704 string code = GenerateMethodPrivateImplementationType (Options);
705 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
706 "public class Test1 {{{0}" +
708 " int System.Int32.Execute(object value1) {{{0}" +
710 "}}{0}", NewLine), code);
714 /// If both ImplementationTypes and PrivateImplementationType are set,
715 /// then only ImplementationTypes are output.
718 public override void MethodImplementationTypeOrder ()
720 string code = GenerateMethodImplementationTypeOrder (Options);
721 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
722 "public class Test1 {{{0}" +
724 " int System.Int32.Execute(object value1) {{{0}" +
726 "}}{0}", NewLine), code);
730 public override void MethodReturnTypeAttributes ()
732 string code = GenerateMethodReturnTypeAttributes (Options);
733 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
734 "public class Test1 {{{0}" +
738 " [return: C(A1=false, A2=true)]{0}" +
739 " [return: D()]{0}" +
740 " public virtual int Execute() {{{0}" +
742 "}}{0}", NewLine), code);
746 public override void MethodNewSlotTest ()
748 string code = GenerateMethodNewSlot (Options);
749 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
750 "public class Test1 {{{0}" +
752 " public new virtual int Execute() {{{0}" +
754 "}}{0}", NewLine), code);
758 public override void ConstructorAttributesTest ()
760 string code = GenerateConstructorAttributes (Options);
761 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
762 "public class Test1 {{{0}" +
766 " private Test1() {{{0}" +
768 "}}{0}", NewLine), code);
772 public void ConstructorAttributesTest_C ()
774 CodeGeneratorOptions options = new CodeGeneratorOptions ();
775 options.BracingStyle = "C";
777 string code = GenerateConstructorAttributes (options);
778 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
779 "public class Test1{0}" +
784 " private Test1(){0}" +
787 "}}{0}", NewLine), code);
791 public override void ConstructorParametersTest ()
793 string code = GenerateConstructorParameters (Options);
794 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
795 "public class Test1 {{{0}" +
797 " public Test1(object value1, object value2, out int index, ref int count) {{{0}" +
799 "}}{0}", NewLine), code);
803 public override void ConstructorParameterAttributesTest ()
805 string code = GenerateConstructorParameterAttributes (Options);
806 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
807 "public class Test1 {{{0}" +
809 " private Test1([A()] [B()] object value, [C(A1=false, A2=true)] [D()] out int index) {{{0}" +
811 "}}{0}", NewLine), code);
815 public override void BaseConstructorSingleArg ()
817 string code = GenerateBaseConstructor (false, Options);
818 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
819 "public class Test1 {{{0}" +
821 " protected Test1(object value1, out int value2) : {0}" +
822 " base(value1) {{{0}" +
824 "}}{0}", NewLine), code);
828 public override void BaseConstructorMultipleArgs ()
830 string code = GenerateBaseConstructor (true, Options);
831 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
832 "public class Test1 {{{0}" +
834 " protected Test1(object value1, out int value2) : {0}" +
835 " base(value1, value2) {{{0}" +
837 "}}{0}", NewLine), code);
841 public override void ChainedConstructorSingleArg ()
843 string code = GenerateChainedConstructor (false, Options);
844 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
845 "public class Test1 {{{0}" +
847 " public Test1(object value1, out int value2) : {0}" +
848 " base(value3) : {0}" +
849 " this(value1) {{{0}" +
851 "}}{0}", NewLine), code);
855 public override void ChainedConstructorMultipleArgs ()
857 string code = GenerateChainedConstructor (true, Options);
858 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
859 "public class Test1 {{{0}" +
861 " public Test1(object value1, out int value2) : {0}" +
862 " base(value3) : {0}" +
863 " this(value1, value2) {{{0}" +
865 "}}{0}", NewLine), code);
869 public override void TypeConstructorTest ()
871 string code = GenerateTypeConstructor (Options);
872 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
873 "public class Test1 {{{0}" +
879 " static Test1() {{{0}" +
881 "}}{0}", NewLine), code);
885 public void TypeConstructorTest_C ()
887 CodeGeneratorOptions options = new CodeGeneratorOptions ();
888 options.BracingStyle = "C";
890 string code = GenerateTypeConstructor (options);
891 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
892 "public class Test1{0}" +
899 " static Test1(){0}" +
902 "}}{0}", NewLine), code);
906 public override void EntryPointMethodTest ()
908 string code = GenerateEntryPointMethod (Options);
909 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
910 "public class Test1 {{{0}" +
914 " public static int Main() {{{0}" +
916 " public static void Main() {{{0}" +
918 " Test.InnerType x;{0}" +
920 "}}{0}", NewLine), code);
923 #endregion Override implementation of CodeGeneratorFromTypeTestBase
927 public class CodeGeneratorFromTypeTest_Delegate : CodeGeneratorFromTypeTestBase
929 private CodeTypeDeclaration _typeDeclaration;
930 private ICodeGenerator _codeGenerator;
932 #region Override implementation of CodeGeneratorTestBase
934 protected override ICodeGenerator CodeGenerator
936 get { return _codeGenerator; }
940 public override void SetUp ()
943 _typeDeclaration = new CodeTypeDelegate ();
945 CodeDomProvider provider = new CSharpCodeProvider ();
946 _codeGenerator = provider.CreateGenerator ();
949 #endregion Override implementation of CodeGeneratorTestBase
951 #region Override implementation of CodeGeneratorFromTypeTestBase
953 protected override CodeTypeDeclaration TypeDeclaration
955 get { return _typeDeclaration; }
959 public override void DefaultTypeTest ()
961 string code = GenerateDefaultType (Options);
962 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
963 "public delegate void ();{0}", NewLine), code);
967 [ExpectedException (typeof (NullReferenceException))]
968 public override void NullTypeTest ()
970 GenerateNullType (Options);
974 public override void SimpleTypeTest ()
976 string code = GenerateSimpleType (Options);
977 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
978 "public delegate void Test1();{0}", NewLine), code);
982 public override void DerivedTypeTest ()
984 string code = GenerateDerivedType (Options);
985 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
986 "delegate void Test1();{0}", NewLine), code);
990 public override void AttributesAndTypeTest ()
992 CodeTypeDelegate delegateDecl = new CodeTypeDelegate ();
993 delegateDecl.ReturnType = new CodeTypeReference (typeof (int));
995 _typeDeclaration = delegateDecl;
997 string code = GenerateAttributesAndType (Options);
998 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1001 "public delegate int Test1();{0}", NewLine), code);
1005 public override void EventMembersTypeTest1 ()
1007 string code = GenerateEventMembersType1 (Options);
1008 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1009 "public delegate void Test1();{0}{0}", NewLine), code);
1013 public override void EventMembersTypeTest2 ()
1015 string code = GenerateEventMembersType2 (Options);
1016 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1017 "public delegate void Test1();{0}{0}", NewLine), code);
1021 public override void EventImplementationTypes ()
1023 string code = GenerateEventImplementationTypes (Options);
1024 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1025 "public delegate void Test1();{0}{0}", NewLine), code);
1029 /// Ensure no access modifiers are output if PrivateImplementationType
1033 public override void EventPrivateImplementationType ()
1035 string code = GenerateEventPrivateImplementationType (Options);
1036 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1037 "public delegate void Test1();{0}{0}", NewLine), code);
1041 /// If both ImplementationTypes and PrivateImplementationType are set,
1042 /// then only ImplementationTypes are output.
1045 public override void EventImplementationTypeOrder ()
1047 string code = GenerateEventImplementationTypeOrder (Options);
1048 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1049 "public delegate void Test1();{0}{0}", NewLine), code);
1053 public override void FieldMembersAttributesTest ()
1055 string code = GenerateFieldMembersAttributes (Options);
1056 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1057 "public delegate void Test1();{0}{0}", NewLine), code);
1061 public override void FieldMembersTypeTest ()
1063 string code = GenerateFieldMembersType (MemberAttributes.Public, Options);
1064 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1065 "public delegate void Test1();{0}{0}", NewLine), code);
1069 public override void FieldNewSlotTest ()
1071 string code = GenerateFieldMembersType (MemberAttributes.Assembly |
1072 MemberAttributes.New, Options);
1073 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1074 "public delegate void Test1();{0}{0}", NewLine), code);
1078 public override void PropertyMembersTypeTest1 ()
1080 string code = GeneratePropertyMembersAttributes (Options);
1081 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1082 "public delegate void Test1();{0}{0}", NewLine), code);
1086 public override void PropertyMembersTypeTest2 ()
1088 string code = GeneratePropertyMembersType (MemberAttributes.Public,
1089 false, false, Options);
1090 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1091 "public delegate void Test1();{0}{0}", NewLine), code);
1095 public override void PropertyMembersTypeGetOnly ()
1097 string code = GeneratePropertyMembersType (MemberAttributes.Family,
1098 true, false, Options);
1099 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1100 "public delegate void Test1();{0}{0}", NewLine), code);
1104 public override void PropertyMembersTypeSetOnly ()
1106 string code = GeneratePropertyMembersType (MemberAttributes.Assembly,
1107 false, true, Options);
1108 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1109 "public delegate void Test1();{0}{0}", NewLine), code);
1113 public override void PropertyMembersTypeGetSet ()
1115 string code = GeneratePropertyMembersType (MemberAttributes.Family,
1116 true, true, Options);
1117 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1118 "public delegate void Test1();{0}{0}", NewLine), code);
1122 public override void PropertyMembersTypeFamilyOrAssembly ()
1124 string code = GeneratePropertyMembersType (MemberAttributes.FamilyOrAssembly,
1125 false, false, Options);
1126 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1127 "public delegate void Test1();{0}{0}", NewLine), code);
1131 public override void PropertyMembersTypeAssembly ()
1133 string code = GeneratePropertyMembersType (MemberAttributes.Assembly,
1134 false, false, Options);
1135 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1136 "public delegate void Test1();{0}{0}", NewLine), code);
1140 public override void PropertyParametersTest ()
1142 string code = GeneratePropertyParameters (Options);
1143 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1144 "public delegate void Test1();{0}{0}", NewLine), code);
1148 public override void PropertyIndexerTest1 ()
1150 string code = GeneratePropertyIndexer (MemberAttributes.Public,
1151 false, false, true, Options);
1152 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1153 "public delegate void Test1();{0}{0}", NewLine), code);
1157 public override void PropertyIndexerTest2 ()
1159 string code = GeneratePropertyIndexer (MemberAttributes.Public,
1160 false, false, false, Options);
1161 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1162 "public delegate void Test1();{0}{0}", NewLine), code);
1166 public override void PropertyIndexerGetOnly ()
1168 string code = GeneratePropertyIndexer (MemberAttributes.Family,
1169 true, false, true, Options);
1170 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1171 "public delegate void Test1();{0}{0}", NewLine), code);
1175 public override void PropertyIndexerSetOnly ()
1177 string code = GeneratePropertyIndexer (MemberAttributes.Family,
1178 false, true, true, Options);
1179 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1180 "public delegate void Test1();{0}{0}", NewLine), code);
1184 public override void PropertyImplementationTypes ()
1186 string code = GeneratePropertyImplementationTypes (Options);
1187 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1188 "public delegate void Test1();{0}{0}", NewLine), code);
1192 public override void PropertyOverloadsTest1 ()
1194 string code = GeneratePropertyOverloads1 (Options);
1195 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1196 "public delegate void Test1();{0}{0}", NewLine), code);
1200 public override void PropertyOverloadsTest2 ()
1202 string code = GeneratePropertyOverloads2 (Options);
1203 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1204 "public delegate void Test1();{0}{0}{0}", NewLine), code);
1208 public override void PropertyOverloadsTest3 ()
1210 string code = GeneratePropertyOverloads3 (Options);
1211 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1212 "public delegate void Test1();{0}{0}{0}", NewLine), code);
1216 public override void PropertyPrivateImplementationType ()
1218 string code = GeneratePropertyPrivateImplementationType (Options);
1219 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1220 "public delegate void Test1();{0}{0}", NewLine), code);
1224 public override void PropertyImplementationTypeOrder ()
1226 string code = GeneratePropertyImplementationTypeOrder (Options);
1227 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1228 "public delegate void Test1();{0}{0}", NewLine), code);
1232 public override void PropertyNewSlotTest ()
1234 string code = GeneratePropertyMembersType (MemberAttributes.Private |
1235 MemberAttributes.New, true, true, Options);
1236 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1237 "public delegate void Test1();{0}{0}", NewLine), code);
1241 public override void MethodMembersTypeTest1 ()
1243 string code = GenerateMethodMembersType1 (Options);
1244 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1245 "public delegate void Test1();{0}{0}", NewLine), code);
1249 public override void MethodMembersTypeTest2 ()
1251 string code = GenerateMethodMembersType2 (Options);
1252 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1253 "public delegate void Test1();{0}{0}", NewLine), code);
1257 public override void MethodMembersTypeTest3 ()
1259 string code = GenerateMethodMembersType3 (Options);
1260 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1261 "public delegate void Test1();{0}{0}", NewLine), code);
1265 public override void MethodImplementationTypes ()
1267 string code = GenerateMethodImplementationTypes (Options);
1268 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1269 "public delegate void Test1();{0}{0}", NewLine), code);
1273 public override void MethodOverloadsTest1 ()
1275 string code = GenerateMethodOverloads1 (Options);
1276 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1277 "public delegate void Test1();{0}{0}", NewLine), code);
1281 public override void MethodOverloadsTest2 ()
1283 string code = GenerateMethodOverloads2 (Options);
1284 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1285 "public delegate void Test1();{0}{0}{0}", NewLine), code);
1289 public override void MethodOverloadsTest3 ()
1291 string code = GenerateMethodOverloads3 (Options);
1292 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1293 "public delegate void Test1();{0}{0}{0}", NewLine), code);
1297 public override void MethodPrivateImplementationType ()
1299 string code = GenerateMethodPrivateImplementationType (Options);
1300 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1301 "public delegate void Test1();{0}{0}", NewLine), code);
1305 public override void MethodImplementationTypeOrder ()
1307 string code = GenerateMethodImplementationTypeOrder (Options);
1308 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1309 "public delegate void Test1();{0}{0}", NewLine), code);
1313 public override void MethodReturnTypeAttributes ()
1315 string code = GenerateMethodReturnTypeAttributes (Options);
1316 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1317 "public delegate void Test1();{0}{0}", NewLine), code);
1321 public override void MethodNewSlotTest ()
1323 string code = GenerateMethodNewSlot (Options);
1324 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1325 "public delegate void Test1();{0}{0}", NewLine), code);
1329 public override void ConstructorAttributesTest ()
1331 string code = GenerateConstructorAttributes (Options);
1332 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1333 "public delegate void Test1();{0}{0}", NewLine), code);
1337 public override void ConstructorParametersTest ()
1339 string code = GenerateConstructorParameters (Options);
1340 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1341 "public delegate void Test1();{0}{0}", NewLine), code);
1345 public override void ConstructorParameterAttributesTest ()
1347 string code = GenerateConstructorParameterAttributes (Options);
1348 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1349 "public delegate void Test1();{0}{0}", NewLine), code);
1353 public override void BaseConstructorSingleArg ()
1355 string code = GenerateBaseConstructor (false, Options);
1356 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1357 "public delegate void Test1();{0}{0}", NewLine), code);
1361 public override void BaseConstructorMultipleArgs ()
1363 string code = GenerateBaseConstructor (true, Options);
1364 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1365 "public delegate void Test1();{0}{0}", NewLine), code);
1369 public override void ChainedConstructorSingleArg ()
1371 string code = GenerateChainedConstructor (false, Options);
1372 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1373 "public delegate void Test1();{0}{0}", NewLine), code);
1377 public override void ChainedConstructorMultipleArgs ()
1379 string code = GenerateChainedConstructor (true, Options);
1380 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1381 "public delegate void Test1();{0}{0}", NewLine), code);
1385 public override void TypeConstructorTest ()
1387 string code = GenerateTypeConstructor (Options);
1388 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1389 "public delegate void Test1();{0}{0}", NewLine), code);
1393 public override void EntryPointMethodTest ()
1395 string code = GenerateEntryPointMethod (Options);
1396 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1397 "public delegate void Test1();{0}{0}" +
1400 "public static int Main() {{{0}" +
1402 "public static void Main() {{{0}" +
1404 " Test.InnerType x;{0}" +
1405 "}}{0}", NewLine), code);
1408 #endregion Override implementation of CodeGeneratorFromTypeTestBase
1412 public class CodeGeneratorFromTypeTest_Interface : CodeGeneratorFromTypeTestBase
1414 private CodeTypeDeclaration _typeDeclaration;
1415 private ICodeGenerator _codeGenerator;
1417 #region Override implementation of CodeGeneratorTestBase
1419 protected override ICodeGenerator CodeGenerator
1421 get { return _codeGenerator; }
1425 public override void SetUp ()
1428 _typeDeclaration = new CodeTypeDeclaration ();
1429 _typeDeclaration.IsInterface = true;
1431 CodeDomProvider provider = new CSharpCodeProvider ();
1432 _codeGenerator = provider.CreateGenerator ();
1435 #endregion Override implementation of CodeGeneratorTestBase
1437 #region Override implementation of CodeGeneratorFromTypeTestBase
1439 protected override CodeTypeDeclaration TypeDeclaration
1441 get { return _typeDeclaration; }
1445 public override void DefaultTypeTest ()
1447 string code = GenerateDefaultType (Options);
1448 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1449 "public interface {{{0}" +
1450 "}}{0}", NewLine), code);
1454 public void DefaultTypeTest_C ()
1456 CodeGeneratorOptions options = new CodeGeneratorOptions ();
1457 options.BracingStyle = "C";
1459 string code = GenerateDefaultType (options);
1460 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1461 "public interface {0}" +
1463 "}}{0}", NewLine), code);
1467 [ExpectedException (typeof (NullReferenceException))]
1468 public override void NullTypeTest ()
1470 GenerateNullType (Options);
1474 public override void SimpleTypeTest ()
1476 string code = GenerateSimpleType (Options);
1477 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1478 "public interface Test1 {{{0}" +
1479 "}}{0}", NewLine), code);
1483 public void SimpleTypeTest_C ()
1485 CodeGeneratorOptions options = new CodeGeneratorOptions ();
1486 options.BracingStyle = "C";
1488 string code = GenerateSimpleType (options);
1489 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1490 "public interface Test1{0}" +
1492 "}}{0}", NewLine), code);
1496 public override void DerivedTypeTest ()
1498 string code = GenerateDerivedType (Options);
1499 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1501 "internal interface Test1 : int, System.Security.Principal.IIdentity, string, System.Security.IPermission {{{0}" +
1503 "interface Test1 : int, System.Security.Principal.IIdentity, string, System.Security.IPermission {{{0}" +
1505 "}}{0}", NewLine), code);
1509 public override void AttributesAndTypeTest ()
1511 string code = GenerateAttributesAndType (Options);
1512 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1515 "public interface Test1 {{{0}" +
1516 "}}{0}", NewLine), code);
1520 public override void EventMembersTypeTest1 ()
1522 string code = GenerateEventMembersType1 (Options);
1523 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1524 "public interface Test1 {{{0}" +
1528 " private event void ;{0}" +
1529 "}}{0}", NewLine), code);
1533 public override void EventMembersTypeTest2 ()
1535 string code = GenerateEventMembersType2 (Options);
1536 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1537 "public interface Test1 {{{0}" +
1539 " public event int Click;{0}" +
1540 "}}{0}", NewLine), code);
1544 public override void EventImplementationTypes ()
1546 string code = GenerateEventImplementationTypes (Options);
1547 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1548 "public interface Test1 {{{0}" +
1551 " internal event int Click;{0}" +
1553 " /*FamANDAssem*/ internal event int Click;{0}" +
1555 "}}{0}", NewLine), code);
1559 public override void EventPrivateImplementationType ()
1561 string code = GenerateEventPrivateImplementationType (Options);
1562 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1563 "public interface Test1 {{{0}" +
1565 " event int System.Int32.Click;{0}" +
1566 "}}{0}", NewLine), code);
1570 public override void EventImplementationTypeOrder ()
1572 string code = GenerateEventImplementationTypeOrder (Options);
1573 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1574 "public interface Test1 {{{0}" +
1576 " event int System.Int32.Click;{0}" +
1577 "}}{0}", NewLine), code);
1581 public override void FieldMembersAttributesTest ()
1583 string code = GenerateFieldMembersAttributes (Options);
1584 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1585 "public interface Test1 {{{0}" +
1587 "}}{0}", NewLine), code);
1591 public override void FieldMembersTypeTest ()
1593 string code = GenerateFieldMembersType (MemberAttributes.Public, Options);
1594 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1595 "public interface Test1 {{{0}" +
1597 "}}{0}", NewLine), code);
1601 public override void FieldNewSlotTest ()
1603 string code = GenerateFieldMembersType (MemberAttributes.Assembly |
1604 MemberAttributes.New, Options);
1605 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1606 "public interface Test1 {{{0}" +
1608 "}}{0}", NewLine), code);
1612 public override void PropertyMembersTypeTest1 ()
1614 string code = GeneratePropertyMembersAttributes (Options);
1615 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1616 "public interface Test1 {{{0}" +
1622 "}}{0}", NewLine), code);
1626 public override void PropertyMembersTypeTest2 ()
1628 string code = GeneratePropertyMembersType (MemberAttributes.Public,
1629 false, false, Options);
1630 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1631 "public interface Test1 {{{0}" +
1635 "}}{0}", NewLine), code);
1639 public override void PropertyMembersTypeGetOnly ()
1641 string code = GeneratePropertyMembersType (MemberAttributes.Family,
1642 true, false, Options);
1643 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1644 "public interface Test1 {{{0}" +
1649 "}}{0}", NewLine), code);
1653 public override void PropertyMembersTypeSetOnly ()
1655 string code = GeneratePropertyMembersType (MemberAttributes.Assembly,
1656 false, true, Options);
1657 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1658 "public interface Test1 {{{0}" +
1663 "}}{0}", NewLine), code);
1667 public override void PropertyMembersTypeGetSet ()
1669 string code = GeneratePropertyMembersType (MemberAttributes.Family,
1670 true, true, Options);
1671 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1672 "public interface Test1 {{{0}" +
1678 "}}{0}", NewLine), code);
1682 public void PropertyMembersTypeGetSet_C ()
1684 CodeGeneratorOptions options = new CodeGeneratorOptions ();
1685 options.BracingStyle = "C";
1687 string code = GeneratePropertyMembersType (MemberAttributes.Family,
1688 true, true, options);
1689 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1690 "public interface Test1{0}" +
1698 "}}{0}", NewLine), code);
1702 public override void PropertyMembersTypeFamilyOrAssembly ()
1704 string code = GeneratePropertyMembersType (MemberAttributes.FamilyOrAssembly,
1705 false, false, Options);
1706 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1707 "public interface Test1 {{{0}" +
1711 "}}{0}", NewLine), code);
1715 public override void PropertyMembersTypeAssembly ()
1717 string code = GeneratePropertyMembersType (MemberAttributes.Assembly,
1718 false, false, Options);
1719 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1720 "public interface Test1 {{{0}" +
1724 "}}{0}", NewLine), code);
1728 public override void PropertyParametersTest ()
1730 string code = GeneratePropertyParameters (Options);
1731 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1732 "public interface Test1 {{{0}" +
1736 "}}{0}", NewLine), code);
1740 public override void PropertyIndexerTest1 ()
1742 string code = GeneratePropertyIndexer (MemberAttributes.Public,
1743 false, false, true, Options);
1744 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1745 "public interface Test1 {{{0}" +
1747 " int this[object value1, ref int value2] {{{0}" +
1749 "}}{0}", NewLine), code);
1753 public override void PropertyIndexerTest2 ()
1755 string code = GeneratePropertyIndexer (MemberAttributes.Public,
1756 false, false, false, Options);
1757 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1758 "public interface Test1 {{{0}" +
1762 "}}{0}", NewLine), code);
1766 public override void PropertyIndexerGetOnly ()
1768 string code = GeneratePropertyIndexer (MemberAttributes.Family,
1769 true, false, true, Options);
1770 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1771 "public interface Test1 {{{0}" +
1773 " int this[object value1, ref int value2] {{{0}" +
1776 "}}{0}", NewLine), code);
1780 public override void PropertyIndexerSetOnly ()
1782 string code = GeneratePropertyIndexer (MemberAttributes.Family,
1783 false, true, true, Options);
1784 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1785 "public interface Test1 {{{0}" +
1787 " int this[object value1, ref int value2] {{{0}" +
1790 "}}{0}", NewLine), code);
1794 public override void PropertyImplementationTypes ()
1796 string code = GeneratePropertyImplementationTypes (Options);
1797 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1798 "public interface Test1 {{{0}" +
1802 "}}{0}", NewLine), code);
1806 public override void PropertyOverloadsTest1 ()
1808 string code = GeneratePropertyOverloads1 (Options);
1809 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1810 "public interface Test1 {{{0}" +
1814 "}}{0}", NewLine), code);
1818 public override void PropertyOverloadsTest2 ()
1820 string code = GeneratePropertyOverloads2 (Options);
1821 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1822 "public interface Test1 {{{0}" +
1829 "}}{0}", NewLine), code);
1833 public override void PropertyOverloadsTest3 ()
1835 string code = GeneratePropertyOverloads3 (Options);
1836 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1837 "public interface Test1 {{{0}" +
1844 "}}{0}", NewLine), code);
1848 public override void PropertyPrivateImplementationType ()
1850 string code = GeneratePropertyPrivateImplementationType (Options);
1851 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1852 "public interface Test1 {{{0}" +
1854 " int this[object value1] {{{0}" +
1856 "}}{0}", NewLine), code);
1860 public override void PropertyImplementationTypeOrder ()
1862 string code = GeneratePropertyImplementationTypeOrder (Options);
1863 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1864 "public interface Test1 {{{0}" +
1866 " int this[object value1] {{{0}" +
1868 "}}{0}", NewLine), code);
1872 public override void PropertyNewSlotTest ()
1874 string code = GeneratePropertyMembersType (MemberAttributes.Private |
1875 MemberAttributes.New, true, true, Options);
1876 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1877 "public interface Test1 {{{0}" +
1879 " new int Name {{{0}" +
1883 "}}{0}", NewLine), code);
1887 public override void MethodMembersTypeTest1 ()
1889 string code = GenerateMethodMembersType1 (Options);
1890 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1891 "public interface Test1 {{{0}" +
1896 "}}{0}", NewLine), code);
1900 public void MethodMembersTypeTest1_C ()
1902 CodeGeneratorOptions options = new CodeGeneratorOptions ();
1903 options.BracingStyle = "C";
1905 string code = GenerateMethodMembersType1 (options);
1906 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1907 "public interface Test1{0}" +
1913 "}}{0}", NewLine), code);
1917 public override void MethodMembersTypeTest2 ()
1919 string code = GenerateMethodMembersType2 (Options);
1920 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1921 "public interface Test1 {{{0}" +
1923 " int Something(object value1, object value2, out int index, ref int count);{0}" +
1924 "}}{0}", NewLine), code);
1928 public override void MethodMembersTypeTest3 ()
1930 string code = GenerateMethodMembersType3 (Options);
1931 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1932 "public interface Test1 {{{0}" +
1934 " int Something([A()] [B()] object value, [C(A1=false, A2=true)] [D()] out int );{0}" +
1935 "}}{0}", NewLine), code);
1939 public override void MethodImplementationTypes ()
1941 string code = GenerateMethodImplementationTypes (Options);
1942 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1943 "public interface Test1 {{{0}" +
1945 " int Execute();{0}" +
1946 "}}{0}", NewLine), code);
1950 public override void MethodOverloadsTest1 ()
1952 string code = GenerateMethodOverloads1 (Options);
1953 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1954 "public interface Test1 {{{0}" +
1956 " int Execute();{0}" +
1957 "}}{0}", NewLine), code);
1961 public override void MethodOverloadsTest2 ()
1963 string code = GenerateMethodOverloads2 (Options);
1964 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1965 "public interface Test1 {{{0}" +
1967 " void Execute();{0}" +
1969 " int Execute(object value1);{0}" +
1970 "}}{0}", NewLine), code);
1974 public override void MethodOverloadsTest3 ()
1976 string code = GenerateMethodOverloads3 (Options);
1977 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1978 "public interface Test1 {{{0}" +
1980 " void Execute();{0}" +
1982 " int System.Int32.Execute(object value1);{0}" +
1983 "}}{0}", NewLine), code);
1987 public override void MethodPrivateImplementationType ()
1989 string code = GenerateMethodPrivateImplementationType (Options);
1990 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1991 "public interface Test1 {{{0}" +
1993 " int System.Int32.Execute(object value1);{0}" +
1994 "}}{0}", NewLine), code);
1998 public override void MethodImplementationTypeOrder ()
2000 string code = GenerateMethodImplementationTypeOrder (Options);
2001 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2002 "public interface Test1 {{{0}" +
2004 " int System.Int32.Execute(object value1);{0}" +
2005 "}}{0}", NewLine), code);
2009 public override void MethodReturnTypeAttributes ()
2011 string code = GenerateMethodReturnTypeAttributes (Options);
2012 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2013 "public interface Test1 {{{0}" +
2017 " [return: C(A1=false, A2=true)]{0}" +
2018 " [return: D()]{0}" +
2019 " int Execute();{0}" +
2020 "}}{0}", NewLine), code);
2024 public override void MethodNewSlotTest ()
2026 string code = GenerateMethodNewSlot (Options);
2027 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2028 "public interface Test1 {{{0}" +
2030 " new int Execute();{0}" +
2031 "}}{0}", NewLine), code);
2035 public override void ConstructorAttributesTest ()
2037 string code = GenerateConstructorAttributes (Options);
2038 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2039 "public interface Test1 {{{0}" +
2041 "}}{0}", NewLine), code);
2045 public void ConstructorAttributesTest_C ()
2047 CodeGeneratorOptions options = new CodeGeneratorOptions ();
2048 options.BracingStyle = "C";
2050 string code = GenerateConstructorAttributes (options);
2051 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2052 "public interface Test1{0}" +
2055 "}}{0}", NewLine), code);
2059 public override void ConstructorParametersTest ()
2061 string code = GenerateConstructorParameters (Options);
2062 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2063 "public interface Test1 {{{0}" +
2065 "}}{0}", NewLine), code);
2069 public override void ConstructorParameterAttributesTest ()
2071 string code = GenerateConstructorParameterAttributes (Options);
2072 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2073 "public interface Test1 {{{0}" +
2075 "}}{0}", NewLine), code, "#1");
2079 public override void BaseConstructorSingleArg ()
2081 string code = GenerateBaseConstructor (false, Options);
2082 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2083 "public interface Test1 {{{0}" +
2085 "}}{0}", NewLine), code);
2089 public override void BaseConstructorMultipleArgs ()
2091 string code = GenerateBaseConstructor (true, Options);
2092 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2093 "public interface Test1 {{{0}" +
2095 "}}{0}", NewLine), code);
2099 public override void ChainedConstructorSingleArg ()
2101 string code = GenerateChainedConstructor (false, Options);
2102 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2103 "public interface Test1 {{{0}" +
2105 "}}{0}", NewLine), code);
2109 public override void ChainedConstructorMultipleArgs ()
2111 string code = GenerateChainedConstructor (true, Options);
2112 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2113 "public interface Test1 {{{0}" +
2115 "}}{0}", NewLine), code);
2119 public override void TypeConstructorTest ()
2121 string code = GenerateTypeConstructor (Options);
2122 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2123 "public interface Test1 {{{0}" +
2125 "}}{0}", NewLine), code);
2129 public void TypeConstructorTest_C ()
2131 CodeGeneratorOptions options = new CodeGeneratorOptions ();
2132 options.BracingStyle = "C";
2134 string code = GenerateTypeConstructor (options);
2135 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2136 "public interface Test1{0}" +
2139 "}}{0}", NewLine), code);
2143 public override void EntryPointMethodTest ()
2145 string code = GenerateEntryPointMethod (Options);
2146 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2147 "public interface Test1 {{{0}" +
2151 " public static int Main() {{{0}" +
2153 " public static void Main() {{{0}" +
2155 " Test.InnerType x;{0}" +
2157 "}}{0}", NewLine), code);
2160 #endregion Override implementation of CodeGeneratorFromTypeTestBase
2164 public class CodeGeneratorFromTypeTest_Struct : CodeGeneratorFromTypeTestBase
2166 private CodeTypeDeclaration _typeDeclaration;
2167 private ICodeGenerator _codeGenerator;
2169 #region Override implementation of CodeGeneratorTestBase
2171 protected override ICodeGenerator CodeGenerator
2173 get { return _codeGenerator; }
2177 public override void SetUp ()
2180 _typeDeclaration = new CodeTypeDeclaration ();
2181 _typeDeclaration.IsStruct = true;
2183 CodeDomProvider provider = new CSharpCodeProvider ();
2184 _codeGenerator = provider.CreateGenerator ();
2187 #endregion Override implementation of CodeGeneratorTestBase
2189 #region Override implementation of CodeGeneratorFromTypeTestBase
2191 protected override CodeTypeDeclaration TypeDeclaration
2193 get { return _typeDeclaration; }
2197 public override void DefaultTypeTest ()
2199 string code = GenerateDefaultType (Options);
2200 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2201 "public struct {{{0}" +
2202 "}}{0}", NewLine), code);
2206 public void DefaultTypeTest_C ()
2208 CodeGeneratorOptions options = new CodeGeneratorOptions ();
2209 options.BracingStyle = "C";
2211 string code = GenerateDefaultType (options);
2212 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2213 "public struct {0}" +
2215 "}}{0}", NewLine), code);
2219 [ExpectedException (typeof (NullReferenceException))]
2220 public override void NullTypeTest ()
2222 GenerateNullType (Options);
2226 public override void SimpleTypeTest ()
2228 string code = GenerateSimpleType (Options);
2229 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2230 "public struct Test1 {{{0}" +
2231 "}}{0}", NewLine), code);
2235 public void SimpleTypeTest_C ()
2237 CodeGeneratorOptions options = new CodeGeneratorOptions ();
2238 options.BracingStyle = "C";
2240 string code = GenerateSimpleType (options);
2241 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2242 "public struct Test1{0}" +
2244 "}}{0}", NewLine), code);
2248 public override void DerivedTypeTest ()
2250 string code = GenerateDerivedType (Options);
2251 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2253 "internal struct Test1 : int, System.Security.Principal.IIdentity, string, System.Security.IPermission {{{0}" +
2255 "struct Test1 : int, System.Security.Principal.IIdentity, string, System.Security.IPermission {{{0}" +
2257 "}}{0}", NewLine), code);
2261 public override void AttributesAndTypeTest ()
2263 string code = GenerateAttributesAndType (Options);
2264 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2267 "public struct Test1 {{{0}" +
2268 "}}{0}", NewLine), code);
2272 public override void EventMembersTypeTest1 ()
2274 string code = GenerateEventMembersType1 (Options);
2275 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2276 "public struct Test1 {{{0}" +
2280 " private event void ;{0}" +
2281 "}}{0}", NewLine), code);
2285 public override void EventMembersTypeTest2 ()
2287 string code = GenerateEventMembersType2 (Options);
2288 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2289 "public struct Test1 {{{0}" +
2291 " public event int Click;{0}" +
2292 "}}{0}", NewLine), code);
2296 public override void EventImplementationTypes ()
2298 string code = GenerateEventImplementationTypes (Options);
2299 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2300 "public struct Test1 {{{0}" +
2303 " internal event int Click;{0}" +
2305 " /*FamANDAssem*/ internal event int Click;{0}" +
2307 "}}{0}", NewLine), code);
2311 public override void EventPrivateImplementationType ()
2313 string code = GenerateEventPrivateImplementationType (Options);
2314 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2315 "public struct Test1 {{{0}" +
2317 " event int System.Int32.Click;{0}" +
2318 "}}{0}", NewLine), code);
2322 public override void EventImplementationTypeOrder ()
2324 string code = GenerateEventImplementationTypeOrder (Options);
2325 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2326 "public struct Test1 {{{0}" +
2328 " event int System.Int32.Click;{0}" +
2329 "}}{0}", NewLine), code);
2333 public override void FieldMembersAttributesTest ()
2335 string code = GenerateFieldMembersAttributes (Options);
2336 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2337 "public struct Test1 {{{0}" +
2341 " private void ;{0}" +
2342 "}}{0}", NewLine), code);
2346 public override void FieldMembersTypeTest ()
2348 string code = GenerateFieldMembersType (MemberAttributes.Public, Options);
2349 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2350 "public struct Test1 {{{0}" +
2352 " public int Name = 2;{0}" +
2353 "}}{0}", NewLine), code);
2357 public override void FieldNewSlotTest ()
2359 string code = GenerateFieldMembersType (MemberAttributes.Assembly |
2360 MemberAttributes.New, Options);
2361 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2362 "public struct Test1 {{{0}" +
2364 " internal new int Name = 2;{0}" +
2365 "}}{0}", NewLine), code);
2369 public override void PropertyMembersTypeTest1 ()
2371 string code = GeneratePropertyMembersAttributes (Options);
2372 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2373 "public struct Test1 {{{0}" +
2377 " private void {{{0}" +
2379 "}}{0}", NewLine), code);
2383 public override void PropertyMembersTypeTest2 ()
2385 string code = GeneratePropertyMembersType (MemberAttributes.Public,
2386 false, false, Options);
2387 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2388 "public struct Test1 {{{0}" +
2390 " public virtual int Name {{{0}" +
2392 "}}{0}", NewLine), code);
2396 public override void PropertyMembersTypeGetOnly ()
2398 string code = GeneratePropertyMembersType (MemberAttributes.Family,
2399 true, false, Options);
2400 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2401 "public struct Test1 {{{0}" +
2403 " protected virtual int Name {{{0}" +
2407 "}}{0}", NewLine), code);
2411 public override void PropertyMembersTypeSetOnly ()
2413 string code = GeneratePropertyMembersType (MemberAttributes.Assembly,
2414 false, true, Options);
2415 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2416 "public struct Test1 {{{0}" +
2419 " internal virtual int Name {{{0}" +
2421 " internal int Name {{{0}" +
2426 "}}{0}", NewLine), code);
2430 public override void PropertyMembersTypeGetSet ()
2432 string code = GeneratePropertyMembersType (MemberAttributes.Family,
2433 true, true, Options);
2434 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2435 "public struct Test1 {{{0}" +
2437 " protected virtual int Name {{{0}" +
2443 "}}{0}", NewLine), code);
2447 public void PropertyMembersTypeGetSet_C ()
2449 CodeGeneratorOptions options = new CodeGeneratorOptions ();
2450 options.BracingStyle = "C";
2452 string code = GeneratePropertyMembersType (MemberAttributes.Family,
2453 true, true, options);
2454 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2455 "public struct Test1{0}" +
2458 " protected virtual int Name{0}" +
2467 "}}{0}", NewLine), code);
2471 public override void PropertyMembersTypeFamilyOrAssembly ()
2473 string code = GeneratePropertyMembersType (MemberAttributes.FamilyOrAssembly,
2474 false, false, Options);
2475 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2476 "public struct Test1 {{{0}" +
2478 " protected internal int Name {{{0}" +
2480 "}}{0}", NewLine), code);
2484 public override void PropertyMembersTypeAssembly ()
2486 string code = GeneratePropertyMembersType (MemberAttributes.Assembly,
2487 false, false, Options);
2488 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2489 "public struct Test1 {{{0}" +
2492 " internal virtual int Name {{{0}" +
2494 " internal int Name {{{0}" +
2497 "}}{0}", NewLine), code);
2501 public override void PropertyParametersTest ()
2503 string code = GeneratePropertyParameters (Options);
2504 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2505 "public struct Test1 {{{0}" +
2507 " public virtual int Name {{{0}" +
2509 "}}{0}", NewLine), code);
2513 public override void PropertyIndexerTest1 ()
2515 string code = GeneratePropertyIndexer (MemberAttributes.Public,
2516 false, false, true, Options);
2517 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2518 "public struct Test1 {{{0}" +
2520 " public virtual int this[object value1, ref int value2] {{{0}" +
2522 "}}{0}", NewLine), code);
2526 public override void PropertyIndexerTest2 ()
2528 string code = GeneratePropertyIndexer (MemberAttributes.Public,
2529 false, false, false, Options);
2530 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2531 "public struct Test1 {{{0}" +
2533 " public virtual int iTem {{{0}" +
2535 "}}{0}", NewLine), code);
2539 public override void PropertyIndexerGetOnly ()
2541 string code = GeneratePropertyIndexer (MemberAttributes.Family,
2542 true, false, true, Options);
2543 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2544 "public struct Test1 {{{0}" +
2546 " protected virtual int this[object value1, ref int value2] {{{0}" +
2550 "}}{0}", NewLine), code);
2554 public override void PropertyIndexerSetOnly ()
2556 string code = GeneratePropertyIndexer (MemberAttributes.Family,
2557 false, true, true, Options);
2558 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2559 "public struct Test1 {{{0}" +
2561 " protected virtual int this[object value1, ref int value2] {{{0}" +
2565 "}}{0}", NewLine), code);
2569 public override void PropertyImplementationTypes ()
2571 string code = GeneratePropertyImplementationTypes (Options);
2572 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2573 "public struct Test1 {{{0}" +
2575 " public virtual int Name {{{0}" +
2577 "}}{0}", NewLine), code);
2581 public override void PropertyOverloadsTest1 ()
2583 string code = GeneratePropertyOverloads1 (Options);
2584 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2585 "public struct Test1 {{{0}" +
2587 " protected virtual int Name {{{0}" +
2589 "}}{0}", NewLine), code);
2593 public override void PropertyOverloadsTest2 ()
2595 string code = GeneratePropertyOverloads2 (Options);
2596 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2597 "public struct Test1 {{{0}" +
2599 " public virtual int Name {{{0}" +
2602 " private int Name {{{0}" +
2604 "}}{0}", NewLine), code);
2608 public override void PropertyOverloadsTest3 ()
2610 string code = GeneratePropertyOverloads3 (Options);
2611 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2612 "public struct Test1 {{{0}" +
2614 " public virtual int Name {{{0}" +
2617 " int System.Int32.Name {{{0}" +
2619 "}}{0}", NewLine), code);
2623 public override void PropertyPrivateImplementationType ()
2625 string code = GeneratePropertyPrivateImplementationType (Options);
2626 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2627 "public struct Test1 {{{0}" +
2629 " int System.Int32.this[object value1] {{{0}" +
2631 "}}{0}", NewLine), code);
2635 public override void PropertyImplementationTypeOrder ()
2637 string code = GeneratePropertyImplementationTypeOrder (Options);
2638 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2639 "public struct Test1 {{{0}" +
2641 " int System.Int32.this[object value1] {{{0}" +
2643 "}}{0}", NewLine), code);
2647 public override void PropertyNewSlotTest ()
2649 string code = GeneratePropertyMembersType (MemberAttributes.Private |
2650 MemberAttributes.New, true, true, Options);
2651 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2652 "public struct Test1 {{{0}" +
2654 " private new int Name {{{0}" +
2660 "}}{0}", NewLine), code);
2664 public override void MethodMembersTypeTest1 ()
2666 string code = GenerateMethodMembersType1 (Options);
2667 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2668 "public struct Test1 {{{0}" +
2672 " private void () {{{0}" +
2674 "}}{0}", NewLine), code);
2678 public void MethodMembersTypeTest1_C ()
2680 CodeGeneratorOptions options = new CodeGeneratorOptions ();
2681 options.BracingStyle = "C";
2683 string code = GenerateMethodMembersType1 (options);
2684 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2685 "public struct Test1{0}" +
2690 " private void (){0}" +
2693 "}}{0}", NewLine), code);
2697 public override void MethodMembersTypeTest2 ()
2699 string code = GenerateMethodMembersType2 (Options);
2700 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2701 "public struct Test1 {{{0}" +
2703 " public virtual int Something(object value1, object value2, out int index, ref int count) {{{0}" +
2705 "}}{0}", NewLine), code);
2709 public override void MethodMembersTypeTest3 ()
2711 string code = GenerateMethodMembersType3 (Options);
2712 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2713 "public struct Test1 {{{0}" +
2715 " public virtual int Something([A()] [B()] object value, [C(A1=false, A2=true)] [D()] out int ) {{{0}" +
2717 "}}{0}", NewLine), code);
2721 public override void MethodImplementationTypes ()
2723 string code = GenerateMethodImplementationTypes (Options);
2724 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2725 "public struct Test1 {{{0}" +
2728 " internal virtual int Execute() {{{0}" +
2730 " internal int Execute() {{{0}" +
2733 "}}{0}", NewLine), code);
2737 public override void MethodOverloadsTest1 ()
2739 string code = GenerateMethodOverloads1 (Options);
2740 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2741 "public struct Test1 {{{0}" +
2744 " internal virtual int Execute() {{{0}" +
2746 " internal int Execute() {{{0}" +
2749 "}}{0}", NewLine), code);
2753 public override void MethodOverloadsTest2 ()
2755 string code = GenerateMethodOverloads2 (Options);
2756 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2757 "public struct Test1 {{{0}" +
2759 " public virtual void Execute() {{{0}" +
2762 " private int Execute(object value1) {{{0}" +
2764 "}}{0}", NewLine), code);
2768 public override void MethodOverloadsTest3 ()
2770 string code = GenerateMethodOverloads3 (Options);
2771 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2772 "public struct Test1 {{{0}" +
2774 " public virtual void Execute() {{{0}" +
2777 " int System.Int32.Execute(object value1) {{{0}" +
2779 "}}{0}", NewLine), code);
2783 public override void MethodPrivateImplementationType ()
2785 string code = GenerateMethodPrivateImplementationType (Options);
2786 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2787 "public struct Test1 {{{0}" +
2789 " int System.Int32.Execute(object value1) {{{0}" +
2791 "}}{0}", NewLine), code);
2795 public override void MethodImplementationTypeOrder ()
2797 string code = GenerateMethodImplementationTypeOrder (Options);
2798 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2799 "public struct Test1 {{{0}" +
2801 " int System.Int32.Execute(object value1) {{{0}" +
2803 "}}{0}", NewLine), code);
2807 public override void MethodReturnTypeAttributes ()
2809 string code = GenerateMethodReturnTypeAttributes (Options);
2810 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2811 "public struct Test1 {{{0}" +
2815 " [return: C(A1=false, A2=true)]{0}" +
2816 " [return: D()]{0}" +
2817 " public virtual int Execute() {{{0}" +
2819 "}}{0}", NewLine), code);
2823 public override void MethodNewSlotTest ()
2825 string code = GenerateMethodNewSlot (Options);
2826 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2827 "public struct Test1 {{{0}" +
2829 " public new virtual int Execute() {{{0}" +
2831 "}}{0}", NewLine), code);
2835 public override void ConstructorAttributesTest ()
2837 string code = GenerateConstructorAttributes (Options);
2838 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2839 "public struct Test1 {{{0}" +
2843 " private Test1() {{{0}" +
2845 "}}{0}", NewLine), code);
2849 public void ConstructorAttributesTest_C ()
2851 CodeGeneratorOptions options = new CodeGeneratorOptions ();
2852 options.BracingStyle = "C";
2854 string code = GenerateConstructorAttributes (options);
2855 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2856 "public struct Test1{0}" +
2861 " private Test1(){0}" +
2864 "}}{0}", NewLine), code);
2868 public override void ConstructorParametersTest ()
2870 string code = GenerateConstructorParameters (Options);
2871 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2872 "public struct Test1 {{{0}" +
2874 " public Test1(object value1, object value2, out int index, ref int count) {{{0}" +
2876 "}}{0}", NewLine), code);
2880 public override void ConstructorParameterAttributesTest ()
2882 string code = GenerateConstructorParameterAttributes (Options);
2883 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2884 "public struct Test1 {{{0}" +
2886 " private Test1([A()] [B()] object value, [C(A1=false, A2=true)] [D()] out int index) {{{0}" +
2888 "}}{0}", NewLine), code);
2892 public override void BaseConstructorSingleArg ()
2894 string code = GenerateBaseConstructor (false, Options);
2895 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2896 "public struct Test1 {{{0}" +
2898 " protected Test1(object value1, out int value2) : {0}" +
2899 " base(value1) {{{0}" +
2901 "}}{0}", NewLine), code);
2905 public override void BaseConstructorMultipleArgs ()
2907 string code = GenerateBaseConstructor (true, Options);
2908 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2909 "public struct Test1 {{{0}" +
2911 " protected Test1(object value1, out int value2) : {0}" +
2912 " base(value1, value2) {{{0}" +
2914 "}}{0}", NewLine), code);
2918 public override void ChainedConstructorSingleArg ()
2920 string code = GenerateChainedConstructor (false, Options);
2921 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2922 "public struct Test1 {{{0}" +
2924 " public Test1(object value1, out int value2) : {0}" +
2925 " base(value3) : {0}" +
2926 " this(value1) {{{0}" +
2928 "}}{0}", NewLine), code);
2932 public override void ChainedConstructorMultipleArgs ()
2934 string code = GenerateChainedConstructor (true, Options);
2935 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2936 "public struct Test1 {{{0}" +
2938 " public Test1(object value1, out int value2) : {0}" +
2939 " base(value3) : {0}" +
2940 " this(value1, value2) {{{0}" +
2942 "}}{0}", NewLine), code);
2946 public override void TypeConstructorTest ()
2948 string code = GenerateTypeConstructor (Options);
2949 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2950 "public struct Test1 {{{0}" +
2956 " static Test1() {{{0}" +
2958 "}}{0}", NewLine), code, "#1");
2962 public void TypeConstructorTest_C ()
2964 CodeGeneratorOptions options = new CodeGeneratorOptions ();
2965 options.BracingStyle = "C";
2967 string code = GenerateTypeConstructor (options);
2968 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2969 "public struct Test1{0}" +
2976 " static Test1(){0}" +
2979 "}}{0}", NewLine), code, "#2");
2983 public override void EntryPointMethodTest ()
2985 string code = GenerateEntryPointMethod (Options);
2986 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
2987 "public struct Test1 {{{0}" +
2991 " public static int Main() {{{0}" +
2993 " public static void Main() {{{0}" +
2995 " Test.InnerType x;{0}" +
2997 "}}{0}", NewLine), code);
3000 #endregion Override implementation of CodeGeneratorFromTypeTestBase
3004 public class CodeGeneratorFromTypeTest_Enum : CodeGeneratorFromTypeTestBase
3006 private CodeTypeDeclaration _typeDeclaration;
3007 private ICodeGenerator _codeGenerator;
3009 #region Override implementation of CodeGeneratorTestBase
3011 protected override ICodeGenerator CodeGenerator
3013 get { return _codeGenerator; }
3017 public override void SetUp ()
3020 _typeDeclaration = new CodeTypeDeclaration ();
3021 _typeDeclaration.IsEnum = true;
3023 CodeDomProvider provider = new CSharpCodeProvider ();
3024 _codeGenerator = provider.CreateGenerator ();
3027 #endregion Override implementation of CodeGeneratorTestBase
3029 #region Override implementation of CodeGeneratorFromTypeTestBase
3031 protected override CodeTypeDeclaration TypeDeclaration
3033 get { return _typeDeclaration; }
3037 public override void DefaultTypeTest ()
3039 string code = GenerateDefaultType (Options);
3040 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3041 "public enum {{{0}" +
3042 "}}{0}", NewLine), code);
3046 public void DefaultTypeTest_C ()
3048 CodeGeneratorOptions options = new CodeGeneratorOptions ();
3049 options.BracingStyle = "C";
3051 string code = GenerateDefaultType (options);
3052 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3055 "}}{0}", NewLine), code);
3059 [ExpectedException (typeof (NullReferenceException))]
3060 public override void NullTypeTest ()
3062 GenerateNullType (Options);
3066 public override void SimpleTypeTest ()
3068 string code = GenerateSimpleType (Options);
3069 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3070 "public enum Test1 {{{0}" +
3071 "}}{0}", NewLine), code);
3075 public void SimpleTypeTest_C ()
3077 CodeGeneratorOptions options = new CodeGeneratorOptions ();
3078 options.BracingStyle = "C";
3080 string code = GenerateSimpleType (options);
3081 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3082 "public enum Test1{0}" +
3084 "}}{0}", NewLine), code);
3088 public override void DerivedTypeTest ()
3090 string code = GenerateDerivedType (Options);
3091 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3093 "internal enum Test1 : int, System.Security.Principal.IIdentity, string, System.Security.IPermission {{{0}" +
3095 "enum Test1 : int, System.Security.Principal.IIdentity, string, System.Security.IPermission {{{0}" +
3097 "}}{0}", NewLine), code);
3101 public override void AttributesAndTypeTest ()
3103 string code = GenerateAttributesAndType (Options);
3104 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3107 "public enum Test1 {{{0}" +
3108 "}}{0}", NewLine), code);
3112 public override void EventMembersTypeTest1 ()
3114 string code = GenerateEventMembersType1 (Options);
3115 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3116 "public enum Test1 {{{0}" +
3118 "}}{0}", NewLine), code);
3122 public override void EventMembersTypeTest2 ()
3124 string code = GenerateEventMembersType2 (Options);
3125 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3126 "public enum Test1 {{{0}" +
3128 "}}{0}", NewLine), code);
3132 public override void EventImplementationTypes ()
3134 string code = GenerateEventImplementationTypes (Options);
3135 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3136 "public enum Test1 {{{0}" +
3138 "}}{0}", NewLine), code);
3142 public override void EventPrivateImplementationType ()
3144 string code = GenerateEventPrivateImplementationType (Options);
3145 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3146 "public enum Test1 {{{0}" +
3148 "}}{0}", NewLine), code);
3152 public override void EventImplementationTypeOrder ()
3154 string code = GenerateEventImplementationTypeOrder (Options);
3155 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3156 "public enum Test1 {{{0}" +
3158 "}}{0}", NewLine), code);
3162 public override void FieldMembersAttributesTest ()
3164 string code = GenerateFieldMembersAttributes (Options);
3165 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3166 "public enum Test1 {{{0}" +
3171 "}}{0}", NewLine), code);
3175 public override void FieldMembersTypeTest ()
3177 string code = GenerateFieldMembersType (MemberAttributes.Public, Options);
3178 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3179 "public enum Test1 {{{0}" +
3182 "}}{0}", NewLine), code);
3186 public override void FieldNewSlotTest ()
3188 string code = GenerateFieldMembersType (MemberAttributes.Assembly |
3189 MemberAttributes.New, Options);
3190 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3191 "public enum Test1 {{{0}" +
3194 "}}{0}", NewLine), code);
3198 public override void PropertyMembersTypeTest1 ()
3200 string code = GeneratePropertyMembersAttributes (Options);
3201 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3202 "public enum Test1 {{{0}" +
3204 "}}{0}", NewLine), code);
3208 public override void PropertyMembersTypeTest2 ()
3210 string code = GeneratePropertyMembersType (MemberAttributes.Public,
3211 false, false, Options);
3212 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3213 "public enum Test1 {{{0}" +
3215 "}}{0}", NewLine), code);
3219 public override void PropertyMembersTypeGetOnly ()
3221 string code = GeneratePropertyMembersType (MemberAttributes.Family,
3222 true, false, Options);
3223 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3224 "public enum Test1 {{{0}" +
3226 "}}{0}", NewLine), code);
3230 public override void PropertyMembersTypeSetOnly ()
3232 string code = GeneratePropertyMembersType (MemberAttributes.Assembly,
3233 false, true, Options);
3234 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3235 "public enum Test1 {{{0}" +
3237 "}}{0}", NewLine), code);
3241 public override void PropertyMembersTypeGetSet ()
3243 string code = GeneratePropertyMembersType (MemberAttributes.Family,
3244 true, true, Options);
3245 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3246 "public enum Test1 {{{0}" +
3248 "}}{0}", NewLine), code);
3252 public void PropertyMembersTypeGetSet_C ()
3254 CodeGeneratorOptions options = new CodeGeneratorOptions ();
3255 options.BracingStyle = "C";
3257 string code = GeneratePropertyMembersType (MemberAttributes.Family,
3258 true, true, options);
3259 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3260 "public enum Test1{0}" +
3263 "}}{0}", NewLine), code);
3267 public override void PropertyMembersTypeFamilyOrAssembly ()
3269 string code = GeneratePropertyMembersType (MemberAttributes.FamilyOrAssembly,
3270 false, false, Options);
3271 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3272 "public enum Test1 {{{0}" +
3274 "}}{0}", NewLine), code);
3278 public override void PropertyMembersTypeAssembly ()
3280 string code = GeneratePropertyMembersType (MemberAttributes.Assembly,
3281 false, false, Options);
3282 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3283 "public enum Test1 {{{0}" +
3285 "}}{0}", NewLine), code);
3289 public override void PropertyParametersTest ()
3291 string code = GeneratePropertyParameters (Options);
3292 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3293 "public enum Test1 {{{0}" +
3295 "}}{0}", NewLine), code);
3299 public override void PropertyIndexerTest1 ()
3301 string code = GeneratePropertyIndexer (MemberAttributes.Public,
3302 false, false, true, Options);
3303 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3304 "public enum Test1 {{{0}" +
3306 "}}{0}", NewLine), code);
3310 public override void PropertyIndexerTest2 ()
3312 string code = GeneratePropertyIndexer (MemberAttributes.Public,
3313 false, false, false, Options);
3314 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3315 "public enum Test1 {{{0}" +
3317 "}}{0}", NewLine), code);
3321 public override void PropertyIndexerGetOnly ()
3323 string code = GeneratePropertyIndexer (MemberAttributes.Family,
3324 true, false, true, Options);
3325 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3326 "public enum Test1 {{{0}" +
3328 "}}{0}", NewLine), code);
3332 public override void PropertyIndexerSetOnly ()
3334 string code = GeneratePropertyIndexer (MemberAttributes.Family,
3335 false, true, true, Options);
3336 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3337 "public enum Test1 {{{0}" +
3339 "}}{0}", NewLine), code);
3343 public override void PropertyImplementationTypes ()
3345 string code = GeneratePropertyImplementationTypes (Options);
3346 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3347 "public enum Test1 {{{0}" +
3349 "}}{0}", NewLine), code);
3353 public override void PropertyOverloadsTest1 ()
3355 string code = GeneratePropertyOverloads1 (Options);
3356 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3357 "public enum Test1 {{{0}" +
3359 "}}{0}", NewLine), code);
3363 public override void PropertyOverloadsTest2 ()
3365 string code = GeneratePropertyOverloads2 (Options);
3366 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3367 "public enum Test1 {{{0}" +
3370 "}}{0}", NewLine), code);
3374 public override void PropertyOverloadsTest3 ()
3376 string code = GeneratePropertyOverloads3 (Options);
3377 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3378 "public enum Test1 {{{0}" +
3381 "}}{0}", NewLine), code);
3385 public override void PropertyPrivateImplementationType ()
3387 string code = GeneratePropertyPrivateImplementationType (Options);
3388 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3389 "public enum Test1 {{{0}" +
3391 "}}{0}", NewLine), code);
3395 public override void PropertyImplementationTypeOrder ()
3397 string code = GeneratePropertyImplementationTypeOrder (Options);
3398 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3399 "public enum Test1 {{{0}" +
3401 "}}{0}", NewLine), code);
3405 public override void PropertyNewSlotTest ()
3407 string code = GeneratePropertyMembersType (MemberAttributes.Private |
3408 MemberAttributes.New, true, true, Options);
3409 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3410 "public enum Test1 {{{0}" +
3412 "}}{0}", NewLine), code);
3416 public override void MethodMembersTypeTest1 ()
3418 string code = GenerateMethodMembersType1 (Options);
3419 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3420 "public enum Test1 {{{0}" +
3422 "}}{0}", NewLine), code);
3426 public override void MethodMembersTypeTest2 ()
3428 string code = GenerateMethodMembersType2 (Options);
3429 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3430 "public enum Test1 {{{0}" +
3432 "}}{0}", NewLine), code);
3436 public override void MethodMembersTypeTest3 ()
3438 string code = GenerateMethodMembersType3 (Options);
3439 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3440 "public enum Test1 {{{0}" +
3442 "}}{0}", NewLine), code);
3446 public override void MethodImplementationTypes ()
3448 string code = GenerateMethodImplementationTypes (Options);
3449 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3450 "public enum Test1 {{{0}" +
3452 "}}{0}", NewLine), code);
3456 public override void MethodOverloadsTest1 ()
3458 string code = GenerateMethodOverloads1 (Options);
3459 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3460 "public enum Test1 {{{0}" +
3462 "}}{0}", NewLine), code);
3466 public override void MethodOverloadsTest2 ()
3468 string code = GenerateMethodOverloads2 (Options);
3469 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3470 "public enum Test1 {{{0}" +
3473 "}}{0}", NewLine), code);
3477 public override void MethodOverloadsTest3 ()
3479 string code = GenerateMethodOverloads3 (Options);
3480 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3481 "public enum Test1 {{{0}" +
3484 "}}{0}", NewLine), code);
3488 public override void MethodPrivateImplementationType ()
3490 string code = GenerateMethodPrivateImplementationType (Options);
3491 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3492 "public enum Test1 {{{0}" +
3494 "}}{0}", NewLine), code);
3498 public override void MethodImplementationTypeOrder ()
3500 string code = GenerateMethodImplementationTypeOrder (Options);
3501 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3502 "public enum Test1 {{{0}" +
3504 "}}{0}", NewLine), code);
3508 public override void MethodNewSlotTest ()
3510 string code = GenerateMethodNewSlot (Options);
3511 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3512 "public enum Test1 {{{0}" +
3514 "}}{0}", NewLine), code);
3518 public override void MethodReturnTypeAttributes ()
3520 string code = GenerateMethodReturnTypeAttributes (Options);
3521 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3522 "public enum Test1 {{{0}" +
3524 "}}{0}", NewLine), code);
3528 public override void ConstructorAttributesTest ()
3530 string code = GenerateConstructorAttributes (Options);
3531 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3532 "public enum Test1 {{{0}" +
3534 "}}{0}", NewLine), code);
3538 public void ConstructorAttributesTest_C ()
3540 CodeGeneratorOptions options = new CodeGeneratorOptions ();
3541 options.BracingStyle = "C";
3543 string code = GenerateConstructorAttributes (options);
3544 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3545 "public enum Test1{0}" +
3548 "}}{0}", NewLine), code);
3552 public override void ConstructorParametersTest ()
3554 string code = GenerateConstructorParameters (Options);
3555 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3556 "public enum Test1 {{{0}" +
3558 "}}{0}", NewLine), code);
3562 public override void ConstructorParameterAttributesTest ()
3564 string code = GenerateConstructorParameterAttributes (Options);
3565 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3566 "public enum Test1 {{{0}" +
3568 "}}{0}", NewLine), code);
3572 public override void BaseConstructorSingleArg ()
3574 string code = GenerateBaseConstructor (false, Options);
3575 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3576 "public enum Test1 {{{0}" +
3578 "}}{0}", NewLine), code);
3582 public override void BaseConstructorMultipleArgs ()
3584 string code = GenerateBaseConstructor (true, Options);
3585 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3586 "public enum Test1 {{{0}" +
3588 "}}{0}", NewLine), code);
3592 public override void ChainedConstructorSingleArg ()
3594 string code = GenerateChainedConstructor (false, Options);
3595 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3596 "public enum Test1 {{{0}" +
3598 "}}{0}", NewLine), code);
3602 public override void ChainedConstructorMultipleArgs ()
3604 string code = GenerateChainedConstructor (true, Options);
3605 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3606 "public enum Test1 {{{0}" +
3608 "}}{0}", NewLine), code);
3612 public override void TypeConstructorTest ()
3614 string code = GenerateTypeConstructor (Options);
3615 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3616 "public enum Test1 {{{0}" +
3618 "}}{0}", NewLine), code);
3622 public void TypeConstructorTest_C ()
3624 CodeGeneratorOptions options = new CodeGeneratorOptions ();
3625 options.BracingStyle = "C";
3627 string code = GenerateTypeConstructor (options);
3628 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3629 "public enum Test1{0}" +
3632 "}}{0}", NewLine), code);
3636 public override void EntryPointMethodTest ()
3638 string code = GenerateEntryPointMethod (Options);
3639 Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
3640 "public enum Test1 {{{0}" +
3644 " public static int Main() {{{0}" +
3646 " public static void Main() {{{0}" +
3648 " Test.InnerType x;{0}" +
3650 "}}{0}", NewLine), code);
3653 #endregion Override implementation of CodeGeneratorFromTypeTestBase