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 #if NET_2_0
  90                                 Assert.AreEqual ("SByte", Generate (new CodeTypeReferenceExpression (typeof (sbyte)), sw), "#15");
  91                                 sb.Length = 0;
  92                                 Assert.AreEqual ("UShort", Generate (new CodeTypeReferenceExpression (typeof (ushort)), sw), "#16");
  93                                 sb.Length = 0;
  94                                 Assert.AreEqual ("UInteger", Generate (new CodeTypeReferenceExpression (typeof (uint)), sw), "#17");
  95                                 sb.Length = 0;
  96                                 Assert.AreEqual ("ULong", Generate (new CodeTypeReferenceExpression (typeof (ulong)), sw), "#18");
  97                                 sb.Length = 0;
  98 #else
  99                                 Assert.AreEqual (typeof (sbyte).FullName, Generate (new CodeTypeReferenceExpression (typeof (sbyte)), sw), "#19");
 100                                 sb.Length = 0;
 101                                 Assert.AreEqual (typeof(ushort).FullName, Generate (new CodeTypeReferenceExpression (typeof (ushort)), sw), "#20");
 102                                 sb.Length = 0;
 103                                 Assert.AreEqual (typeof(uint).FullName, Generate (new CodeTypeReferenceExpression (typeof (uint)), sw), "#21");
 104                                 sb.Length = 0;
 105                                 Assert.AreEqual (typeof(ulong).FullName, Generate (new CodeTypeReferenceExpression (typeof (ulong)), sw), "#22");
 106                                 sb.Length = 0;
 107 #endif
 108                                 sw.Close ();
 109                         }
 110                 }
 111
 112                 [Test]
 113                 public void PrimitiveExpressionTest ()
 114                 {
 115                         StringBuilder sb = new StringBuilder ();
 116
 117                         using (StringWriter sw = new StringWriter (sb)) {
 118                                 Assert.AreEqual ("Nothing", Generate (new CodePrimitiveExpression (null), sw), "#1");
 119                                 sb.Length = 0;
 120                                 Assert.AreEqual ("\"AB\"\"C\"", Generate (new CodePrimitiveExpression ("AB\"C"), sw), "#2");
 121                                 sb.Length = 0;
 122                                 Assert.AreEqual ("5", Generate (new CodePrimitiveExpression ((byte) 5), sw), "#4");
 123                                 sb.Length = 0;
 124                                 Assert.AreEqual ("20", Generate (new CodePrimitiveExpression ((short) 20), sw), "#5");
 125                                 sb.Length = 0;
 126                                 Assert.AreEqual ("243", Generate (new CodePrimitiveExpression (243), sw), "#6");
 127                                 sb.Length = 0;
 128                                 Assert.AreEqual ("434343", Generate (new CodePrimitiveExpression ((long) 434343), sw), "#7");
 129                                 sb.Length = 0;
 130                                 Assert.AreEqual ("6.445!", Generate (new CodePrimitiveExpression ((float) 6.445), sw), "#8");
 131                                 sb.Length = 0;
 132                                 Assert.AreEqual ("5.76", Generate (new CodePrimitiveExpression ((double) 5.76), sw), "#9");
 133                                 sb.Length = 0;
 134                                 Assert.AreEqual ("7.667", Generate (new CodePrimitiveExpression ((decimal) 7.667), sw), "#10");
 135                                 sb.Length = 0;
 136                                 Assert.AreEqual ("true", Generate (new CodePrimitiveExpression (true), sw), "#11");
 137                                 sb.Length = 0;
 138                                 Assert.AreEqual ("false", Generate (new CodePrimitiveExpression (false), sw), "#12");
 139                                 sw.Close ();
 140                         }
 141                 }
 142
 143                 [Test]
 144                 public void PrimitiveExpressionTest_Char ()
 145                 {
 146 #if NET_2_0
 147                         string vbNs = "Global.Microsoft.VisualBasic";
 148 #else
 149                         string vbNs = "Microsoft.VisualBasic";
 150 #endif
 151                         StringBuilder sb = new StringBuilder ();
 152
 153                         using (StringWriter sw = new StringWriter (sb)) {
 154                                 Assert.AreEqual (vbNs + ".ChrW(0)", Generate (new CodePrimitiveExpression ('\0'), sw), "#0");
 155                                 sb.Length = 0;
 156                                 Assert.AreEqual (vbNs + ".ChrW(1)", Generate (new CodePrimitiveExpression ('\x01'), sw), "#1");
 157                                 sb.Length = 0;
 158                                 Assert.AreEqual (vbNs + ".ChrW(2)", Generate (new CodePrimitiveExpression ('\x02'), sw), "#2");
 159                                 sb.Length = 0;
 160                                 Assert.AreEqual (vbNs + ".ChrW(3)", Generate (new CodePrimitiveExpression ('\x03'), sw), "#3");
 161                                 sb.Length = 0;
 162                                 Assert.AreEqual (vbNs + ".ChrW(4)", Generate (new CodePrimitiveExpression ('\x04'), sw), "#4");
 163                                 sb.Length = 0;
 164                                 Assert.AreEqual (vbNs + ".ChrW(5)", Generate (new CodePrimitiveExpression ('\x05'), sw), "#5");
 165                                 sb.Length = 0;
 166                                 Assert.AreEqual (vbNs + ".ChrW(6)", Generate (new CodePrimitiveExpression ('\x06'), sw), "#6");
 167                                 sb.Length = 0;
 168                                 Assert.AreEqual (vbNs + ".ChrW(7)", Generate (new CodePrimitiveExpression ('\a'), sw), "#7");
 169                                 sb.Length = 0;
 170                                 Assert.AreEqual (vbNs + ".ChrW(8)", Generate (new CodePrimitiveExpression ('\b'), sw), "#8");
 171                                 sb.Length = 0;
 172                                 Assert.AreEqual (vbNs + ".ChrW(9)", Generate (new CodePrimitiveExpression ('\t'), sw), "#9");
 173                                 sb.Length = 0;
 174                                 Assert.AreEqual (vbNs + ".ChrW(10)", Generate (new CodePrimitiveExpression ('\n'), sw), "#10");
 175                                 sb.Length = 0;
 176                                 Assert.AreEqual (vbNs + ".ChrW(11)", Generate (new CodePrimitiveExpression ('\v'), sw), "#11");
 177                                 sb.Length = 0;
 178                                 Assert.AreEqual (vbNs + ".ChrW(12)", Generate (new CodePrimitiveExpression ('\f'), sw), "#12");
 179                                 sb.Length = 0;
 180                                 Assert.AreEqual (vbNs + ".ChrW(13)", Generate (new CodePrimitiveExpression ('\r'), sw), "#13");
 181                                 sb.Length = 0;
 182                                 Assert.AreEqual (vbNs + ".ChrW(14)", Generate (new CodePrimitiveExpression ('\x0E'), sw), "#14");
 183                                 sb.Length = 0;
 184                                 Assert.AreEqual (vbNs + ".ChrW(15)", Generate (new CodePrimitiveExpression ('\x0F'), sw), "#15");
 185                                 sb.Length = 0;
 186                                 Assert.AreEqual (vbNs + ".ChrW(16)", Generate (new CodePrimitiveExpression ('\x10'), sw), "#16");
 187                                 sb.Length = 0;
 188                                 Assert.AreEqual (vbNs + ".ChrW(17)", Generate (new CodePrimitiveExpression ('\x11'), sw), "#17");
 189                                 sb.Length = 0;
 190                                 Assert.AreEqual (vbNs + ".ChrW(18)", Generate (new CodePrimitiveExpression ('\x12'), sw), "#18");
 191                                 sb.Length = 0;
 192                                 Assert.AreEqual (vbNs + ".ChrW(19)", Generate (new CodePrimitiveExpression ('\x13'), sw), "#19");
 193                                 sb.Length = 0;
 194                                 Assert.AreEqual (vbNs + ".ChrW(20)", Generate (new CodePrimitiveExpression ('\x14'), sw), "#20");
 195                                 sb.Length = 0;
 196                                 Assert.AreEqual (vbNs + ".ChrW(21)", Generate (new CodePrimitiveExpression ('\x15'), sw), "#21");
 197                                 sb.Length = 0;
 198                                 Assert.AreEqual (vbNs + ".ChrW(22)", Generate (new CodePrimitiveExpression ('\x16'), sw), "#22");
 199                                 sb.Length = 0;
 200                                 Assert.AreEqual (vbNs + ".ChrW(23)", Generate (new CodePrimitiveExpression ('\x17'), sw), "#23");
 201                                 sb.Length = 0;
 202                                 Assert.AreEqual (vbNs + ".ChrW(24)", Generate (new CodePrimitiveExpression ('\x18'), sw), "#24");
 203                                 sb.Length = 0;
 204                                 Assert.AreEqual (vbNs + ".ChrW(25)", Generate (new CodePrimitiveExpression ('\x19'), sw), "#25");
 205                                 sb.Length = 0;
 206                                 Assert.AreEqual (vbNs + ".ChrW(26)", Generate (new CodePrimitiveExpression ('\x1A'), sw), "#26");
 207                                 sb.Length = 0;
 208                                 Assert.AreEqual (vbNs + ".ChrW(27)", Generate (new CodePrimitiveExpression ('\x1B'), sw), "#27");
 209                                 sb.Length = 0;
 210                                 Assert.AreEqual (vbNs + ".ChrW(28)", Generate (new CodePrimitiveExpression ('\x1C'), sw), "#28");
 211                                 sb.Length = 0;
 212                                 Assert.AreEqual (vbNs + ".ChrW(29)", Generate (new CodePrimitiveExpression ('\x1D'), sw), "#29");
 213                                 sb.Length = 0;
 214                                 Assert.AreEqual (vbNs + ".ChrW(30)", Generate (new CodePrimitiveExpression ('\x1E'), sw), "#30");
 215                                 sb.Length = 0;
 216                                 Assert.AreEqual (vbNs + ".ChrW(31)", Generate (new CodePrimitiveExpression ('\x1F'), sw), "#31");
 217                                 sb.Length = 0;
 218                                 Assert.AreEqual (vbNs + ".ChrW(32)", Generate (new CodePrimitiveExpression ('\x20'), sw), "#32");
 219                                 sb.Length = 0;
 220                                 Assert.AreEqual (vbNs + ".ChrW(33)", Generate (new CodePrimitiveExpression ('\x21'), sw), "#33");
 221                                 sb.Length = 0;
 222                                 Assert.AreEqual (vbNs + ".ChrW(34)", Generate (new CodePrimitiveExpression ('"'), sw), "#34");
 223                                 sb.Length = 0;
 224                                 Assert.AreEqual (vbNs + ".ChrW(35)", Generate (new CodePrimitiveExpression ('\x23'), sw), "#35");
 225                                 sb.Length = 0;
 226                                 Assert.AreEqual (vbNs + ".ChrW(36)", Generate (new CodePrimitiveExpression ('\x24'), sw), "#36");
 227                                 sb.Length = 0;
 228                                 Assert.AreEqual (vbNs + ".ChrW(37)", Generate (new CodePrimitiveExpression ('\x25'), sw), "#37");
 229                                 sb.Length = 0;
 230                                 Assert.AreEqual (vbNs + ".ChrW(38)", Generate (new CodePrimitiveExpression ('\x26'), sw), "#38");
 231                                 sb.Length = 0;
 232                                 Assert.AreEqual (vbNs + ".ChrW(39)", Generate (new CodePrimitiveExpression ('\''), sw), "#39");
 233                                 sb.Length = 0;
 234                                 Assert.AreEqual (vbNs + ".ChrW(8232)", Generate (new CodePrimitiveExpression ('\u2028'), sw), "#40");
 235                                 sb.Length = 0;
 236                                 Assert.AreEqual (vbNs + ".ChrW(8233)", Generate (new CodePrimitiveExpression ('\u2029'), sw), "#41");
 237                                 sb.Length = 0;
 238                                 Assert.AreEqual (vbNs + ".ChrW(8240)", Generate (new CodePrimitiveExpression ('\u2030'), sw), "#42");
 239                                 sw.Close ();
 240                         }
 241                 }
 242
 243                 [Test]
 244 #if ONLY_1_1
 245                 [ExpectedException (typeof (ArgumentException))]
 246 #endif
 247                 public void PrimitiveExpressionTest_SByte ()
 248                 {
 249                         StringBuilder sb = new StringBuilder ();
 250
 251                         using (StringWriter sw = new StringWriter (sb)) {
 252                                 Assert.AreEqual ("CSByte(5)", Generate (new CodePrimitiveExpression ((sbyte) 5), sw));
 253                                 sw.Close ();
 254                         }
 255                 }
 256
 257                 [Test]
 258 #if ONLY_1_1
 259                 [ExpectedException (typeof (ArgumentException))]
 260 #endif
 261                 public void PrimitiveExpressionTest_UInt16 ()
 262                 {
 263                         StringBuilder sb = new StringBuilder ();
 264
 265                         using (StringWriter sw = new StringWriter (sb)) {
 266                                 Assert.AreEqual ("5US", Generate (new CodePrimitiveExpression ((ushort) 5), sw));
 267                                 sw.Close ();
 268                         }
 269                 }
 270
 271                 [Test]
 272 #if ONLY_1_1
 273                 [ExpectedException (typeof (ArgumentException))]
 274 #endif
 275                 public void PrimitiveExpressionTest_UInt32 ()
 276                 {
 277                         StringBuilder sb = new StringBuilder ();
 278
 279                         using (StringWriter sw = new StringWriter (sb)) {
 280                                 Assert.AreEqual ("5UI", Generate (new CodePrimitiveExpression ((uint) 5), sw));
 281                                 sw.Close ();
 282                         }
 283                 }
 284
 285                 [Test]
 286 #if ONLY_1_1
 287                 [ExpectedException (typeof (ArgumentException))]
 288 #endif
 289                 public void PrimitiveExpressionTest_UInt64 ()
 290                 {
 291                         StringBuilder sb = new StringBuilder ();
 292
 293                         using (StringWriter sw = new StringWriter (sb)) {
 294                                 Assert.AreEqual ("5UL", Generate (new CodePrimitiveExpression ((ulong) 5), sw));
 295                                 sw.Close ();
 296                         }
 297                 }
 298
 299                 [Test]
 300                 public void ParameterDeclarationExpressionTest ()
 301                 {
 302                         CodeParameterDeclarationExpression cpde = null;
 303
 304                         StringBuilder sb = new StringBuilder();
 305
 306                         using (StringWriter sw = new StringWriter (sb)) {
 307                                 cpde = new CodeParameterDeclarationExpression ();
 308 #if NET_2_0
 309                                 Assert.AreEqual ("ByVal __exception As System.Void", Generate (cpde, sw), "#1");
 310 #else
 311                                 Assert.AreEqual ("ByVal  As System.Void", Generate (cpde, sw), "#1");
 312 #endif
 313                                 sb.Length = 0;
 314
 315                                 cpde = new CodeParameterDeclarationExpression ((string) null,
 316                                         (string) null);
 317 #if NET_2_0
 318                                 Assert.AreEqual ("ByVal __exception As System.Void", Generate (cpde, sw), "#2");
 319 #else
 320                                 Assert.AreEqual ("ByVal  As System.Void", Generate (cpde, sw), "#2");
 321 #endif
 322                                 sb.Length = 0;
 323
 324                                 cpde = new CodeParameterDeclarationExpression ("A", (string) null);
 325 #if NET_2_0
 326                                 Assert.AreEqual ("ByVal __exception As A", Generate (cpde, sw), "#3");
 327 #else
 328                                 Assert.AreEqual ("ByVal  As A", Generate (cpde, sw), "#3");
 329 #endif
 330                                 sb.Length = 0;
 331
 332                                 cpde = new CodeParameterDeclarationExpression ((string) null, "B");
 333                                 Assert.AreEqual ("ByVal B As System.Void", Generate (cpde, sw), "#4");
 334                                 sb.Length = 0;
 335
 336                                 cpde = new CodeParameterDeclarationExpression ("A", "B");
 337                                 Assert.AreEqual ("ByVal B As A", Generate (cpde, sw), "#5");
 338                                 sb.Length = 0;
 339
 340                                 cpde.Direction = FieldDirection.Out;
 341                                 Assert.AreEqual ("ByRef B As A", Generate (cpde, sw), "#6");
 342                                 sb.Length = 0;
 343
 344                                 cpde.Direction = FieldDirection.Ref;
 345                                 Assert.AreEqual ("ByRef B As A", Generate (cpde, sw), "#7");
 346                                 sb.Length = 0;
 347                         }
 348                 }
 349
 350                 private string Generate (CodeExpression expression, StringWriter sw)
 351                 {
 352                         generator.GenerateCodeFromExpression (expression, sw, options);
 353                         return sw.ToString ();
 354                 }
 355         }
 356 }