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.IO;
  13 using System.Text;
  14
  15 using Microsoft.CSharp;
  16
  17 using NUnit.Framework;
  18
  19 namespace MonoTests.Microsoft.CSharp
  20 {
  21         /// <summary>
  22         /// Test ICodeGenerator's GenerateCodeFromExpression, along with a
  23         /// minimal set CodeDom components.
  24         /// </summary>
  25         [TestFixture]
  26         public class CodeGeneratorFromExpressionTest
  27         {
  28                 private CSharpCodeProvider provider;
  29                 private ICodeGenerator generator;
  30                 private CodeGeneratorOptions options;
  31
  32                 [SetUp]
  33                 public void SetUp ()
  34                 {
  35                         provider = new CSharpCodeProvider ();
  36                         generator = provider.CreateGenerator ();
  37                         options = new CodeGeneratorOptions ();
  38                 }
  39
  40                 [Test]
  41                 [ExpectedException (typeof (ArgumentException))]
  42                 public void DefaultExpressionTest ()
  43                 {
  44                         using (StringWriter sw = new StringWriter ()) {
  45                                 Generate (new CodeExpression (), sw);
  46                                 sw.Close ();
  47                         }
  48                 }
  49
  50                 [Test]
  51                 [ExpectedException (typeof (ArgumentNullException))]
  52                 public void NullExpressionTest ()
  53                 {
  54                         using (StringWriter sw = new StringWriter ()) {
  55                                 Generate (null, sw);
  56                         }
  57                 }
  58
  59                 [Test]
  60                 public void TypeReferenceExpressionTest ()
  61                 {
  62                         StringBuilder sb = new StringBuilder ();
  63
  64                         using (StringWriter sw = new StringWriter (sb)) {
  65                                 Assert.AreEqual ("bool", Generate (new CodeTypeReferenceExpression (typeof (bool)), sw), "#1");
  66                                 sb.Length = 0;
  67                                 Assert.AreEqual ("char", Generate (new CodeTypeReferenceExpression (typeof (char)), sw), "#2");
  68                                 sb.Length = 0;
  69                                 Assert.AreEqual (typeof(DateTime).FullName, Generate (new CodeTypeReferenceExpression (typeof (DateTime)), sw), "#3");
  70                                 sb.Length = 0;
  71                                 Assert.AreEqual ("short", Generate (new CodeTypeReferenceExpression (typeof (short)), sw), "#4");
  72                                 sb.Length = 0;
  73                                 Assert.AreEqual ("int", Generate (new CodeTypeReferenceExpression (typeof (int)), sw), "#5");
  74                                 sb.Length = 0;
  75                                 Assert.AreEqual ("long", Generate (new CodeTypeReferenceExpression (typeof (long)), sw), "#6");
  76                                 sb.Length = 0;
  77                                 Assert.AreEqual ("object", Generate (new CodeTypeReferenceExpression (typeof (object)), sw), "#7");
  78                                 sb.Length = 0;
  79                                 Assert.AreEqual ("void", Generate (new CodeTypeReferenceExpression (typeof (void)), sw), "#8");
  80                                 sb.Length = 0;
  81                                 Assert.AreEqual ("void", Generate (new CodeTypeReferenceExpression ((string) null), sw), "#9");
  82                                 sb.Length = 0;
  83                                 Assert.AreEqual ("void", Generate (new CodeTypeReferenceExpression (""), sw), "#10");
  84                                 sb.Length = 0;
  85 #if NET_2_0
  86                                 Assert.AreEqual ("byte", Generate (new CodeTypeReferenceExpression (typeof (byte)), sw), "#11");
  87                                 sb.Length = 0;
  88                                 Assert.AreEqual ("decimal", Generate (new CodeTypeReferenceExpression (typeof (decimal)), sw), "#12");
  89                                 sb.Length = 0;
  90                                 Assert.AreEqual ("double", Generate (new CodeTypeReferenceExpression (typeof (double)), sw), "#13");
  91                                 sb.Length = 0;
  92                                 Assert.AreEqual ("sbyte", Generate (new CodeTypeReferenceExpression (typeof (sbyte)), sw), "#14");
  93                                 sb.Length = 0;
  94                                 Assert.AreEqual ("ushort", Generate (new CodeTypeReferenceExpression (typeof (ushort)), sw), "#15");
  95                                 sb.Length = 0;
  96                                 Assert.AreEqual ("uint", Generate (new CodeTypeReferenceExpression (typeof (uint)), sw), "#16");
  97                                 sb.Length = 0;
  98                                 Assert.AreEqual ("ulong", Generate (new CodeTypeReferenceExpression (typeof (ulong)), sw), "#17");
  99                                 sb.Length = 0;
 100                                 Assert.AreEqual ("float", Generate (new CodeTypeReferenceExpression (typeof (float)), sw), "#18");
 101                                 sb.Length = 0;
 102 #else
 103                                 Assert.AreEqual (typeof (byte).FullName, Generate (new CodeTypeReferenceExpression (typeof (byte)), sw), "#19");
 104                                 sb.Length = 0;
 105                                 Assert.AreEqual (typeof (decimal).FullName, Generate (new CodeTypeReferenceExpression (typeof (decimal)), sw), "#20");
 106                                 sb.Length = 0;
 107                                 Assert.AreEqual (typeof (double).FullName, Generate (new CodeTypeReferenceExpression (typeof (double)), sw), "#21");
 108                                 sb.Length = 0;
 109                                 Assert.AreEqual (typeof (sbyte).FullName, Generate (new CodeTypeReferenceExpression (typeof (sbyte)), sw), "#22");
 110                                 sb.Length = 0;
 111                                 Assert.AreEqual (typeof (ushort).FullName, Generate (new CodeTypeReferenceExpression (typeof (ushort)), sw), "#23");
 112                                 sb.Length = 0;
 113                                 Assert.AreEqual (typeof (uint).FullName, Generate (new CodeTypeReferenceExpression (typeof (uint)), sw), "#24");
 114                                 sb.Length = 0;
 115                                 Assert.AreEqual (typeof (ulong).FullName, Generate (new CodeTypeReferenceExpression (typeof (ulong)), sw), "#25");
 116                                 sb.Length = 0;
 117                                 Assert.AreEqual (typeof (float).FullName, Generate (new CodeTypeReferenceExpression (typeof (float)), sw), "#26");
 118                                 sb.Length = 0;
 119 #endif
 120                                 sw.Close ();
 121                         }
 122                 }
 123
 124                 [Test]
 125                 public void PrimitiveExpressionTest ()
 126                 {
 127                         StringBuilder sb = new StringBuilder ();
 128
 129                         using (StringWriter sw = new StringWriter (sb)) {
 130                                 Assert.AreEqual ("null", Generate (new CodePrimitiveExpression (null), sw), "#1");
 131                                 sb.Length = 0;
 132                                 Assert.AreEqual ("\"AB\\\"C\"", Generate (new CodePrimitiveExpression ("AB\"C"), sw), "#2");
 133                                 sb.Length = 0;
 134                                 Assert.AreEqual ("5", Generate (new CodePrimitiveExpression ((byte) 5), sw), "#4");
 135                                 sb.Length = 0;
 136                                 Assert.AreEqual ("20", Generate (new CodePrimitiveExpression ((short) 20), sw), "#5");
 137                                 sb.Length = 0;
 138                                 Assert.AreEqual ("243", Generate (new CodePrimitiveExpression (243), sw), "#6");
 139                                 sb.Length = 0;
 140                                 Assert.AreEqual ("434343", Generate (new CodePrimitiveExpression ((long) 434343), sw), "#7");
 141                                 sb.Length = 0;
 142                                 Assert.AreEqual ("6.445F", Generate (new CodePrimitiveExpression ((float) 6.445), sw), "#8");
 143                                 sb.Length = 0;
 144                                 Assert.AreEqual ("5.76", Generate (new CodePrimitiveExpression ((double) 5.76), sw), "#9");
 145                                 sb.Length = 0;
 146                                 Assert.AreEqual ("7.667m", Generate (new CodePrimitiveExpression ((decimal) 7.667), sw), "#10");
 147                                 sb.Length = 0;
 148                                 Assert.AreEqual ("true", Generate (new CodePrimitiveExpression (true), sw), "#11");
 149                                 sb.Length = 0;
 150                                 Assert.AreEqual ("false", Generate (new CodePrimitiveExpression (false), sw), "#12");
 151                                 sw.Close ();
 152                         }
 153                 }
 154
 155                 [Test]
 156                 public void PrimitiveExpressionTest_Char ()
 157                 {
 158                         StringBuilder sb = new StringBuilder ();
 159
 160                         using (StringWriter sw = new StringWriter (sb)) {
 161                                 Assert.AreEqual ("'\\0'", Generate (new CodePrimitiveExpression ('\0'), sw), "#0");
 162                                 sb.Length = 0;
 163                                 Assert.AreEqual ("'\x01'", Generate (new CodePrimitiveExpression ('\x01'), sw), "#1");
 164                                 sb.Length = 0;
 165                                 Assert.AreEqual ("'\x02'", Generate (new CodePrimitiveExpression ('\x02'), sw), "#2");
 166                                 sb.Length = 0;
 167                                 Assert.AreEqual ("'\x03'", Generate (new CodePrimitiveExpression ('\x03'), sw), "#3");
 168                                 sb.Length = 0;
 169                                 Assert.AreEqual ("'\x04'", Generate (new CodePrimitiveExpression ('\x04'), sw), "#4");
 170                                 sb.Length = 0;
 171                                 Assert.AreEqual ("'\x05'", Generate (new CodePrimitiveExpression ('\x05'), sw), "#5");
 172                                 sb.Length = 0;
 173                                 Assert.AreEqual ("'\x06'", Generate (new CodePrimitiveExpression ('\x06'), sw), "#6");
 174                                 sb.Length = 0;
 175                                 Assert.AreEqual ("'\a'", Generate (new CodePrimitiveExpression ('\a'), sw), "#7");
 176                                 sb.Length = 0;
 177                                 Assert.AreEqual ("'\b'", Generate (new CodePrimitiveExpression ('\b'), sw), "#8");
 178                                 sb.Length = 0;
 179                                 Assert.AreEqual ("'\\t'", Generate (new CodePrimitiveExpression ('\t'), sw), "#9");
 180                                 sb.Length = 0;
 181                                 Assert.AreEqual ("'\\n'", Generate (new CodePrimitiveExpression ('\n'), sw), "#10");
 182                                 sb.Length = 0;
 183                                 Assert.AreEqual ("'\v'", Generate (new CodePrimitiveExpression ('\v'), sw), "#11");
 184                                 sb.Length = 0;
 185                                 Assert.AreEqual ("'\f'", Generate (new CodePrimitiveExpression ('\f'), sw), "#12");
 186                                 sb.Length = 0;
 187                                 Assert.AreEqual ("'\\r'", Generate (new CodePrimitiveExpression ('\r'), sw), "#13");
 188                                 sb.Length = 0;
 189                                 Assert.AreEqual ("'\x0E'", Generate (new CodePrimitiveExpression ('\x0E'), sw), "#14");
 190                                 sb.Length = 0;
 191                                 Assert.AreEqual ("'\x0F'", Generate (new CodePrimitiveExpression ('\x0F'), sw), "#15");
 192                                 sb.Length = 0;
 193                                 Assert.AreEqual ("'\x10'", Generate (new CodePrimitiveExpression ('\x10'), sw), "#16");
 194                                 sb.Length = 0;
 195                                 Assert.AreEqual ("'\x11'", Generate (new CodePrimitiveExpression ('\x11'), sw), "#17");
 196                                 sb.Length = 0;
 197                                 Assert.AreEqual ("'\x12'", Generate (new CodePrimitiveExpression ('\x12'), sw), "#18");
 198                                 sb.Length = 0;
 199                                 Assert.AreEqual ("'\x13'", Generate (new CodePrimitiveExpression ('\x13'), sw), "#19");
 200                                 sb.Length = 0;
 201                                 Assert.AreEqual ("'\x14'", Generate (new CodePrimitiveExpression ('\x14'), sw), "#20");
 202                                 sb.Length = 0;
 203                                 Assert.AreEqual ("'\x15'", Generate (new CodePrimitiveExpression ('\x15'), sw), "#21");
 204                                 sb.Length = 0;
 205                                 Assert.AreEqual ("'\x16'", Generate (new CodePrimitiveExpression ('\x16'), sw), "#22");
 206                                 sb.Length = 0;
 207                                 Assert.AreEqual ("'\x17'", Generate (new CodePrimitiveExpression ('\x17'), sw), "#23");
 208                                 sb.Length = 0;
 209                                 Assert.AreEqual ("'\x18'", Generate (new CodePrimitiveExpression ('\x18'), sw), "#24");
 210                                 sb.Length = 0;
 211                                 Assert.AreEqual ("'\x19'", Generate (new CodePrimitiveExpression ('\x19'), sw), "#25");
 212                                 sb.Length = 0;
 213                                 Assert.AreEqual ("'\x1A'", Generate (new CodePrimitiveExpression ('\x1A'), sw), "#26");
 214                                 sb.Length = 0;
 215                                 Assert.AreEqual ("'\x1B'", Generate (new CodePrimitiveExpression ('\x1B'), sw), "#27");
 216                                 sb.Length = 0;
 217                                 Assert.AreEqual ("'\x1C'", Generate (new CodePrimitiveExpression ('\x1C'), sw), "#28");
 218                                 sb.Length = 0;
 219                                 Assert.AreEqual ("'\x1D'", Generate (new CodePrimitiveExpression ('\x1D'), sw), "#29");
 220                                 sb.Length = 0;
 221                                 Assert.AreEqual ("'\x1E'", Generate (new CodePrimitiveExpression ('\x1E'), sw), "#30");
 222                                 sb.Length = 0;
 223                                 Assert.AreEqual ("'\x1F'", Generate (new CodePrimitiveExpression ('\x1F'), sw), "#31");
 224                                 sb.Length = 0;
 225                                 Assert.AreEqual ("'\x20'", Generate (new CodePrimitiveExpression ('\x20'), sw), "#32");
 226                                 sb.Length = 0;
 227                                 Assert.AreEqual ("'\x21'", Generate (new CodePrimitiveExpression ('\x21'), sw), "#33");
 228                                 sb.Length = 0;
 229                                 Assert.AreEqual ("'\\\"'", Generate (new CodePrimitiveExpression ('"'), sw), "#34");
 230                                 sb.Length = 0;
 231                                 Assert.AreEqual ("'\x23'", Generate (new CodePrimitiveExpression ('\x23'), sw), "#35");
 232                                 sb.Length = 0;
 233                                 Assert.AreEqual ("'\x24'", Generate (new CodePrimitiveExpression ('\x24'), sw), "#36");
 234                                 sb.Length = 0;
 235                                 Assert.AreEqual ("'\x25'", Generate (new CodePrimitiveExpression ('\x25'), sw), "#37");
 236                                 sb.Length = 0;
 237                                 Assert.AreEqual ("'\x26'", Generate (new CodePrimitiveExpression ('\x26'), sw), "#38");
 238                                 sb.Length = 0;
 239                                 Assert.AreEqual ("'\\''", Generate (new CodePrimitiveExpression ('\''), sw), "#39");
 240                                 sb.Length = 0;
 241 #if NET_2_0
 242                                 Assert.AreEqual ("'\\u2028'", Generate (new CodePrimitiveExpression ('\u2028'), sw), "#40");
 243 #else
 244                                 Assert.AreEqual ("'\\u8232'", Generate (new CodePrimitiveExpression ('\u2028'), sw), "#40");
 245 #endif
 246                                 sb.Length = 0;
 247 #if NET_2_0
 248                                 Assert.AreEqual ("'\\u2029'", Generate (new CodePrimitiveExpression ('\u2029'), sw), "#41");
 249 #else
 250                                 Assert.AreEqual ("'\\u8233'", Generate (new CodePrimitiveExpression ('\u2029'), sw), "#41");
 251 #endif
 252                                 sb.Length = 0;
 253                                 Assert.AreEqual ("'\u2030'", Generate (new CodePrimitiveExpression ('\u2030'), sw), "#42");
 254                                 sw.Close ();
 255                         }
 256                 }
 257
 258                 [Test]
 259 #if ONLY_1_1
 260                 [ExpectedException (typeof (ArgumentException))]
 261 #endif
 262                 public void PrimitiveExpressionTest_SByte ()
 263                 {
 264                         StringBuilder sb = new StringBuilder ();
 265
 266                         using (StringWriter sw = new StringWriter (sb)) {
 267                                 Assert.AreEqual ("5", Generate (new CodePrimitiveExpression ((sbyte) 5), sw));
 268                                 sw.Close ();
 269                         }
 270                 }
 271
 272                 [Test]
 273 #if ONLY_1_1
 274                 [ExpectedException (typeof (ArgumentException))]
 275 #endif
 276                 public void PrimitiveExpressionTest_UInt16 ()
 277                 {
 278                         StringBuilder sb = new StringBuilder ();
 279
 280                         using (StringWriter sw = new StringWriter (sb)) {
 281                                 Assert.AreEqual ("5", Generate (new CodePrimitiveExpression ((ushort) 5), sw));
 282                                 sw.Close ();
 283                         }
 284                 }
 285
 286                 [Test]
 287 #if ONLY_1_1
 288                 [ExpectedException (typeof (ArgumentException))]
 289 #endif
 290                 public void PrimitiveExpressionTest_UInt32 ()
 291                 {
 292                         StringBuilder sb = new StringBuilder ();
 293
 294                         using (StringWriter sw = new StringWriter (sb)) {
 295                                 Assert.AreEqual ("5u", Generate (new CodePrimitiveExpression ((uint) 5), sw));
 296                                 sw.Close ();
 297                         }
 298                 }
 299
 300                 [Test]
 301 #if ONLY_1_1
 302                 [ExpectedException (typeof (ArgumentException))]
 303 #endif
 304                 public void PrimitiveExpressionTest_UInt64 ()
 305                 {
 306                         StringBuilder sb = new StringBuilder ();
 307
 308                         using (StringWriter sw = new StringWriter (sb)) {
 309                                 Assert.AreEqual ("5ul", Generate (new CodePrimitiveExpression ((ulong) 5), sw));
 310                                 sw.Close ();
 311                         }
 312                 }
 313
 314                 [Test]
 315                 public void ParameterDeclarationExpressionTest ()
 316                 {
 317                         CodeParameterDeclarationExpression cpde = null;
 318
 319                         StringBuilder sb = new StringBuilder ();
 320
 321                         using (StringWriter sw = new StringWriter (sb)) {
 322                                 cpde = new CodeParameterDeclarationExpression ();
 323                                 Assert.AreEqual ("void ", Generate (cpde, sw), "#1");
 324                                 sb.Length = 0;
 325
 326                                 cpde = new CodeParameterDeclarationExpression ((string) null,
 327                                         (string) null);
 328                                 Assert.AreEqual ("void ", Generate (cpde, sw), "#2");
 329                                 sb.Length = 0;
 330
 331                                 cpde = new CodeParameterDeclarationExpression ("A", (string) null);
 332                                 Assert.AreEqual ("A ", Generate (cpde, sw), "#4");
 333                                 sb.Length = 0;
 334
 335                                 cpde = new CodeParameterDeclarationExpression ((string) null, "B");
 336                                 Assert.AreEqual ("void B", Generate (cpde, sw), "#4");
 337                                 sb.Length = 0;
 338
 339                                 cpde = new CodeParameterDeclarationExpression ("A", "B");
 340                                 Assert.AreEqual ("A B", Generate (cpde, sw), "#5");
 341                                 sb.Length = 0;
 342
 343                                 cpde.Direction = FieldDirection.Out;
 344                                 Assert.AreEqual ("out A B", Generate (cpde, sw), "#6");
 345                                 sb.Length = 0;
 346
 347                                 cpde.Direction = FieldDirection.Ref;
 348                                 Assert.AreEqual ("ref A B", Generate (cpde, sw), "#7");
 349                                 sb.Length = 0;
 350                         }
 351                 }
 352
 353                 private string Generate (CodeExpression expression, StringWriter sw)
 354                 {
 355                         generator.GenerateCodeFromExpression (expression, sw, options);
 356                         return sw.ToString ();
 357                 }
 358         }
 359 }