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

   1 //
   2 // Microsoft.CSharp.* Test Cases
   3 //
   4 // Authors:
   5 //      Erik LeBel (eriklebel@yahoo.ca)
   6 //
   7 // (c) 2003 Erik LeBel
   8 //
   9 using System;
  10 using System.CodeDom;
  11 using System.CodeDom.Compiler;
  12 using System.Globalization;
  13 using System.IO;
  14 using System.Text;
  15
  16 using Microsoft.CSharp;
  17
  18 using NUnit.Framework;
  19
  20 namespace MonoTests.Microsoft.CSharp
  21 {
  22         /// <summary>
  23         /// Test ICodeGenerator's GenerateCodeFromExpression, along with a
  24         /// minimal set CodeDom components.
  25         /// </summary>
  26         [TestFixture]
  27         public class CodeGeneratorFromExpressionTest
  28         {
  29                 private CSharpCodeProvider provider;
  30                 private ICodeGenerator generator;
  31                 private CodeGeneratorOptions options;
  32
  33                 [SetUp]
  34                 public void SetUp ()
  35                 {
  36                         provider = new CSharpCodeProvider ();
  37                         generator = provider.CreateGenerator ();
  38                         options = new CodeGeneratorOptions ();
  39                 }
  40
  41                 [Test]
  42                 public void DefaultExpressionTest ()
  43                 {
  44                         using (StringWriter sw = new StringWriter ()) {
  45                                 try {
  46                                         Generate (new CodeExpression (), sw);
  47                                         Assert.Fail ("#1");
  48                                 } catch (ArgumentException ex) {
  49                                         // Element type System.CodeDom.CodeExpression is not supported
  50                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
  51                                         Assert.IsNull (ex.InnerException, "#3");
  52                                         Assert.IsNotNull (ex.Message, "#4");
  53                                         Assert.AreEqual ("e", ex.ParamName, "#5");
  54                                 }
  55                         }
  56                 }
  57
  58                 [Test]
  59                 public void NullExpressionTest ()
  60                 {
  61                         using (StringWriter sw = new StringWriter ()) {
  62                                 try {
  63                                         Generate (null, sw);
  64                                         Assert.Fail ("#1");
  65                                 } catch (ArgumentNullException ex) {
  66                                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
  67                                         Assert.IsNull (ex.InnerException, "#3");
  68                                         Assert.IsNotNull (ex.Message, "#4");
  69                                         Assert.AreEqual ("e", ex.ParamName, "#5");
  70                                 }
  71                         }
  72                 }
  73
  74                 [Test]
  75                 public void TypeReferenceExpressionTest ()
  76                 {
  77                         StringBuilder sb = new StringBuilder ();
  78
  79                         using (StringWriter sw = new StringWriter (sb)) {
  80                                 Assert.AreEqual ("bool", Generate (new CodeTypeReferenceExpression (typeof (bool)), sw), "#1");
  81                                 sb.Length = 0;
  82                                 Assert.AreEqual ("char", Generate (new CodeTypeReferenceExpression (typeof (char)), sw), "#2");
  83                                 sb.Length = 0;
  84                                 Assert.AreEqual (typeof(DateTime).FullName, Generate (new CodeTypeReferenceExpression (typeof (DateTime)), sw), "#3");
  85                                 sb.Length = 0;
  86                                 Assert.AreEqual ("short", Generate (new CodeTypeReferenceExpression (typeof (short)), sw), "#4");
  87                                 sb.Length = 0;
  88                                 Assert.AreEqual ("int", Generate (new CodeTypeReferenceExpression (typeof (int)), sw), "#5");
  89                                 sb.Length = 0;
  90                                 Assert.AreEqual ("long", Generate (new CodeTypeReferenceExpression (typeof (long)), sw), "#6");
  91                                 sb.Length = 0;
  92                                 Assert.AreEqual ("object", Generate (new CodeTypeReferenceExpression (typeof (object)), sw), "#7");
  93                                 sb.Length = 0;
  94                                 Assert.AreEqual ("void", Generate (new CodeTypeReferenceExpression (typeof (void)), sw), "#8");
  95                                 sb.Length = 0;
  96                                 Assert.AreEqual ("void", Generate (new CodeTypeReferenceExpression ((string) null), sw), "#9");
  97                                 sb.Length = 0;
  98                                 Assert.AreEqual ("void", Generate (new CodeTypeReferenceExpression (""), sw), "#10");
  99                                 sb.Length = 0;
 100 #if NET_2_0
 101                                 Assert.AreEqual ("byte", Generate (new CodeTypeReferenceExpression (typeof (byte)), sw), "#11");
 102                                 sb.Length = 0;
 103                                 Assert.AreEqual ("decimal", Generate (new CodeTypeReferenceExpression (typeof (decimal)), sw), "#12");
 104                                 sb.Length = 0;
 105                                 Assert.AreEqual ("double", Generate (new CodeTypeReferenceExpression (typeof (double)), sw), "#13");
 106                                 sb.Length = 0;
 107                                 Assert.AreEqual ("sbyte", Generate (new CodeTypeReferenceExpression (typeof (sbyte)), sw), "#14");
 108                                 sb.Length = 0;
 109                                 Assert.AreEqual ("ushort", Generate (new CodeTypeReferenceExpression (typeof (ushort)), sw), "#15");
 110                                 sb.Length = 0;
 111                                 Assert.AreEqual ("uint", Generate (new CodeTypeReferenceExpression (typeof (uint)), sw), "#16");
 112                                 sb.Length = 0;
 113                                 Assert.AreEqual ("ulong", Generate (new CodeTypeReferenceExpression (typeof (ulong)), sw), "#17");
 114                                 sb.Length = 0;
 115                                 Assert.AreEqual ("float", Generate (new CodeTypeReferenceExpression (typeof (float)), sw), "#18");
 116                                 sb.Length = 0;
 117 #else
 118                                 Assert.AreEqual (typeof (byte).FullName, Generate (new CodeTypeReferenceExpression (typeof (byte)), sw), "#19");
 119                                 sb.Length = 0;
 120                                 Assert.AreEqual (typeof (decimal).FullName, Generate (new CodeTypeReferenceExpression (typeof (decimal)), sw), "#20");
 121                                 sb.Length = 0;
 122                                 Assert.AreEqual (typeof (double).FullName, Generate (new CodeTypeReferenceExpression (typeof (double)), sw), "#21");
 123                                 sb.Length = 0;
 124                                 Assert.AreEqual (typeof (sbyte).FullName, Generate (new CodeTypeReferenceExpression (typeof (sbyte)), sw), "#22");
 125                                 sb.Length = 0;
 126                                 Assert.AreEqual (typeof (ushort).FullName, Generate (new CodeTypeReferenceExpression (typeof (ushort)), sw), "#23");
 127                                 sb.Length = 0;
 128                                 Assert.AreEqual (typeof (uint).FullName, Generate (new CodeTypeReferenceExpression (typeof (uint)), sw), "#24");
 129                                 sb.Length = 0;
 130                                 Assert.AreEqual (typeof (ulong).FullName, Generate (new CodeTypeReferenceExpression (typeof (ulong)), sw), "#25");
 131                                 sb.Length = 0;
 132                                 Assert.AreEqual (typeof (float).FullName, Generate (new CodeTypeReferenceExpression (typeof (float)), sw), "#26");
 133                                 sb.Length = 0;
 134 #endif
 135                                 sw.Close ();
 136                         }
 137                 }
 138
 139                 [Test]
 140                 public void PrimitiveExpressionTest ()
 141                 {
 142                         StringBuilder sb = new StringBuilder ();
 143
 144                         using (StringWriter sw = new StringWriter (sb)) {
 145                                 Assert.AreEqual ("null", Generate (new CodePrimitiveExpression (null), sw), "#1");
 146                                 sb.Length = 0;
 147                                 Assert.AreEqual ("\"AB\\\"C\"", Generate (new CodePrimitiveExpression ("AB\"C"), sw), "#2");
 148                                 sb.Length = 0;
 149                                 Assert.AreEqual ("5", Generate (new CodePrimitiveExpression ((byte) 5), sw), "#4");
 150                                 sb.Length = 0;
 151                                 Assert.AreEqual ("20", Generate (new CodePrimitiveExpression ((short) 20), sw), "#5");
 152                                 sb.Length = 0;
 153                                 Assert.AreEqual ("243", Generate (new CodePrimitiveExpression (243), sw), "#6");
 154                                 sb.Length = 0;
 155                                 Assert.AreEqual ("434343", Generate (new CodePrimitiveExpression ((long) 434343), sw), "#7");
 156                                 sb.Length = 0;
 157                                 Assert.AreEqual ("6.445F", Generate (new CodePrimitiveExpression ((float) 6.445), sw), "#8");
 158                                 sb.Length = 0;
 159                                 Assert.AreEqual ("5.76", Generate (new CodePrimitiveExpression ((double) 5.76), sw), "#9");
 160                                 sb.Length = 0;
 161                                 Assert.AreEqual ("7.667m", Generate (new CodePrimitiveExpression ((decimal) 7.667), sw), "#10");
 162                                 sb.Length = 0;
 163                                 Assert.AreEqual ("true", Generate (new CodePrimitiveExpression (true), sw), "#11");
 164                                 sb.Length = 0;
 165                                 Assert.AreEqual ("false", Generate (new CodePrimitiveExpression (false), sw), "#12");
 166                                 sw.Close ();
 167                         }
 168                 }
 169
 170                 [Test]
 171                 public void PrimitiveExpressionTest_Char ()
 172                 {
 173                         StringBuilder sb = new StringBuilder ();
 174
 175                         using (StringWriter sw = new StringWriter (sb)) {
 176                                 Assert.AreEqual ("'\\0'", Generate (new CodePrimitiveExpression ('\0'), sw), "#0");
 177                                 sb.Length = 0;
 178                                 Assert.AreEqual ("'\x01'", Generate (new CodePrimitiveExpression ('\x01'), sw), "#1");
 179                                 sb.Length = 0;
 180                                 Assert.AreEqual ("'\x02'", Generate (new CodePrimitiveExpression ('\x02'), sw), "#2");
 181                                 sb.Length = 0;
 182                                 Assert.AreEqual ("'\x03'", Generate (new CodePrimitiveExpression ('\x03'), sw), "#3");
 183                                 sb.Length = 0;
 184                                 Assert.AreEqual ("'\x04'", Generate (new CodePrimitiveExpression ('\x04'), sw), "#4");
 185                                 sb.Length = 0;
 186                                 Assert.AreEqual ("'\x05'", Generate (new CodePrimitiveExpression ('\x05'), sw), "#5");
 187                                 sb.Length = 0;
 188                                 Assert.AreEqual ("'\x06'", Generate (new CodePrimitiveExpression ('\x06'), sw), "#6");
 189                                 sb.Length = 0;
 190                                 Assert.AreEqual ("'\a'", Generate (new CodePrimitiveExpression ('\a'), sw), "#7");
 191                                 sb.Length = 0;
 192                                 Assert.AreEqual ("'\b'", Generate (new CodePrimitiveExpression ('\b'), sw), "#8");
 193                                 sb.Length = 0;
 194                                 Assert.AreEqual ("'\\t'", Generate (new CodePrimitiveExpression ('\t'), sw), "#9");
 195                                 sb.Length = 0;
 196                                 Assert.AreEqual ("'\\n'", Generate (new CodePrimitiveExpression ('\n'), sw), "#10");
 197                                 sb.Length = 0;
 198                                 Assert.AreEqual ("'\v'", Generate (new CodePrimitiveExpression ('\v'), sw), "#11");
 199                                 sb.Length = 0;
 200                                 Assert.AreEqual ("'\f'", Generate (new CodePrimitiveExpression ('\f'), sw), "#12");
 201                                 sb.Length = 0;
 202                                 Assert.AreEqual ("'\\r'", Generate (new CodePrimitiveExpression ('\r'), sw), "#13");
 203                                 sb.Length = 0;
 204                                 Assert.AreEqual ("'\x0E'", Generate (new CodePrimitiveExpression ('\x0E'), sw), "#14");
 205                                 sb.Length = 0;
 206                                 Assert.AreEqual ("'\x0F'", Generate (new CodePrimitiveExpression ('\x0F'), sw), "#15");
 207                                 sb.Length = 0;
 208                                 Assert.AreEqual ("'\x10'", Generate (new CodePrimitiveExpression ('\x10'), sw), "#16");
 209                                 sb.Length = 0;
 210                                 Assert.AreEqual ("'\x11'", Generate (new CodePrimitiveExpression ('\x11'), sw), "#17");
 211                                 sb.Length = 0;
 212                                 Assert.AreEqual ("'\x12'", Generate (new CodePrimitiveExpression ('\x12'), sw), "#18");
 213                                 sb.Length = 0;
 214                                 Assert.AreEqual ("'\x13'", Generate (new CodePrimitiveExpression ('\x13'), sw), "#19");
 215                                 sb.Length = 0;
 216                                 Assert.AreEqual ("'\x14'", Generate (new CodePrimitiveExpression ('\x14'), sw), "#20");
 217                                 sb.Length = 0;
 218                                 Assert.AreEqual ("'\x15'", Generate (new CodePrimitiveExpression ('\x15'), sw), "#21");
 219                                 sb.Length = 0;
 220                                 Assert.AreEqual ("'\x16'", Generate (new CodePrimitiveExpression ('\x16'), sw), "#22");
 221                                 sb.Length = 0;
 222                                 Assert.AreEqual ("'\x17'", Generate (new CodePrimitiveExpression ('\x17'), sw), "#23");
 223                                 sb.Length = 0;
 224                                 Assert.AreEqual ("'\x18'", Generate (new CodePrimitiveExpression ('\x18'), sw), "#24");
 225                                 sb.Length = 0;
 226                                 Assert.AreEqual ("'\x19'", Generate (new CodePrimitiveExpression ('\x19'), sw), "#25");
 227                                 sb.Length = 0;
 228                                 Assert.AreEqual ("'\x1A'", Generate (new CodePrimitiveExpression ('\x1A'), sw), "#26");
 229                                 sb.Length = 0;
 230                                 Assert.AreEqual ("'\x1B'", Generate (new CodePrimitiveExpression ('\x1B'), sw), "#27");
 231                                 sb.Length = 0;
 232                                 Assert.AreEqual ("'\x1C'", Generate (new CodePrimitiveExpression ('\x1C'), sw), "#28");
 233                                 sb.Length = 0;
 234                                 Assert.AreEqual ("'\x1D'", Generate (new CodePrimitiveExpression ('\x1D'), sw), "#29");
 235                                 sb.Length = 0;
 236                                 Assert.AreEqual ("'\x1E'", Generate (new CodePrimitiveExpression ('\x1E'), sw), "#30");
 237                                 sb.Length = 0;
 238                                 Assert.AreEqual ("'\x1F'", Generate (new CodePrimitiveExpression ('\x1F'), sw), "#31");
 239                                 sb.Length = 0;
 240                                 Assert.AreEqual ("'\x20'", Generate (new CodePrimitiveExpression ('\x20'), sw), "#32");
 241                                 sb.Length = 0;
 242                                 Assert.AreEqual ("'\x21'", Generate (new CodePrimitiveExpression ('\x21'), sw), "#33");
 243                                 sb.Length = 0;
 244                                 Assert.AreEqual ("'\\\"'", Generate (new CodePrimitiveExpression ('"'), sw), "#34");
 245                                 sb.Length = 0;
 246                                 Assert.AreEqual ("'\x23'", Generate (new CodePrimitiveExpression ('\x23'), sw), "#35");
 247                                 sb.Length = 0;
 248                                 Assert.AreEqual ("'\x24'", Generate (new CodePrimitiveExpression ('\x24'), sw), "#36");
 249                                 sb.Length = 0;
 250                                 Assert.AreEqual ("'\x25'", Generate (new CodePrimitiveExpression ('\x25'), sw), "#37");
 251                                 sb.Length = 0;
 252                                 Assert.AreEqual ("'\x26'", Generate (new CodePrimitiveExpression ('\x26'), sw), "#38");
 253                                 sb.Length = 0;
 254                                 Assert.AreEqual ("'\\''", Generate (new CodePrimitiveExpression ('\''), sw), "#39");
 255                                 sb.Length = 0;
 256 #if NET_2_0
 257                                 Assert.AreEqual ("'\\u2028'", Generate (new CodePrimitiveExpression ('\u2028'), sw), "#40");
 258 #else
 259                                 Assert.AreEqual ("'\\u8232'", Generate (new CodePrimitiveExpression ('\u2028'), sw), "#40");
 260 #endif
 261                                 sb.Length = 0;
 262 #if NET_2_0
 263                                 Assert.AreEqual ("'\\u2029'", Generate (new CodePrimitiveExpression ('\u2029'), sw), "#41");
 264 #else
 265                                 Assert.AreEqual ("'\\u8233'", Generate (new CodePrimitiveExpression ('\u2029'), sw), "#41");
 266 #endif
 267                                 sb.Length = 0;
 268                                 Assert.AreEqual ("'\u2030'", Generate (new CodePrimitiveExpression ('\u2030'), sw), "#42");
 269                                 sw.Close ();
 270                         }
 271                 }
 272
 273                 [Test]
 274 #if ONLY_1_1
 275                 [ExpectedException (typeof (ArgumentException))]
 276 #endif
 277                 public void PrimitiveExpressionTest_SByte ()
 278                 {
 279                         StringBuilder sb = new StringBuilder ();
 280
 281                         using (StringWriter sw = new StringWriter (sb)) {
 282                                 Assert.AreEqual ("5", Generate (new CodePrimitiveExpression ((sbyte) 5), sw));
 283                                 sw.Close ();
 284                         }
 285                 }
 286
 287                 [Test]
 288 #if ONLY_1_1
 289                 [ExpectedException (typeof (ArgumentException))]
 290 #endif
 291                 public void PrimitiveExpressionTest_UInt16 ()
 292                 {
 293                         StringBuilder sb = new StringBuilder ();
 294
 295                         using (StringWriter sw = new StringWriter (sb)) {
 296                                 Assert.AreEqual ("5", Generate (new CodePrimitiveExpression ((ushort) 5), sw));
 297                                 sw.Close ();
 298                         }
 299                 }
 300
 301                 [Test]
 302 #if ONLY_1_1
 303                 [ExpectedException (typeof (ArgumentException))]
 304 #endif
 305                 public void PrimitiveExpressionTest_UInt32 ()
 306                 {
 307                         StringBuilder sb = new StringBuilder ();
 308
 309                         using (StringWriter sw = new StringWriter (sb)) {
 310                                 Assert.AreEqual ("5u", Generate (new CodePrimitiveExpression ((uint) 5), sw));
 311                                 sw.Close ();
 312                         }
 313                 }
 314
 315                 [Test]
 316 #if ONLY_1_1
 317                 [ExpectedException (typeof (ArgumentException))]
 318 #endif
 319                 public void PrimitiveExpressionTest_UInt64 ()
 320                 {
 321                         StringBuilder sb = new StringBuilder ();
 322
 323                         using (StringWriter sw = new StringWriter (sb)) {
 324                                 Assert.AreEqual ("5ul", Generate (new CodePrimitiveExpression ((ulong) 5), sw));
 325                                 sw.Close ();
 326                         }
 327                 }
 328
 329                 [Test]
 330                 public void ParameterDeclarationExpressionTest ()
 331                 {
 332                         CodeParameterDeclarationExpression cpde = null;
 333
 334                         StringBuilder sb = new StringBuilder ();
 335
 336                         using (StringWriter sw = new StringWriter (sb)) {
 337                                 cpde = new CodeParameterDeclarationExpression ();
 338                                 Assert.AreEqual ("void ", Generate (cpde, sw), "#1");
 339                                 sb.Length = 0;
 340
 341                                 cpde = new CodeParameterDeclarationExpression ((string) null,
 342                                         (string) null);
 343                                 Assert.AreEqual ("void ", Generate (cpde, sw), "#2");
 344                                 sb.Length = 0;
 345
 346                                 cpde = new CodeParameterDeclarationExpression ("A", (string) null);
 347                                 Assert.AreEqual ("A ", Generate (cpde, sw), "#4");
 348                                 sb.Length = 0;
 349
 350                                 cpde = new CodeParameterDeclarationExpression ((string) null, "B");
 351                                 Assert.AreEqual ("void B", Generate (cpde, sw), "#4");
 352                                 sb.Length = 0;
 353
 354                                 cpde = new CodeParameterDeclarationExpression ("A", "B");
 355                                 Assert.AreEqual ("A B", Generate (cpde, sw), "#5");
 356                                 sb.Length = 0;
 357
 358                                 cpde.Direction = FieldDirection.Out;
 359                                 Assert.AreEqual ("out A B", Generate (cpde, sw), "#6");
 360                                 sb.Length = 0;
 361
 362                                 cpde.Direction = FieldDirection.Ref;
 363                                 Assert.AreEqual ("ref A B", Generate (cpde, sw), "#7");
 364                                 sb.Length = 0;
 365                         }
 366                 }
 367
 368                 [Test]
 369                 public void ArrayCreateExpressionTest ()
 370                 {
 371                         StringBuilder sb;
 372
 373                         sb = new StringBuilder ();
 374                         using (StringWriter sw = new StringWriter (sb)) {
 375                                 Assert.AreEqual (
 376                                         string.Format (CultureInfo.InvariantCulture,
 377                                                 "new int[] {{{0}        5}}",
 378                                                 Environment.NewLine),
 379                                         Generate (new CodeArrayCreateExpression (
 380                                                         typeof (int),
 381                                                         new CodeExpression [] {
 382                                                                 new CodePrimitiveExpression (5)
 383                                                                 })
 384                                                 , sw), "#1");
 385                         }
 386
 387                         sb = new StringBuilder ();
 388                         using (StringWriter sw = new StringWriter (sb)) {
 389                                 Assert.AreEqual ("new int[5]",
 390                                         Generate (new CodeArrayCreateExpression (
 391                                                         typeof (int),
 392                                                         new CodePrimitiveExpression (5))
 393                                                 , sw), "#2");
 394                         }
 395
 396                         sb = new StringBuilder ();
 397                         using (StringWriter sw = new StringWriter (sb)) {
 398                                 Assert.AreEqual (
 399                                         string.Format (CultureInfo.InvariantCulture,
 400                                                 "new string[] {{{0}" +
 401                                                 "        \"a\",{0}" +
 402                                                 "        \"b\",{0}" +
 403                                                 "        \"c\"}}",
 404                                                 Environment.NewLine),
 405                                         Generate (new CodeArrayCreateExpression (
 406                                                         typeof (string),
 407                                                         new CodeExpression [] {
 408                                                                 new CodePrimitiveExpression ("a"),
 409                                                                 new CodePrimitiveExpression ("b"),
 410                                                                 new CodePrimitiveExpression ("c"),
 411                                                                 })
 412                                                 , sw));
 413                                 sw.Close ();
 414                         }
 415                 }
 416
 417                 [Test]
 418                 public void EscapedIdentifierTest ()
 419                 {
 420                         StringBuilder sb;
 421                         string code;
 422
 423                         sb = new StringBuilder ();
 424                         using (StringWriter sw = new StringWriter (sb)) {
 425                                 code = Generate (new CodeVariableReferenceExpression ("using"), sw);
 426                                 Assert.AreEqual ("@using", code, "#1");
 427                                 sw.Close ();
 428                         }
 429
 430                         sb = new StringBuilder ();
 431                         using (StringWriter sw = new StringWriter (sb)) {
 432                                 code = Generate (new CodeTypeReferenceExpression ("using"), sw);
 433                                 Assert.AreEqual ("@using", code, "#2");
 434                                 sw.Close ();
 435                         }
 436
 437                         sb = new StringBuilder ();
 438                         using (StringWriter sw = new StringWriter (sb)) {
 439                                 code = Generate (new CodePropertyReferenceExpression (null, "using"), sw);
 440                                 Assert.AreEqual ("@using", code, "#3");
 441                                 sw.Close ();
 442                         }
 443
 444                         sb = new StringBuilder ();
 445                         using (StringWriter sw = new StringWriter (sb)) {
 446                                 code = Generate (new CodeMethodReferenceExpression (null, "using"), sw);
 447                                 Assert.AreEqual ("@using", code, "#4");
 448                                 sw.Close ();
 449                         }
 450
 451                         sb = new StringBuilder ();
 452                         using (StringWriter sw = new StringWriter (sb)) {
 453                                 code = Generate (new CodeFieldReferenceExpression (null, "using"), sw);
 454                                 Assert.AreEqual ("@using", code, "#5");
 455                                 sw.Close ();
 456                         }
 457
 458                         sb = new StringBuilder ();
 459                         using (StringWriter sw = new StringWriter (sb)) {
 460                                 code = Generate (new CodeEventReferenceExpression (null, "using"), sw);
 461                                 Assert.AreEqual ("@using", code, "#6");
 462                                 sw.Close ();
 463                         }
 464                 }
 465
 466                 [Test]
 467                 public void EventReferenceTest ()
 468                 {
 469                         StringBuilder sb;
 470                         string code;
 471
 472                         sb = new StringBuilder ();
 473                         using (StringWriter sw = new StringWriter (sb)) {
 474                                 code = Generate (new CodeEventReferenceExpression (null, null), sw);
 475                                 Assert.AreEqual (string.Empty, code, "#1");
 476                         }
 477
 478                         sb = new StringBuilder ();
 479                         using (StringWriter sw = new StringWriter (sb)) {
 480                                 code = Generate (new CodeEventReferenceExpression (null, "abc"), sw);
 481                                 Assert.AreEqual ("abc", code, "#2");
 482                         }
 483
 484                         sb = new StringBuilder ();
 485                         using (StringWriter sw = new StringWriter (sb)) {
 486                                 code = Generate (new CodeEventReferenceExpression (new CodeThisReferenceExpression (), null), sw);
 487                                 Assert.AreEqual ("this.", code, "#3");
 488                         }
 489
 490                         sb = new StringBuilder ();
 491                         using (StringWriter sw = new StringWriter (sb)) {
 492                                 code = Generate (new CodeEventReferenceExpression (new CodeThisReferenceExpression (), "abc"), sw);
 493                                 Assert.AreEqual ("this.abc", code, "#4");
 494                         }
 495
 496                         sb = new StringBuilder ();
 497                         using (StringWriter sw = new StringWriter (sb)) {
 498                                 code = Generate (new CodeEventReferenceExpression (new CodePrimitiveExpression ("primitive"), null), sw);
 499                                 Assert.AreEqual ("\"primitive\".", code, "#5");
 500                         }
 501
 502                         sb = new StringBuilder ();
 503                         using (StringWriter sw = new StringWriter (sb)) {
 504                                 code = Generate (new CodeEventReferenceExpression (new CodePrimitiveExpression ("primitive"), "abc"), sw);
 505                                 Assert.AreEqual ("\"primitive\".abc", code, "#6");
 506                         }
 507                 }
 508
 509 #if NET_2_0
 510                 [Test]
 511                 public void DefaultValueExpressionTest ()
 512                 {
 513                         StringBuilder sb = new StringBuilder ();
 514
 515                         using (StringWriter sw = new StringWriter (sb)) {
 516                                 Assert.AreEqual ("default(string)", Generate (new CodeDefaultValueExpression (new CodeTypeReference (typeof(string))), sw), "#0");
 517                                 sb.Length = 0;
 518                                 sw.Close ();
 519                         }
 520                 }
 521 #endif
 522
 523                 [Test]
 524                 public void DelegateInvokeTest ()
 525                 {
 526                         StringBuilder sb;
 527                         string code;
 528
 529                         sb = new StringBuilder ();
 530                         using (StringWriter sw = new StringWriter (sb)) {
 531                                 code = Generate (new CodeDelegateInvokeExpression (null, new CodePrimitiveExpression ("abc")), sw);
 532                                 Assert.AreEqual ("(\"abc\")", code, "#1");
 533                         }
 534
 535                         sb = new StringBuilder ();
 536                         using (StringWriter sw = new StringWriter (sb)) {
 537                                 code = Generate (new CodeDelegateInvokeExpression (new CodeThisReferenceExpression (), new CodePrimitiveExpression ("abc")), sw);
 538                                 Assert.AreEqual ("this(\"abc\")", code, "#2");
 539                         }
 540
 541                         sb = new StringBuilder ();
 542                         using (StringWriter sw = new StringWriter (sb)) {
 543                                 code = Generate (new CodeDelegateInvokeExpression (new CodePrimitiveExpression ("primitive"), new CodePrimitiveExpression ("abc")), sw);
 544                                 Assert.AreEqual ("\"primitive\"(\"abc\")", code, "#3");
 545                         }
 546
 547                         sb = new StringBuilder ();
 548                         using (StringWriter sw = new StringWriter (sb)) {
 549                                 code = Generate (new CodeDelegateInvokeExpression (new CodeEventReferenceExpression (new CodeThisReferenceExpression (), "Click"), new CodePrimitiveExpression ("abc")), sw);
 550                                 Assert.AreEqual ("this.Click(\"abc\")", code, "#4");
 551                         }
 552
 553                         sb = new StringBuilder ();
 554                         using (StringWriter sw = new StringWriter (sb)) {
 555                                 code = Generate (new CodeDelegateInvokeExpression (new CodeEventReferenceExpression (new CodeThisReferenceExpression (), null), new CodePrimitiveExpression ("abc")), sw);
 556                                 Assert.AreEqual ("this.(\"abc\")", code, "#5");
 557                         }
 558
 559                         sb = new StringBuilder ();
 560                         using (StringWriter sw = new StringWriter (sb)) {
 561                                 code = Generate (new CodeDelegateInvokeExpression (new CodeEventReferenceExpression (new CodePrimitiveExpression ("primitive"), "Click"), new CodePrimitiveExpression ("abc")), sw);
 562                                 Assert.AreEqual ("\"primitive\".Click(\"abc\")", code, "#6");
 563                         }
 564
 565                         sb = new StringBuilder ();
 566                         using (StringWriter sw = new StringWriter (sb)) {
 567                                 code = Generate (new CodeDelegateInvokeExpression (new CodeEventReferenceExpression (new CodePrimitiveExpression ("primitive"), null), new CodePrimitiveExpression ("abc")), sw);
 568                                 Assert.AreEqual ("\"primitive\".(\"abc\")", code, "#7");
 569                         }
 570
 571                         sb = new StringBuilder ();
 572                         using (StringWriter sw = new StringWriter (sb)) {
 573                                 code = Generate (new CodeDelegateInvokeExpression (), sw);
 574                                 Assert.AreEqual ("()", code, "#8");
 575                         }
 576                 }
 577
 578                 private string Generate (CodeExpression expression, StringWriter sw)
 579                 {
 580                         generator.GenerateCodeFromExpression (expression, sw, options);
 581                         return sw.ToString ();
 582                 }
 583         }
 584 }