mcs/class/System/Test/Microsoft.VisualBasic/CodeGeneratorFromExpressionTest.cs

   1 //
   2 // Microsoft.VisualBasic.* Test Cases
   3 //
   4 // Authors:
   5 //      Gert Driesen (drieseng@users.sourceforge.net)
   6 //
   7 // (c) 2005 Novell
   8 //
   9 using System;
  10 using System.IO;
  11 using System.Text;
  12 using System.CodeDom;
  13 using System.CodeDom.Compiler;
  14
  15 using Microsoft.VisualBasic;
  16
  17 using NUnit.Framework;
  18
  19 namespace MonoTests.Microsoft.VisualBasic
  20 {
  21         [TestFixture]
  22         public class CodeGeneratorFromExpressionTest
  23         {
  24                 VBCodeProvider provider;
  25                 ICodeGenerator generator;
  26                 CodeGeneratorOptions options;
  27
  28                 [SetUp]
  29                 public void SetUp ()
  30                 {
  31                         provider = new VBCodeProvider ();
  32                         generator = provider.CreateGenerator ();
  33                         options = new CodeGeneratorOptions ();
  34                 }
  35
  36                 [Test]
  37                 [ExpectedException (typeof (ArgumentException))]
  38                 public void DefaultExpressionTest ()
  39                 {
  40                         using (StringWriter sw = new StringWriter ()) {
  41                                 Generate(new CodeExpression (), sw);
  42                                 sw.Close ();
  43                         }
  44                 }
  45
  46                 [Test]
  47                 [ExpectedException (typeof (ArgumentNullException))]
  48                 public void NullExpressionTest ()
  49                 {
  50                         using (StringWriter sw = new StringWriter ()) {
  51                                 Generate (null, sw);
  52                         }
  53                 }
  54
  55                 [Test]
  56                 public void TypeReferenceExpressionTest ()
  57                 {
  58                         StringBuilder sb = new StringBuilder();
  59
  60                         using (StringWriter sw = new StringWriter (sb)) {
  61                                 Assert.AreEqual ("Boolean", Generate (new CodeTypeReferenceExpression (typeof (bool)), sw), "#1");
  62                                 sb.Length = 0;
  63                                 Assert.AreEqual ("Byte", Generate (new CodeTypeReferenceExpression (typeof (byte)), sw), "#2");
  64                                 sb.Length = 0;
  65                                 Assert.AreEqual ("Char", Generate (new CodeTypeReferenceExpression (typeof (char)), sw), "#3");
  66                                 sb.Length = 0;
  67                                 Assert.AreEqual ("Date", Generate (new CodeTypeReferenceExpression (typeof (DateTime)), sw), "#4");
  68                                 sb.Length = 0;
  69                                 Assert.AreEqual ("Decimal", Generate (new CodeTypeReferenceExpression (typeof (decimal)), sw), "#5");
  70                                 sb.Length = 0;
  71                                 Assert.AreEqual ("Double", Generate (new CodeTypeReferenceExpression (typeof (double)), sw), "#6");
  72                                 sb.Length = 0;
  73                                 Assert.AreEqual ("Short", Generate (new CodeTypeReferenceExpression (typeof (short)), sw), "#7");
  74                                 sb.Length = 0;
  75                                 Assert.AreEqual ("Integer", Generate (new CodeTypeReferenceExpression (typeof (int)), sw), "#8");
  76                                 sb.Length = 0;
  77                                 Assert.AreEqual ("Long", Generate (new CodeTypeReferenceExpression (typeof (long)), sw), "#9");
  78                                 sb.Length = 0;
  79                                 Assert.AreEqual ("Single", Generate (new CodeTypeReferenceExpression (typeof (float)), sw), "#10");
  80                                 sb.Length = 0;
  81                                 Assert.AreEqual ("Object", Generate (new CodeTypeReferenceExpression (typeof (object)), sw), "#11");
  82                                 sb.Length = 0;
  83                                 Assert.AreEqual (typeof (void).FullName, Generate (new CodeTypeReferenceExpression (typeof (void)), sw), "#12");
  84                                 sb.Length = 0;
  85                                 Assert.AreEqual (typeof (void).FullName, Generate (new CodeTypeReferenceExpression ((string) null), sw), "#13");
  86                                 sb.Length = 0;
  87                                 Assert.AreEqual (typeof (void).FullName, Generate (new CodeTypeReferenceExpression (""), sw), "#14");
  88                                 sb.Length = 0;
  89                                 Assert.AreEqual ("SByte", Generate (new CodeTypeReferenceExpression (typeof (sbyte)), sw), "#15");
  90                                 sb.Length = 0;
  91                                 Assert.AreEqual ("UShort", Generate (new CodeTypeReferenceExpression (typeof (ushort)), sw), "#16");
  92                                 sb.Length = 0;
  93                                 Assert.AreEqual ("UInteger", Generate (new CodeTypeReferenceExpression (typeof (uint)), sw), "#17");
  94                                 sb.Length = 0;
  95                                 Assert.AreEqual ("ULong", Generate (new CodeTypeReferenceExpression (typeof (ulong)), sw), "#18");
  96                                 sb.Length = 0;
  97                                 sw.Close ();
  98                         }
  99                 }
 100
 101                 [Test]
 102                 public void PrimitiveExpressionTest ()
 103                 {
 104                         StringBuilder sb = new StringBuilder ();
 105
 106                         using (StringWriter sw = new StringWriter (sb)) {
 107                                 Assert.AreEqual ("Nothing", Generate (new CodePrimitiveExpression (null), sw), "#1");
 108                                 sb.Length = 0;
 109                                 Assert.AreEqual ("\"AB\"\"C\"", Generate (new CodePrimitiveExpression ("AB\"C"), sw), "#2");
 110                                 sb.Length = 0;
 111                                 Assert.AreEqual ("5", Generate (new CodePrimitiveExpression ((byte) 5), sw), "#4");
 112                                 sb.Length = 0;
 113                                 Assert.AreEqual ("20", Generate (new CodePrimitiveExpression ((short) 20), sw), "#5");
 114                                 sb.Length = 0;
 115                                 Assert.AreEqual ("243", Generate (new CodePrimitiveExpression (243), sw), "#6");
 116                                 sb.Length = 0;
 117                                 Assert.AreEqual ("434343", Generate (new CodePrimitiveExpression ((long) 434343), sw), "#7");
 118                                 sb.Length = 0;
 119                                 Assert.AreEqual ("6.445!", Generate (new CodePrimitiveExpression ((float) 6.445), sw), "#8");
 120                                 sb.Length = 0;
 121                                 Assert.AreEqual ("5.76", Generate (new CodePrimitiveExpression ((double) 5.76), sw), "#9");
 122                                 sb.Length = 0;
 123                                 Assert.AreEqual ("7.667", Generate (new CodePrimitiveExpression ((decimal) 7.667), sw), "#10");
 124                                 sb.Length = 0;
 125                                 Assert.AreEqual ("true", Generate (new CodePrimitiveExpression (true), sw), "#11");
 126                                 sb.Length = 0;
 127                                 Assert.AreEqual ("false", Generate (new CodePrimitiveExpression (false), sw), "#12");
 128                                 sw.Close ();
 129                         }
 130                 }
 131
 132                 [Test]
 133                 public void ArrayIndexerExpressionTest ()
 134                 {
 135                         StringBuilder sb = new StringBuilder ();
 136                         using (StringWriter sw = new StringWriter (sb)) {
 137                                 Assert.AreEqual ("x(5)", Generate (new CodeArrayIndexerExpression(new CodeVariableReferenceExpression("x"), new CodePrimitiveExpression(5)), sw), "#1");
 138                                 sb.Length = 0;
 139                         }
 140                 }
 141
 142                 [Test]
 143                 public void PrimitiveExpressionTest_Char ()
 144                 {
 145                         string vbNs = "Global.Microsoft.VisualBasic";
 146                         StringBuilder sb = new StringBuilder ();
 147
 148                         using (StringWriter sw = new StringWriter (sb)) {
 149                                 Assert.AreEqual (vbNs + ".ChrW(0)", Generate (new CodePrimitiveExpression ('\0'), sw), "#0");
 150                                 sb.Length = 0;
 151                                 Assert.AreEqual (vbNs + ".ChrW(1)", Generate (new CodePrimitiveExpression ('\x01'), sw), "#1");
 152                                 sb.Length = 0;
 153                                 Assert.AreEqual (vbNs + ".ChrW(2)", Generate (new CodePrimitiveExpression ('\x02'), sw), "#2");
 154                                 sb.Length = 0;
 155                                 Assert.AreEqual (vbNs + ".ChrW(3)", Generate (new CodePrimitiveExpression ('\x03'), sw), "#3");
 156                                 sb.Length = 0;
 157                                 Assert.AreEqual (vbNs + ".ChrW(4)", Generate (new CodePrimitiveExpression ('\x04'), sw), "#4");
 158                                 sb.Length = 0;
 159                                 Assert.AreEqual (vbNs + ".ChrW(5)", Generate (new CodePrimitiveExpression ('\x05'), sw), "#5");
 160                                 sb.Length = 0;
 161                                 Assert.AreEqual (vbNs + ".ChrW(6)", Generate (new CodePrimitiveExpression ('\x06'), sw), "#6");
 162                                 sb.Length = 0;
 163                                 Assert.AreEqual (vbNs + ".ChrW(7)", Generate (new CodePrimitiveExpression ('\a'), sw), "#7");
 164                                 sb.Length = 0;
 165                                 Assert.AreEqual (vbNs + ".ChrW(8)", Generate (new CodePrimitiveExpression ('\b'), sw), "#8");
 166                                 sb.Length = 0;
 167                                 Assert.AreEqual (vbNs + ".ChrW(9)", Generate (new CodePrimitiveExpression ('\t'), sw), "#9");
 168                                 sb.Length = 0;
 169                                 Assert.AreEqual (vbNs + ".ChrW(10)", Generate (new CodePrimitiveExpression ('\n'), sw), "#10");
 170                                 sb.Length = 0;
 171                                 Assert.AreEqual (vbNs + ".ChrW(11)", Generate (new CodePrimitiveExpression ('\v'), sw), "#11");
 172                                 sb.Length = 0;
 173                                 Assert.AreEqual (vbNs + ".ChrW(12)", Generate (new CodePrimitiveExpression ('\f'), sw), "#12");
 174                                 sb.Length = 0;
 175                                 Assert.AreEqual (vbNs + ".ChrW(13)", Generate (new CodePrimitiveExpression ('\r'), sw), "#13");
 176                                 sb.Length = 0;
 177                                 Assert.AreEqual (vbNs + ".ChrW(14)", Generate (new CodePrimitiveExpression ('\x0E'), sw), "#14");
 178                                 sb.Length = 0;
 179                                 Assert.AreEqual (vbNs + ".ChrW(15)", Generate (new CodePrimitiveExpression ('\x0F'), sw), "#15");
 180                                 sb.Length = 0;
 181                                 Assert.AreEqual (vbNs + ".ChrW(16)", Generate (new CodePrimitiveExpression ('\x10'), sw), "#16");
 182                                 sb.Length = 0;
 183                                 Assert.AreEqual (vbNs + ".ChrW(17)", Generate (new CodePrimitiveExpression ('\x11'), sw), "#17");
 184                                 sb.Length = 0;
 185                                 Assert.AreEqual (vbNs + ".ChrW(18)", Generate (new CodePrimitiveExpression ('\x12'), sw), "#18");
 186                                 sb.Length = 0;
 187                                 Assert.AreEqual (vbNs + ".ChrW(19)", Generate (new CodePrimitiveExpression ('\x13'), sw), "#19");
 188                                 sb.Length = 0;
 189                                 Assert.AreEqual (vbNs + ".ChrW(20)", Generate (new CodePrimitiveExpression ('\x14'), sw), "#20");
 190                                 sb.Length = 0;
 191                                 Assert.AreEqual (vbNs + ".ChrW(21)", Generate (new CodePrimitiveExpression ('\x15'), sw), "#21");
 192                                 sb.Length = 0;
 193                                 Assert.AreEqual (vbNs + ".ChrW(22)", Generate (new CodePrimitiveExpression ('\x16'), sw), "#22");
 194                                 sb.Length = 0;
 195                                 Assert.AreEqual (vbNs + ".ChrW(23)", Generate (new CodePrimitiveExpression ('\x17'), sw), "#23");
 196                                 sb.Length = 0;
 197                                 Assert.AreEqual (vbNs + ".ChrW(24)", Generate (new CodePrimitiveExpression ('\x18'), sw), "#24");
 198                                 sb.Length = 0;
 199                                 Assert.AreEqual (vbNs + ".ChrW(25)", Generate (new CodePrimitiveExpression ('\x19'), sw), "#25");
 200                                 sb.Length = 0;
 201                                 Assert.AreEqual (vbNs + ".ChrW(26)", Generate (new CodePrimitiveExpression ('\x1A'), sw), "#26");
 202                                 sb.Length = 0;
 203                                 Assert.AreEqual (vbNs + ".ChrW(27)", Generate (new CodePrimitiveExpression ('\x1B'), sw), "#27");
 204                                 sb.Length = 0;
 205                                 Assert.AreEqual (vbNs + ".ChrW(28)", Generate (new CodePrimitiveExpression ('\x1C'), sw), "#28");
 206                                 sb.Length = 0;
 207                                 Assert.AreEqual (vbNs + ".ChrW(29)", Generate (new CodePrimitiveExpression ('\x1D'), sw), "#29");
 208                                 sb.Length = 0;
 209                                 Assert.AreEqual (vbNs + ".ChrW(30)", Generate (new CodePrimitiveExpression ('\x1E'), sw), "#30");
 210                                 sb.Length = 0;
 211                                 Assert.AreEqual (vbNs + ".ChrW(31)", Generate (new CodePrimitiveExpression ('\x1F'), sw), "#31");
 212                                 sb.Length = 0;
 213                                 Assert.AreEqual (vbNs + ".ChrW(32)", Generate (new CodePrimitiveExpression ('\x20'), sw), "#32");
 214                                 sb.Length = 0;
 215                                 Assert.AreEqual (vbNs + ".ChrW(33)", Generate (new CodePrimitiveExpression ('\x21'), sw), "#33");
 216                                 sb.Length = 0;
 217                                 Assert.AreEqual (vbNs + ".ChrW(34)", Generate (new CodePrimitiveExpression ('"'), sw), "#34");
 218                                 sb.Length = 0;
 219                                 Assert.AreEqual (vbNs + ".ChrW(35)", Generate (new CodePrimitiveExpression ('\x23'), sw), "#35");
 220                                 sb.Length = 0;
 221                                 Assert.AreEqual (vbNs + ".ChrW(36)", Generate (new CodePrimitiveExpression ('\x24'), sw), "#36");
 222                                 sb.Length = 0;
 223                                 Assert.AreEqual (vbNs + ".ChrW(37)", Generate (new CodePrimitiveExpression ('\x25'), sw), "#37");
 224                                 sb.Length = 0;
 225                                 Assert.AreEqual (vbNs + ".ChrW(38)", Generate (new CodePrimitiveExpression ('\x26'), sw), "#38");
 226                                 sb.Length = 0;
 227                                 Assert.AreEqual (vbNs + ".ChrW(39)", Generate (new CodePrimitiveExpression ('\''), sw), "#39");
 228                                 sb.Length = 0;
 229                                 Assert.AreEqual (vbNs + ".ChrW(8232)", Generate (new CodePrimitiveExpression ('\u2028'), sw), "#40");
 230                                 sb.Length = 0;
 231                                 Assert.AreEqual (vbNs + ".ChrW(8233)", Generate (new CodePrimitiveExpression ('\u2029'), sw), "#41");
 232                                 sb.Length = 0;
 233                                 Assert.AreEqual (vbNs + ".ChrW(8240)", Generate (new CodePrimitiveExpression ('\u2030'), sw), "#42");
 234                                 sw.Close ();
 235                         }
 236                 }
 237
 238                 [Test]
 239 #if ONLY_1_1
 240                 [ExpectedException (typeof (ArgumentException))]
 241 #endif
 242                 public void PrimitiveExpressionTest_SByte ()
 243                 {
 244                         StringBuilder sb = new StringBuilder ();
 245
 246                         using (StringWriter sw = new StringWriter (sb)) {
 247                                 Assert.AreEqual ("CSByte(5)", Generate (new CodePrimitiveExpression ((sbyte) 5), sw));
 248                                 sw.Close ();
 249                         }
 250                 }
 251
 252                 [Test]
 253 #if ONLY_1_1
 254                 [ExpectedException (typeof (ArgumentException))]
 255 #endif
 256                 public void PrimitiveExpressionTest_UInt16 ()
 257                 {
 258                         StringBuilder sb = new StringBuilder ();
 259
 260                         using (StringWriter sw = new StringWriter (sb)) {
 261                                 Assert.AreEqual ("5US", Generate (new CodePrimitiveExpression ((ushort) 5), sw));
 262                                 sw.Close ();
 263                         }
 264                 }
 265
 266                 [Test]
 267 #if ONLY_1_1
 268                 [ExpectedException (typeof (ArgumentException))]
 269 #endif
 270                 public void PrimitiveExpressionTest_UInt32 ()
 271                 {
 272                         StringBuilder sb = new StringBuilder ();
 273
 274                         using (StringWriter sw = new StringWriter (sb)) {
 275                                 Assert.AreEqual ("5UI", Generate (new CodePrimitiveExpression ((uint) 5), sw));
 276                                 sw.Close ();
 277                         }
 278                 }
 279
 280                 [Test]
 281 #if ONLY_1_1
 282                 [ExpectedException (typeof (ArgumentException))]
 283 #endif
 284                 public void PrimitiveExpressionTest_UInt64 ()
 285                 {
 286                         StringBuilder sb = new StringBuilder ();
 287
 288                         using (StringWriter sw = new StringWriter (sb)) {
 289                                 Assert.AreEqual ("5UL", Generate (new CodePrimitiveExpression ((ulong) 5), sw));
 290                                 sw.Close ();
 291                         }
 292                 }
 293
 294                 [Test]
 295                 public void ParameterDeclarationExpressionTest ()
 296                 {
 297                         CodeParameterDeclarationExpression cpde = null;
 298
 299                         StringBuilder sb = new StringBuilder();
 300
 301                         using (StringWriter sw = new StringWriter (sb)) {
 302                                 cpde = new CodeParameterDeclarationExpression ();
 303                                 Assert.AreEqual ("ByVal __exception As System.Void", Generate (cpde, sw), "#1");
 304                                 sb.Length = 0;
 305
 306                                 cpde = new CodeParameterDeclarationExpression ((string) null,
 307                                         (string) null);
 308                                 Assert.AreEqual ("ByVal __exception As System.Void", Generate (cpde, sw), "#2");
 309                                 sb.Length = 0;
 310
 311                                 cpde = new CodeParameterDeclarationExpression ("A", (string) null);
 312                                 Assert.AreEqual ("ByVal __exception As A", Generate (cpde, sw), "#3");
 313                                 sb.Length = 0;
 314
 315                                 cpde = new CodeParameterDeclarationExpression ((string) null, "B");
 316                                 Assert.AreEqual ("ByVal B As System.Void", Generate (cpde, sw), "#4");
 317                                 sb.Length = 0;
 318
 319                                 cpde = new CodeParameterDeclarationExpression ("A", "B");
 320                                 Assert.AreEqual ("ByVal B As A", Generate (cpde, sw), "#5");
 321                                 sb.Length = 0;
 322
 323                                 cpde.Direction = FieldDirection.Out;
 324                                 Assert.AreEqual ("ByRef B As A", Generate (cpde, sw), "#6");
 325                                 sb.Length = 0;
 326
 327                                 cpde.Direction = FieldDirection.Ref;
 328                                 Assert.AreEqual ("ByRef B As A", Generate (cpde, sw), "#7");
 329                                 sb.Length = 0;
 330                         }
 331                 }
 332
 333                 private string Generate (CodeExpression expression, StringWriter sw)
 334                 {
 335                         generator.GenerateCodeFromExpression (expression, sw, options);
 336                         return sw.ToString ();
 337                 }
 338
 339
 340                 [Test]
 341                 public void ArrayCreateExpressionTest ()
 342                 {
 343                         StringBuilder sb;
 344
 345                         sb = new StringBuilder ();
 346                         using (StringWriter sw = new StringWriter (sb)) {
 347                                 Assert.AreEqual ("New Integer() {5}",
 348                                         Generate (new CodeArrayCreateExpression(
 349                                                         typeof(int),
 350                                                         new CodeExpression [] {
 351                                                                 new CodePrimitiveExpression (5)
 352                                                                 })
 353                                                 , sw), "#1");
 354                                 sw.Close ();
 355                         }
 356
 357                         sb = new StringBuilder ();
 358                         using (StringWriter sw = new StringWriter (sb)) {
 359                                 Assert.AreEqual ("New Integer((5) - 1) {}",
 360                                         Generate (new CodeArrayCreateExpression(
 361                                                         typeof(int),
 362                                                         new CodePrimitiveExpression (5))
 363                                                 , sw), "#2");
 364                                 sw.Close ();
 365                         }
 366
 367                         sb = new StringBuilder ();
 368                         using (StringWriter sw = new StringWriter (sb)) {
 369                                 Assert.AreEqual ("New String() {\"a\", \"b\", \"c\"}",
 370                                         Generate (new CodeArrayCreateExpression(
 371                                                         typeof(string),
 372                                                         new CodeExpression [] {
 373                                                                 new CodePrimitiveExpression ("a"),
 374                                                                 new CodePrimitiveExpression ("b"),
 375                                                                 new CodePrimitiveExpression ("c"),
 376                                                                 })
 377                                                 , sw), "#3");
 378                                 sw.Close ();
 379                         }
 380                 }
 381
 382                 [Test]
 383                 public void EscapedIdentifierTest ()
 384                 {
 385                         StringBuilder sb;
 386                         string code;
 387
 388                         sb = new StringBuilder ();
 389                         using (StringWriter sw = new StringWriter (sb)) {
 390                                 code = Generate (new CodeVariableReferenceExpression ("set"), sw);
 391                                 Assert.AreEqual ("[set]", code, "#01");
 392                                 sw.Close ();
 393                         }
 394
 395                         sb = new StringBuilder ();
 396                         using (StringWriter sw = new StringWriter (sb)) {
 397                                 code = Generate (new CodeTypeReferenceExpression ("set"), sw);
 398                                 Assert.AreEqual ("[set]", code, "#02");
 399                                 sw.Close ();
 400                         }
 401
 402                         sb = new StringBuilder ();
 403                         using (StringWriter sw = new StringWriter (sb)) {
 404                                 code = Generate (new CodePropertyReferenceExpression (null, "set"), sw);
 405                                 Assert.AreEqual ("[set]", code, "#03");
 406                                 sw.Close ();
 407                         }
 408
 409                         sb = new StringBuilder ();
 410                         using (StringWriter sw = new StringWriter (sb)) {
 411                                 code = Generate (new CodeMethodReferenceExpression (null, "set"), sw);
 412                                 Assert.AreEqual ("[set]", code, "#04");
 413                                 sw.Close ();
 414                         }
 415
 416                         sb = new StringBuilder ();
 417                         using (StringWriter sw = new StringWriter (sb)) {
 418                                 code = Generate (new CodeFieldReferenceExpression (null, "set"), sw);
 419                                 Assert.AreEqual ("[set]", code, "#05");
 420                                 sw.Close ();
 421                         }
 422
 423                         sb = new StringBuilder ();
 424                         using (StringWriter sw = new StringWriter (sb)) {
 425                                 code = Generate (new CodeEventReferenceExpression (null, "set"), sw);
 426                                 Assert.AreEqual ("setEvent", code, "#06");
 427                                 sw.Close ();
 428                         }
 429                 }
 430
 431                 [Test]
 432                 public void EventReferenceTest ()
 433                 {
 434                         StringBuilder sb;
 435                         string code;
 436
 437                         sb = new StringBuilder ();
 438                         using (StringWriter sw = new StringWriter (sb)) {
 439                                 code = Generate (new CodeEventReferenceExpression (null, null), sw);
 440                                 Assert.AreEqual ("[Event]", code, "#01");
 441                         }
 442
 443                         sb = new StringBuilder ();
 444                         using (StringWriter sw = new StringWriter (sb)) {
 445                                 code = Generate (new CodeEventReferenceExpression (null, "abc"), sw);
 446                                 Assert.AreEqual ("abcEvent", code, "#02");
 447                         }
 448
 449                         sb = new StringBuilder ();
 450                         using (StringWriter sw = new StringWriter (sb)) {
 451                                 code = Generate (new CodeEventReferenceExpression (new CodeThisReferenceExpression (), null), sw);
 452                                 Assert.AreEqual ("Me.Event", code, "#03");
 453                         }
 454
 455                         sb = new StringBuilder ();
 456                         using (StringWriter sw = new StringWriter (sb)) {
 457                                 code = Generate (new CodeEventReferenceExpression (new CodeThisReferenceExpression (), "abc"), sw);
 458                                 Assert.AreEqual ("Me.abcEvent", code, "#04");
 459                         }
 460
 461                         sb = new StringBuilder ();
 462                         using (StringWriter sw = new StringWriter (sb)) {
 463                                 code = Generate (new CodeEventReferenceExpression (new CodePrimitiveExpression ("primitive"), null), sw);
 464                                 Assert.AreEqual ("\"primitive\".", code, "#05");
 465                         }
 466
 467                         sb = new StringBuilder ();
 468                         using (StringWriter sw = new StringWriter (sb)) {
 469                                 code = Generate (new CodeEventReferenceExpression (new CodePrimitiveExpression ("primitive"), "abc"), sw);
 470                                 Assert.AreEqual ("\"primitive\".abc", code, "#06");
 471                         }
 472                 }
 473
 474                 [Test]
 475                 public void DelegateInvokeTest ()
 476                 {
 477                         StringBuilder sb;
 478                         string code;
 479
 480                         sb = new StringBuilder ();
 481                         using (StringWriter sw = new StringWriter (sb)) {
 482                                 code = Generate (new CodeDelegateInvokeExpression (null, new CodePrimitiveExpression ("abc")), sw);
 483                                 Assert.AreEqual ("(\"abc\")", code, "#01");
 484                         }
 485
 486                         sb = new StringBuilder ();
 487                         using (StringWriter sw = new StringWriter (sb)) {
 488                                 code = Generate (new CodeDelegateInvokeExpression (new CodeThisReferenceExpression (), new CodePrimitiveExpression ("abc")), sw);
 489                                 Assert.AreEqual ("Me(\"abc\")", code, "#02");
 490                         }
 491
 492                         sb = new StringBuilder ();
 493                         using (StringWriter sw = new StringWriter (sb)) {
 494                                 code = Generate (new CodeDelegateInvokeExpression (new CodePrimitiveExpression ("primitive"), new CodePrimitiveExpression ("abc")), sw);
 495                                 Assert.AreEqual ("\"primitive\"(\"abc\")", code, "#03");
 496                         }
 497
 498                         sb = new StringBuilder ();
 499                         using (StringWriter sw = new StringWriter (sb)) {
 500                                 code = Generate (new CodeDelegateInvokeExpression (new CodeEventReferenceExpression (new CodeThisReferenceExpression (), "Click"), new CodePrimitiveExpression ("abc")), sw);
 501                                 Assert.AreEqual ("RaiseEvent Click(\"abc\")", code, "#04");
 502                         }
 503
 504                         sb = new StringBuilder ();
 505                         using (StringWriter sw = new StringWriter (sb)) {
 506                                 code = Generate (new CodeDelegateInvokeExpression (new CodeEventReferenceExpression (new CodeThisReferenceExpression (), null), new CodePrimitiveExpression ("abc")), sw);
 507                                 Assert.AreEqual ("RaiseEvent (\"abc\")", code, "#05");
 508                         }
 509
 510                         sb = new StringBuilder ();
 511                         using (StringWriter sw = new StringWriter (sb)) {
 512                                 code = Generate (new CodeDelegateInvokeExpression (new CodeEventReferenceExpression (new CodePrimitiveExpression ("primitive"), "Click"), new CodePrimitiveExpression ("abc")), sw);
 513                                 Assert.AreEqual ("RaiseEvent \"primitive\".Click(\"abc\")", code, "#06");
 514                         }
 515
 516                         sb = new StringBuilder ();
 517                         using (StringWriter sw = new StringWriter (sb)) {
 518                                 code = Generate (new CodeDelegateInvokeExpression (new CodeEventReferenceExpression (new CodePrimitiveExpression ("primitive"), null), new CodePrimitiveExpression ("abc")), sw);
 519                                 Assert.AreEqual ("RaiseEvent \"primitive\".(\"abc\")", code, "#07");
 520                         }
 521                 }
 522         }
 523 }