mcs/class/System/Test/System.ComponentModel/EnumConverterTests.cs

   1 //
   2 // System.ComponentModel.EnumConverter test cases
   3 //
   4 // Authors:
   5 //      Gert Driesen (drieseng@users.sourceforge.net)
   6 //
   7 // (c) 2007 Gert Driesen
   8 //
   9
  10 using System;
  11 using System.ComponentModel;
  12 using System.ComponentModel.Design.Serialization;
  13 using System.Globalization;
  14 using System.Reflection;
  15
  16 using NUnit.Framework;
  17
  18 namespace MonoTests.System.ComponentModel
  19 {
  20         [TestFixture]
  21         public class EnumConverterTests
  22         {
  23                 [Test]
  24                 public void CanConvertFrom ()
  25                 {
  26                         EnumConverter converter = new EnumConverter (typeof (E));
  27                         Assert.IsTrue (converter.CanConvertFrom (typeof (string)), "#A1");
  28                         Assert.IsFalse (converter.CanConvertFrom (typeof (Enum)), "#A2");
  29                         Assert.IsFalse (converter.CanConvertFrom (typeof (object)), "#A3");
  30                         Assert.IsFalse (converter.CanConvertFrom (typeof (int)), "#A4");
  31                         Assert.IsTrue (converter.CanConvertFrom (typeof (InstanceDescriptor)), "#A5");
  32                         Assert.IsFalse (converter.CanConvertFrom (typeof (string [])), "#A6");
  33 #if NET_2_0
  34                         Assert.IsTrue (converter.CanConvertFrom (typeof (Enum [])), "#A7");
  35 #else
  36                         Assert.IsFalse (converter.CanConvertFrom (typeof (Enum [])), "#A7");
  37 #endif
  38
  39                         converter = new EnumConverter (typeof (E2));
  40                         Assert.IsTrue (converter.CanConvertFrom (typeof (string)), "#B1");
  41                         Assert.IsFalse (converter.CanConvertFrom (typeof (Enum)), "#B2");
  42                         Assert.IsFalse (converter.CanConvertFrom (typeof (object)), "#B3");
  43                         Assert.IsFalse (converter.CanConvertFrom (typeof (int)), "#B4");
  44                         Assert.IsTrue (converter.CanConvertFrom (typeof (InstanceDescriptor)), "#B5");
  45                         Assert.IsFalse (converter.CanConvertFrom (typeof (string [])), "#B6");
  46 #if NET_2_0
  47                         Assert.IsTrue (converter.CanConvertFrom (typeof (Enum [])), "#B7");
  48 #else
  49                         Assert.IsFalse (converter.CanConvertFrom (typeof (Enum [])), "#B7");
  50 #endif
  51                 }
  52
  53                 [Test]
  54                 public void CanConvertTo ()
  55                 {
  56                         EnumConverter converter = new EnumConverter (typeof (E));
  57                         Assert.IsTrue (converter.CanConvertTo (typeof (string)), "#A1");
  58                         Assert.IsFalse (converter.CanConvertTo (typeof (Enum)), "#A2");
  59                         Assert.IsFalse (converter.CanConvertTo (typeof (object)), "#A3");
  60                         Assert.IsFalse (converter.CanConvertTo (typeof (int)), "#A4");
  61                         Assert.IsTrue (converter.CanConvertTo (typeof (InstanceDescriptor)), "#A5");
  62                         Assert.IsFalse (converter.CanConvertTo (typeof (string [])), "#A6");
  63 #if NET_2_0
  64                         Assert.IsTrue (converter.CanConvertTo (typeof (Enum [])), "#A7");
  65 #else
  66                         Assert.IsFalse (converter.CanConvertTo (typeof (Enum [])), "#A7");
  67 #endif
  68
  69                         converter = new EnumConverter (typeof (E2));
  70                         Assert.IsTrue (converter.CanConvertTo (typeof (string)), "#B1");
  71                         Assert.IsFalse (converter.CanConvertTo (typeof (Enum)), "#B2");
  72                         Assert.IsFalse (converter.CanConvertTo (typeof (object)), "#B3");
  73                         Assert.IsFalse (converter.CanConvertTo (typeof (object)), "#B4");
  74                         Assert.IsTrue (converter.CanConvertTo (typeof (InstanceDescriptor)), "#B5");
  75                         Assert.IsFalse (converter.CanConvertTo (typeof (string [])), "#B6");
  76 #if NET_2_0
  77                         Assert.IsTrue (converter.CanConvertTo (typeof (Enum [])), "#B7");
  78 #else
  79                         Assert.IsFalse (converter.CanConvertTo (typeof (Enum [])), "#B7");
  80 #endif
  81                 }
  82
  83                 [Test]
  84                 public void ConvertFrom_Null ()
  85                 {
  86                         EnumConverter converter = new EnumConverter (typeof (E));
  87                         try {
  88                                 converter.ConvertFrom (null, CultureInfo.InvariantCulture, null);
  89                                 Assert.Fail ("#1");
  90                         } catch (NotSupportedException ex) {
  91                                 // EnumConverter cannot convert from (null)
  92                                 Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
  93                                 Assert.IsNull (ex.InnerException, "#3");
  94                                 Assert.IsNotNull (ex.Message, "#4");
  95                                 Assert.IsTrue (ex.Message.IndexOf (typeof (EnumConverter).Name) != -1, "#5");
  96                                 Assert.IsTrue (ex.Message.IndexOf ("(null)") != -1, "#6");
  97                         }
  98                 }
  99
 100 #if NET_2_0
 101                 [Test]
 102                 public void ConvertFrom_EnumArray ()
 103                 {
 104                         EnumConverter converter = new EnumConverter (typeof (E));
 105                         Assert.AreEqual (E.Aa, converter.ConvertFrom (null,
 106                                 CultureInfo.InvariantCulture,
 107                                 (Enum []) new Enum [] { E.Aa }), "#A1");
 108                         Assert.AreEqual ((E) 8, converter.ConvertFrom (null,
 109                                 CultureInfo.InvariantCulture,
 110                                 (Enum []) new Enum [] { E.Aa, E2.Dd }), "#A2");
 111                         Assert.AreEqual ((E) 958, converter.ConvertFrom (null,
 112                                 CultureInfo.InvariantCulture,
 113                                 (Enum []) new Enum [] { (E2) 444, (E) 666 }), "#A3");
 114                         Assert.AreEqual ((E) 0, converter.ConvertFrom (null,
 115                                 CultureInfo.InvariantCulture,
 116                                 (Enum []) new Enum [0]), "#A4");
 117
 118                         converter = new EnumConverter (typeof (E2));
 119                         Assert.AreEqual ((E2) 0, converter.ConvertFrom (null,
 120                                 CultureInfo.InvariantCulture,
 121                                 (Enum []) new Enum [] { E.Aa }), "#B1");
 122                         Assert.AreEqual (E2.Dd, converter.ConvertFrom (null,
 123                                 CultureInfo.InvariantCulture,
 124                                 (Enum []) new Enum [] { E.Aa, E2.Dd }), "#B2");
 125                         Assert.AreEqual ((E2) 958, converter.ConvertFrom (null,
 126                                 CultureInfo.InvariantCulture,
 127                                 (Enum []) new Enum [] { (E2) 444, (E) 666 }), "#B3");
 128                         Assert.AreEqual ((E2) 0, converter.ConvertFrom (null,
 129                                 CultureInfo.InvariantCulture,
 130                                 (Enum []) new Enum [0]), "#B4");
 131                         Assert.AreEqual (E2.Bb | E2.Dd, converter.ConvertFrom (null,
 132                                 CultureInfo.InvariantCulture,
 133                                 (Enum []) new Enum [] { E2.Bb, E2.Dd }), "#B5");
 134                 }
 135 #endif
 136
 137                 [Test]
 138                 public void ConvertFrom_String ()
 139                 {
 140                         EnumConverter converter = new EnumConverter (typeof (E));
 141                         Assert.AreEqual (E.Bb, converter.ConvertFrom (null, CultureInfo.InvariantCulture, "Bb"), "#A1");
 142                         Assert.AreEqual (E.Cc, converter.ConvertFrom (null, CultureInfo.InvariantCulture, "2"), "#A2");
 143                         Assert.AreEqual (E.Bb, converter.ConvertFrom (null, CultureInfo.InvariantCulture, " Bb "), "#A3");
 144                         Assert.AreEqual (E.Dd, converter.ConvertFrom (null, CultureInfo.InvariantCulture, " 3 "), "#A4");
 145                         Assert.AreEqual ((E) 666, converter.ConvertFrom (null, CultureInfo.InvariantCulture, "666"), "#A5");
 146                         Assert.AreEqual (E.Dd, converter.ConvertFrom (null, CultureInfo.InvariantCulture, "Bb,Dd"), "#A6");
 147                         Assert.AreEqual (E.Dd, converter.ConvertFrom (null, CultureInfo.InvariantCulture, "Dd,Bb"), "#A7");
 148                         Assert.AreEqual (E.Bb, converter.ConvertFrom (null, CultureInfo.InvariantCulture, "Aa,Bb"), "#A8");
 149
 150                         try {
 151                                 converter.ConvertFrom (null, CultureInfo.InvariantCulture, string.Empty);
 152                                 Assert.Fail ("#B1");
 153 #if NET_2_0
 154                         } catch (FormatException ex) {
 155                                 //  is not a valid value for E
 156                                 Assert.AreEqual (typeof (FormatException), ex.GetType (), "#B2");
 157                                 Assert.IsNotNull (ex.InnerException, "#B3");
 158                                 Assert.AreEqual (typeof (ArgumentException), ex.InnerException.GetType (), "#B4");
 159                                 Assert.IsNotNull (ex.Message, "#B5");
 160                                 Assert.IsTrue (ex.Message.IndexOf ("E") != -1, "#B6");
 161
 162                                 // Must specify valid information for parsing in the string
 163                                 ArgumentException inner = (ArgumentException) ex.InnerException;
 164                                 Assert.IsNull (inner.InnerException, "#B7");
 165                                 Assert.IsNotNull (inner.Message, "#B8");
 166                         }
 167 #else
 168                         } catch (ArgumentException ex) {
 169                                 // Must specify valid information for parsing in the string
 170                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 171                                 Assert.IsNull (ex.InnerException, "#B3");
 172                                 Assert.IsNotNull (ex.Message, "#B4");
 173                         }
 174 #endif
 175
 176                         try {
 177                                 converter.ConvertFrom (null, CultureInfo.InvariantCulture, "YY");
 178                                 Assert.Fail ("#C1");
 179 #if NET_2_0
 180                         } catch (FormatException ex) {
 181                                 // YY is not a valid value for E
 182                                 Assert.AreEqual (typeof (FormatException), ex.GetType (), "#C2");
 183                                 Assert.IsNotNull (ex.InnerException, "#C3");
 184                                 Assert.AreEqual (typeof (ArgumentException), ex.InnerException.GetType (), "#C4");
 185                                 Assert.IsNotNull (ex.Message, "#C5");
 186                                 Assert.IsTrue (ex.Message.IndexOf ("YY") != -1, "#C6");
 187                                 Assert.IsTrue (ex.Message.IndexOf ("E") != -1, "#C7");
 188
 189                                 // Requested value YY was not found
 190                                 ArgumentException inner = (ArgumentException) ex.InnerException;
 191                                 //Assert.IsNull (inner.InnerException, "#C8");
 192                                 Assert.IsNotNull (inner.Message, "#C9");
 193                                 Assert.IsTrue (inner.Message.IndexOf ("YY") != -1, "#C10");
 194                                 Assert.IsNull (inner.ParamName, "#C11");
 195                         }
 196 #else
 197                         } catch (ArgumentException ex) {
 198                                 // Requested value YY was not found
 199                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
 200                                 //Assert.IsNull (ex.InnerException, "#C3");
 201                                 Assert.IsNotNull (ex.Message, "#C4");
 202                                 Assert.IsTrue (ex.Message.IndexOf ("YY") != -1, "#C5");
 203                                 Assert.IsNull (ex.ParamName, "#C6");
 204                         }
 205 #endif
 206                 }
 207
 208                 [Test]
 209 #if TARGET_JVM
 210                 [NUnit.Framework.Category("NotWorking")]
 211 #endif
 212                 public void ConvertFrom_String_Flags ()
 213                 {
 214                         EnumConverter converter = new EnumConverter (typeof (E2));
 215                         Assert.AreEqual (E2.Cc, converter.ConvertFrom (null, CultureInfo.InvariantCulture, "Cc"), "#B1");
 216                         Assert.AreEqual (E2.Dd, converter.ConvertFrom (null, CultureInfo.InvariantCulture, "8"), "#B2");
 217                         Assert.AreEqual (E2.Cc | E2.Dd, converter.ConvertFrom (null, CultureInfo.InvariantCulture, "Cc,Dd"), "#B3");
 218                         Assert.AreEqual (E2.Aa | E2.Bb, converter.ConvertFrom (null, CultureInfo.InvariantCulture, "3"), "#B4");
 219                         Assert.AreEqual (E2.Bb | E2.Cc, converter.ConvertFrom (null, CultureInfo.InvariantCulture, "2,4"), "#B5");
 220                         Assert.AreEqual (E2.Aa | E2.Dd, converter.ConvertFrom (null, CultureInfo.InvariantCulture, " 1 , 8 "), "#B5");
 221                         Assert.AreEqual ((E2) 666, converter.ConvertFrom (null, CultureInfo.InvariantCulture, "666"), "#B6");
 222                         Assert.AreEqual (E2.Cc | E2.Dd, converter.ConvertFrom (null, CultureInfo.InvariantCulture, " Dd , Cc "), "#B7");
 223                         Assert.AreEqual (E2.Bb, converter.ConvertFrom (null, CultureInfo.InvariantCulture, " Bb "), "#B8");
 224                         Assert.AreEqual (E2.Aa | E2.Bb, converter.ConvertFrom (null, CultureInfo.InvariantCulture, " 3 "), "#B9");
 225
 226                         try {
 227                                 converter.ConvertFrom (null, CultureInfo.InvariantCulture, string.Empty);
 228                                 Assert.Fail ("#B1");
 229 #if NET_2_0
 230                         } catch (FormatException ex) {
 231                                 //  is not a valid value for E2
 232                                 Assert.AreEqual (typeof (FormatException), ex.GetType (), "#B2");
 233                                 Assert.IsNotNull (ex.InnerException, "#B3");
 234                                 Assert.AreEqual (typeof (ArgumentException), ex.InnerException.GetType (), "#B4");
 235                                 Assert.IsNotNull (ex.Message, "#B5");
 236                                 Assert.IsTrue (ex.Message.IndexOf ("E2") != -1, "#B6");
 237
 238                                 // Must specify valid information for parsing in the string
 239                                 ArgumentException inner = (ArgumentException) ex.InnerException;
 240                                 Assert.IsNull (inner.InnerException, "#B7");
 241                                 Assert.IsNotNull (inner.Message, "#B8");
 242                         }
 243 #else
 244                         } catch (ArgumentException ex) {
 245                                 // Must specify valid information for parsing in the string
 246                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 247                                 Assert.IsNull (ex.InnerException, "#B3");
 248                                 Assert.IsNotNull (ex.Message, "#B4");
 249                         }
 250 #endif
 251
 252                         try {
 253                                 converter.ConvertFrom (null, CultureInfo.InvariantCulture, "Aa Bb");
 254                                 Assert.Fail ("#C1");
 255 #if NET_2_0
 256                         } catch (FormatException ex) {
 257                                 // Aa Bb is not a valid value for E2
 258                                 Assert.AreEqual (typeof (FormatException), ex.GetType (), "#C2");
 259                                 Assert.IsNotNull (ex.InnerException, "#C3");
 260                                 Assert.AreEqual (typeof (ArgumentException), ex.InnerException.GetType (), "#C4");
 261                                 Assert.IsNotNull (ex.Message, "#C5");
 262                                 Assert.IsTrue (ex.Message.IndexOf ("Aa Bb") != -1, "#C6");
 263                                 Assert.IsTrue (ex.Message.IndexOf ("E2") != -1, "#C7");
 264
 265                                 // Requested value Aa Bb was not found
 266                                 ArgumentException inner = (ArgumentException) ex.InnerException;
 267                                 Assert.IsNotNull (inner.Message, "#C9");
 268                                 Assert.IsTrue (inner.Message.IndexOf ("Aa Bb") != -1, "#C10");
 269                                 Assert.IsNull (inner.ParamName, "#C11");
 270                         }
 271 #else
 272                         } catch (ArgumentException ex) {
 273                                 // Requested value Aa Bb was not found
 274                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
 275                                 Assert.IsNotNull (ex.Message, "#C3");
 276                                 Assert.IsTrue (ex.Message.IndexOf ("Aa Bb") != -1, "#C4");
 277                                 Assert.IsNull (ex.ParamName, "#C5");
 278                         }
 279 #endif
 280
 281                         try {
 282                                 converter.ConvertFrom (null, CultureInfo.InvariantCulture, "2,");
 283                                 Assert.Fail ("#D1");
 284 #if NET_2_0
 285                         } catch (FormatException ex) {
 286                                 // 2, is not a valid value for E2
 287                                 Assert.AreEqual (typeof (FormatException), ex.GetType (), "#D2");
 288                                 Assert.IsNotNull (ex.InnerException, "#D3");
 289                                 Assert.AreEqual (typeof (ArgumentException), ex.InnerException.GetType (), "#D4");
 290                                 Assert.IsNotNull (ex.Message, "#D5");
 291                                 Assert.IsTrue (ex.Message.IndexOf ("2,") != -1, "#D6");
 292                                 Assert.IsTrue (ex.Message.IndexOf ("E2") != -1, "#D7");
 293
 294                                 // Must specify valid information for parsing in the string
 295                                 ArgumentException inner = (ArgumentException) ex.InnerException;
 296                                 Assert.IsNull (inner.InnerException, "#D8");
 297                                 Assert.IsNotNull (inner.Message, "#D9");
 298                                 Assert.IsFalse (inner.Message.IndexOf ("2,") != -1, "#D10");
 299                         }
 300 #else
 301                         } catch (ArgumentException ex) {
 302                                 // Must specify valid information for parsing in the string
 303                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#D2");
 304                                 Assert.IsNull (ex.InnerException, "#D3");
 305                                 Assert.IsNotNull (ex.Message, "#D4");
 306                                 Assert.IsFalse (ex.Message.IndexOf ("2,") != -1, "#D5");
 307                         }
 308 #endif
 309                 }
 310
 311 #if NET_2_0
 312                 [Test]
 313                 public void ConvertTo_EnumArray ()
 314                 {
 315                         Enum [] enums;
 316                         EnumConverter converter = new EnumConverter (typeof (E));
 317
 318                         enums = converter.ConvertTo (null, CultureInfo.InvariantCulture,
 319                                 E.Bb, typeof (Enum [])) as Enum [];
 320                         Assert.IsNotNull (enums, "#A1");
 321                         Assert.AreEqual (1, enums.Length, "#A2");
 322                         Assert.AreEqual (typeof (E), enums [0].GetType (), "#A3");
 323                         Assert.AreEqual (E.Bb, enums [0], "#A4");
 324
 325                         enums = converter.ConvertTo (null, CultureInfo.InvariantCulture,
 326                                 2, typeof (Enum [])) as Enum [];
 327                         Assert.IsNotNull (enums, "#B1");
 328                         Assert.AreEqual (1, enums.Length, "#B2");
 329                         Assert.AreEqual (typeof (E), enums [0].GetType (), "#B3");
 330                         Assert.AreEqual (E.Cc, enums [0], "#B4");
 331
 332                         try {
 333                                 enums = converter.ConvertTo (null, CultureInfo.InvariantCulture,
 334                                         "2", typeof (Enum [])) as Enum [];
 335                                 Assert.Fail ("#C1");
 336                         } catch (ArgumentException ex) {
 337                                 // The value passed in must be an enum base or an
 338                                 // underlying type for an enum, such as an Int32
 339                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
 340                                 Assert.IsNull (ex.InnerException, "#C3");
 341                                 Assert.IsNotNull (ex.Message, "#C4");
 342                                 Assert.IsNotNull (ex.ParamName, "#C5");
 343                                 Assert.AreEqual ("value", ex.ParamName, "#C6");
 344                         }
 345
 346                         try {
 347                                 converter.ConvertTo (null, CultureInfo.InvariantCulture,
 348                                         null, typeof (Enum []));
 349                                 Assert.Fail ("#D1");
 350                         } catch (NotSupportedException ex) {
 351                                 // 'EnumConverter' is unable to convert '(null)'
 352                                 // to 'System.Enum[]'
 353                                 Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#D2");
 354                                 Assert.IsNull (ex.InnerException, "#D3");
 355                                 Assert.IsNotNull (ex.Message, "#D4");
 356                                 Assert.IsTrue (ex.Message.IndexOf ("'" + typeof (EnumConverter).Name + "'") != -1, "#D5");
 357                                 Assert.IsTrue (ex.Message.IndexOf ("'(null)'") != -1, "#D6");
 358                                 Assert.IsTrue (ex.Message.IndexOf ("'" + typeof (Enum []).FullName + "'") != -1, "#D7");
 359                         }
 360
 361                         try {
 362                                 converter.ConvertTo (null, CultureInfo.InvariantCulture,
 363                                         "Cc", typeof (Enum []));
 364                                 Assert.Fail ("#E1");
 365                         } catch (ArgumentException ex) {
 366                                 // The value passed in must be an enum base or an
 367                                 // underlying type for an enum, such as an Int32
 368                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#E2");
 369                                 Assert.IsNull (ex.InnerException, "#E3");
 370                                 Assert.IsNotNull (ex.Message, "#E4");
 371                                 Assert.IsNotNull (ex.ParamName, "#E5");
 372                                 Assert.AreEqual ("value", ex.ParamName, "#E6");
 373                         }
 374                 }
 375
 376                 [Test]
 377                 public void ConvertTo_EnumArray_Flags ()
 378                 {
 379                         Enum [] enums;
 380                         EnumConverter converter = new EnumConverter (typeof (E2));
 381
 382                         enums = converter.ConvertTo (null, CultureInfo.InvariantCulture,
 383                                 E.Bb, typeof (Enum [])) as Enum [];
 384                         Assert.IsNotNull (enums, "#A1");
 385                         Assert.AreEqual (1, enums.Length, "#A2");
 386                         Assert.AreEqual (typeof (E2), enums [0].GetType (), "#A3");
 387                         Assert.AreEqual (E2.Aa, enums [0], "#A4");
 388
 389                         enums = converter.ConvertTo (null, CultureInfo.InvariantCulture,
 390                                 E2.Bb, typeof (Enum [])) as Enum [];
 391                         Assert.IsNotNull (enums, "#B1");
 392                         Assert.AreEqual (1, enums.Length, "#B2");
 393                         Assert.AreEqual (typeof (E2), enums [0].GetType (), "#B3");
 394                         Assert.AreEqual (E2.Bb, enums [0], "#B4");
 395
 396                         enums = converter.ConvertTo (null, CultureInfo.InvariantCulture,
 397                                 (E2) 0, typeof (Enum [])) as Enum [];
 398                         Assert.IsNotNull (enums, "#C1");
 399                         Assert.AreEqual (0, enums.Length, "#C2");
 400
 401                         enums = converter.ConvertTo (null, CultureInfo.InvariantCulture,
 402                                 (E2) 18, typeof (Enum [])) as Enum [];
 403                         Assert.IsNotNull (enums, "#D1");
 404                         Assert.AreEqual (2, enums.Length, "#D2");
 405                         Assert.AreEqual (typeof (E2), enums [0].GetType (), "#D3");
 406                         Assert.AreEqual (E2.Bb, enums [0], "#D4");
 407                         Assert.AreEqual (typeof (E2), enums [1].GetType (), "#D5");
 408                         Assert.AreEqual ((E2) 16, enums [1], "#D6");
 409
 410                         try {
 411                                 enums = converter.ConvertTo (null, CultureInfo.InvariantCulture,
 412                                         5, typeof (Enum [])) as Enum [];
 413                                 Assert.Fail ("#E1");
 414                         } catch (InvalidCastException ex) {
 415                                 // Unable to cast object of type 'System.Int32'
 416                                 // to type 'System.Enum'
 417                                 Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#E2");
 418                                 Assert.IsNull (ex.InnerException, "#E3");
 419                                 Assert.IsNotNull (ex.Message, "#E4");
 420                         }
 421
 422                         try {
 423                                 enums = converter.ConvertTo (null, CultureInfo.InvariantCulture,
 424                                         "2", typeof (Enum [])) as Enum [];
 425                                 Assert.Fail ("#F1");
 426                         } catch (InvalidCastException ex) {
 427                                 // Unable to cast object of type 'System.String'
 428                                 // to type 'System.Enum'
 429                                 Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#F2");
 430                                 Assert.IsNull (ex.InnerException, "#F3");
 431                                 Assert.IsNotNull (ex.Message, "#F4");
 432                         }
 433
 434                         try {
 435                                 converter.ConvertTo (null, CultureInfo.InvariantCulture,
 436                                         null, typeof (Enum []));
 437                                 Assert.Fail ("#G1");
 438                         } catch (NotSupportedException ex) {
 439                                 // 'EnumConverter' is unable to convert '(null)'
 440                                 // to 'System.Enum[]'
 441                                 Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#G2");
 442                                 Assert.IsNull (ex.InnerException, "#G3");
 443                                 Assert.IsNotNull (ex.Message, "#G4");
 444                                 Assert.IsTrue (ex.Message.IndexOf ("'" + typeof (EnumConverter).Name + "'") != -1, "#G5");
 445                                 Assert.IsTrue (ex.Message.IndexOf ("'(null)'") != -1, "#G6");
 446                                 Assert.IsTrue (ex.Message.IndexOf ("'" + typeof (Enum []).FullName + "'") != -1, "#G7");
 447                         }
 448
 449                         try {
 450                                 converter.ConvertTo (null, CultureInfo.InvariantCulture,
 451                                         "Bb,Cc", typeof (Enum []));
 452                                 Assert.Fail ("#H1");
 453                         } catch (InvalidCastException ex) {
 454                                 // Unable to cast object of type 'System.String'
 455                                 // to type 'System.Enum'
 456                                 Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#H2");
 457                                 Assert.IsNull (ex.InnerException, "#H3");
 458                                 Assert.IsNotNull (ex.Message, "#H4");
 459                         }
 460
 461                         try {
 462                                 converter.ConvertTo (null, CultureInfo.InvariantCulture,
 463                                         "2,4", typeof (Enum []));
 464                                 Assert.Fail ("#I1");
 465                         } catch (InvalidCastException ex) {
 466                                 // Unable to cast object of type 'System.String'
 467                                 // to type 'System.Enum'
 468                                 Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#I2");
 469                                 Assert.IsNull (ex.InnerException, "#I3");
 470                                 Assert.IsNotNull (ex.Message, "#I4");
 471                         }
 472
 473                         converter = new EnumConverter (typeof (F2));
 474
 475                         enums = converter.ConvertTo (null, CultureInfo.InvariantCulture,
 476                                 (F2) 15, typeof (Enum [])) as Enum [];
 477                         Assert.IsNotNull (enums, "#J1");
 478                         Assert.AreEqual (3, enums.Length, "#J2");
 479                         Assert.AreEqual (typeof (F2), enums [0].GetType (), "#J3");
 480                         Assert.AreEqual (F2.Bb, enums [0], "#J4");
 481                         Assert.AreEqual (typeof (F2), enums [1].GetType (), "#J5");
 482                         Assert.AreEqual (F2.Dd, enums [1], "#J6");
 483                         Assert.AreEqual (typeof (F2), enums [2].GetType (), "#J5");
 484                         Assert.AreEqual ((F2) 5, enums [2], "#J6");
 485
 486                         // Test Flags conversion of enum value 0
 487                         converter = new EnumConverter (typeof (E3));
 488                         enums = converter.ConvertTo (null, CultureInfo.InvariantCulture,
 489                                 E3.Aa, typeof (Enum [])) as Enum [];
 490                         Assert.AreEqual (1, enums.Length, "#H1");
 491                         Assert.AreEqual (typeof (E3), enums [0].GetType (), "#H2");
 492                         Assert.AreEqual (E3.Aa, enums[0], "#H3");
 493                 }
 494 #endif
 495
 496                 [Test]
 497                 public void ConvertTo_InstanceDescriptor ()
 498                 {
 499                         InstanceDescriptor idesc;
 500                         FieldInfo fi;
 501                         EnumConverter converter = new EnumConverter (typeof (E));
 502
 503                         idesc = converter.ConvertTo (null, CultureInfo.InvariantCulture,
 504                                 E.Bb, typeof (InstanceDescriptor)) as InstanceDescriptor;
 505                         Assert.IsNotNull (idesc, "#A1");
 506                         Assert.IsNotNull (idesc.Arguments, "#A2");
 507                         Assert.AreEqual (0, idesc.Arguments.Count, "#A3");
 508                         Assert.AreEqual (typeof (object []), idesc.Arguments.GetType (), "#A4");
 509                         Assert.IsTrue (idesc.IsComplete, "#A5");
 510                         fi = idesc.MemberInfo as FieldInfo;
 511                         Assert.IsNotNull (fi, "#A6");
 512                         Assert.AreEqual (typeof (E), fi.DeclaringType, "#A7");
 513                         Assert.AreEqual (typeof (E), fi.FieldType, "#A8");
 514                         Assert.IsTrue (fi.IsStatic, "#A9");
 515                         Assert.AreEqual ("Bb", fi.Name, "#A10");
 516                         Assert.AreEqual (E.Bb, fi.GetValue (null), "#A11");
 517
 518
 519                         idesc = converter.ConvertTo (null, CultureInfo.InvariantCulture,
 520                                 "2", typeof (InstanceDescriptor)) as InstanceDescriptor;
 521                         Assert.IsNotNull (idesc, "#B1");
 522                         Assert.IsNotNull (idesc.Arguments, "#B2");
 523                         Assert.AreEqual (0, idesc.Arguments.Count, "#B3");
 524                         Assert.AreEqual (typeof (object []), idesc.Arguments.GetType (), "#B4");
 525                         Assert.IsTrue (idesc.IsComplete, "#B5");
 526                         fi = idesc.MemberInfo as FieldInfo;
 527                         Assert.IsNotNull (fi, "#B6");
 528                         Assert.AreEqual (typeof (E), fi.DeclaringType, "#B7");
 529                         Assert.AreEqual (typeof (E), fi.FieldType, "#B8");
 530                         Assert.IsTrue (fi.IsStatic, "#B9");
 531                         Assert.AreEqual ("Cc", fi.Name, "#B10");
 532                         Assert.AreEqual (E.Cc, fi.GetValue (null), "#B11");
 533
 534
 535                         idesc = converter.ConvertTo (null, CultureInfo.InvariantCulture,
 536                                 2, typeof (InstanceDescriptor)) as InstanceDescriptor;
 537                         Assert.IsNotNull (idesc, "#C1");
 538                         Assert.IsNotNull (idesc.Arguments, "#C2");
 539                         Assert.AreEqual (0, idesc.Arguments.Count, "#C3");
 540                         Assert.AreEqual (typeof (object []), idesc.Arguments.GetType (), "#C4");
 541                         Assert.IsTrue (idesc.IsComplete, "#C5");
 542                         fi = idesc.MemberInfo as FieldInfo;
 543                         Assert.IsNotNull (fi, "#C6");
 544                         Assert.AreEqual (typeof (E), fi.DeclaringType, "#C7");
 545                         Assert.AreEqual (typeof (E), fi.FieldType, "#C8");
 546                         Assert.IsTrue (fi.IsStatic, "#C9");
 547                         Assert.AreEqual ("Cc", fi.Name, "#C10");
 548                         Assert.AreEqual (E.Cc, fi.GetValue (null), "#C11");
 549
 550                         idesc = converter.ConvertTo (null, CultureInfo.InvariantCulture,
 551                                 (E) 2, typeof (InstanceDescriptor)) as InstanceDescriptor;
 552                         Assert.IsNotNull (idesc, "#D1");
 553                         Assert.IsNotNull (idesc.Arguments, "#D2");
 554                         Assert.AreEqual (0, idesc.Arguments.Count, "#D3");
 555                         Assert.AreEqual (typeof (object []), idesc.Arguments.GetType (), "#D4");
 556                         Assert.IsTrue (idesc.IsComplete, "#D5");
 557                         fi = idesc.MemberInfo as FieldInfo;
 558                         Assert.IsNotNull (fi, "#D6");
 559                         Assert.AreEqual (typeof (E), fi.DeclaringType, "#D7");
 560                         Assert.AreEqual (typeof (E), fi.FieldType, "#D8");
 561                         Assert.IsTrue (fi.IsStatic, "#D9");
 562                         Assert.AreEqual ("Cc", fi.Name, "#D10");
 563                         Assert.AreEqual (E.Cc, fi.GetValue (null), "#D11");
 564
 565                         try {
 566                                 converter.ConvertTo (null, CultureInfo.InvariantCulture,
 567                                         null, typeof (InstanceDescriptor));
 568                                 Assert.Fail ("#E1");
 569                         } catch (NotSupportedException ex) {
 570                                 // 'EnumConverter' is unable to convert '(null)'
 571                                 // to 'System.ComponentModel.Design.Serialization.InstanceDescriptor'
 572                                 Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#E2");
 573                                 Assert.IsNull (ex.InnerException, "#E3");
 574                                 Assert.IsNotNull (ex.Message, "#E4");
 575                                 Assert.IsTrue (ex.Message.IndexOf ("'" + typeof (EnumConverter).Name + "'") != -1, "#E5");
 576                                 Assert.IsTrue (ex.Message.IndexOf ("'(null)'") != -1, "#E6");
 577                                 Assert.IsTrue (ex.Message.IndexOf ("'" + typeof (InstanceDescriptor).FullName + "'") != -1, "#E7");
 578                         }
 579
 580                         try {
 581                                 converter.ConvertTo (null, CultureInfo.InvariantCulture,
 582                                         "5", typeof (InstanceDescriptor));
 583                                 Assert.Fail ("#F1");
 584                         } catch (ArgumentException ex) {
 585                                 // The value '5' is not a valid value for the enum 'E'
 586                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#F2");
 587                                 Assert.IsNull (ex.InnerException, "#F3");
 588                                 Assert.IsNotNull (ex.Message, "#F4");
 589                                 Assert.IsTrue (ex.Message.IndexOf ("'5'") != -1, "#F5");
 590                                 Assert.IsTrue (ex.Message.IndexOf ("'E'") != -1, "#F6");
 591                                 Assert.IsNull (ex.ParamName, "#F7");
 592                         }
 593
 594                         try {
 595                                 converter.ConvertTo (null, CultureInfo.InvariantCulture,
 596                                         "Cc", typeof (InstanceDescriptor));
 597                                 Assert.Fail ("#G1");
 598                         } catch (FormatException ex) {
 599                                 // Input string was not in a correct format
 600                                 Assert.AreEqual (typeof (FormatException), ex.GetType (), "#G2");
 601                                 Assert.IsNull (ex.InnerException, "#G3");
 602                                 Assert.IsNotNull (ex.Message, "#G4");
 603                         }
 604
 605                         try {
 606                                 converter.ConvertTo (null, CultureInfo.InvariantCulture,
 607                                         (E) 666, typeof (InstanceDescriptor));
 608                                 Assert.Fail ("#F1");
 609                         } catch (ArgumentException ex) {
 610                                 // The value '666' is not a valid value for the enum 'E'
 611                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#F2");
 612                                 Assert.IsNull (ex.InnerException, "#F3");
 613                                 Assert.IsNotNull (ex.Message, "#F4");
 614                                 Assert.IsTrue (ex.Message.IndexOf ("'666'") != -1, "#F5");
 615                                 Assert.IsTrue (ex.Message.IndexOf ("'E'") != -1, "#F6");
 616                                 Assert.IsNull (ex.ParamName, "#F7");
 617                         }
 618                 }
 619
 620                 [Test]
 621                 public void ConvertTo_InstanceDescriptor_Flags ()
 622                 {
 623                         InstanceDescriptor idesc;
 624                         FieldInfo fi;
 625                         MethodInfo mi;
 626                         ParameterInfo [] parameters;
 627                         object [] arguments;
 628                         EnumConverter converter = new EnumConverter (typeof (E2));
 629
 630                         idesc = converter.ConvertTo (null, CultureInfo.InvariantCulture,
 631                                 E2.Bb, typeof (InstanceDescriptor)) as InstanceDescriptor;
 632                         Assert.IsNotNull (idesc, "#A1");
 633                         Assert.IsNotNull (idesc.Arguments, "#A2");
 634                         Assert.AreEqual (0, idesc.Arguments.Count, "#A3");
 635                         Assert.AreEqual (typeof (object []), idesc.Arguments.GetType (), "#A4");
 636                         Assert.IsTrue (idesc.IsComplete, "#A5");
 637                         fi = idesc.MemberInfo as FieldInfo;
 638                         Assert.IsNotNull (fi, "#A6");
 639                         Assert.AreEqual (typeof (E2), fi.DeclaringType, "#A7");
 640                         Assert.AreEqual (typeof (E2), fi.FieldType, "#A8");
 641                         Assert.IsTrue (fi.IsStatic, "#A9");
 642                         Assert.AreEqual ("Bb", fi.Name, "#A10");
 643                         Assert.AreEqual (E2.Bb, fi.GetValue (null), "#A11");
 644
 645                         idesc = converter.ConvertTo (null, CultureInfo.InvariantCulture,
 646                                 E.Bb, typeof (InstanceDescriptor)) as InstanceDescriptor;
 647                         Assert.IsNotNull (idesc, "#B1");
 648                         Assert.IsNotNull (idesc.Arguments, "#B2");
 649                         Assert.AreEqual (0, idesc.Arguments.Count, "#B3");
 650                         Assert.AreEqual (typeof (object []), idesc.Arguments.GetType (), "#B4");
 651                         Assert.IsTrue (idesc.IsComplete, "#B5");
 652                         fi = idesc.MemberInfo as FieldInfo;
 653                         Assert.IsNotNull (fi, "#B6");
 654                         Assert.AreEqual (typeof (E2), fi.DeclaringType, "#B7");
 655                         Assert.AreEqual (typeof (E2), fi.FieldType, "#B8");
 656                         Assert.IsTrue (fi.IsStatic, "#B9");
 657                         Assert.AreEqual ("Aa", fi.Name, "#B10");
 658                         Assert.AreEqual (E2.Aa, fi.GetValue (null), "#B11");
 659
 660                         idesc = converter.ConvertTo (null, CultureInfo.InvariantCulture,
 661                                 E2.Bb | E2.Dd, typeof (InstanceDescriptor))
 662                                 as InstanceDescriptor;
 663                         Assert.IsNotNull (idesc, "#C1");
 664                         Assert.IsNotNull (idesc.Arguments, "#C2");
 665                         Assert.AreEqual (2, idesc.Arguments.Count, "#C3");
 666                         Assert.AreEqual (typeof (object []), idesc.Arguments.GetType (), "#C4");
 667                         arguments = (object []) idesc.Arguments;
 668                         Assert.AreEqual (typeof (E2), arguments [0], "#C5");
 669                         Assert.AreEqual (typeof (int), arguments [1].GetType (), "#C6");
 670                         Assert.AreEqual (10, arguments [1], "#C7");
 671                         Assert.IsTrue (idesc.IsComplete, "#C8");
 672                         mi = idesc.MemberInfo as MethodInfo;
 673                         Assert.IsNotNull (mi, "#C9");
 674                         Assert.AreEqual ("ToObject", mi.Name, "#C10");
 675                         Assert.AreEqual (typeof (Enum), mi.DeclaringType, "#C11");
 676                         parameters = mi.GetParameters ();
 677                         Assert.AreEqual (2, parameters.Length, "#C12");
 678                         Assert.AreEqual (typeof (Type), parameters [0].ParameterType, "#C13");
 679                         Assert.AreEqual (typeof (int), parameters [1].ParameterType, "#C14");
 680
 681                         idesc = converter.ConvertTo (null, CultureInfo.InvariantCulture,
 682                                 "5", typeof (InstanceDescriptor)) as InstanceDescriptor;
 683                         Assert.IsNotNull (idesc, "#D1");
 684                         Assert.IsNotNull (idesc.Arguments, "#D2");
 685                         Assert.AreEqual (2, idesc.Arguments.Count, "#D3");
 686                         Assert.AreEqual (typeof (object []), idesc.Arguments.GetType (), "#D4");
 687                         arguments = (object []) idesc.Arguments;
 688                         Assert.AreEqual (typeof (E2), arguments [0], "#D5");
 689                         Assert.AreEqual (typeof (int), arguments [1].GetType (), "#D6");
 690                         Assert.AreEqual (5, arguments [1], "#D7");
 691                         Assert.IsTrue (idesc.IsComplete, "#D8");
 692                         mi = idesc.MemberInfo as MethodInfo;
 693                         Assert.IsNotNull (mi, "#D9");
 694                         Assert.AreEqual ("ToObject", mi.Name, "#D10");
 695                         Assert.AreEqual (typeof (Enum), mi.DeclaringType, "#D11");
 696                         parameters = mi.GetParameters ();
 697                         Assert.AreEqual (2, parameters.Length, "#D12");
 698                         Assert.AreEqual (typeof (Type), parameters [0].ParameterType, "#D13");
 699                         Assert.AreEqual (typeof (int), parameters [1].ParameterType, "#D14");
 700
 701                         idesc = converter.ConvertTo (null, CultureInfo.InvariantCulture,
 702                                 3, typeof (InstanceDescriptor)) as InstanceDescriptor;
 703                         Assert.IsNotNull (idesc, "#E1");
 704                         Assert.IsNotNull (idesc.Arguments, "#E2");
 705                         Assert.AreEqual (2, idesc.Arguments.Count, "#E3");
 706                         Assert.AreEqual (typeof (object []), idesc.Arguments.GetType (), "#E4");
 707                         arguments = (object []) idesc.Arguments;
 708                         Assert.AreEqual (typeof (E2), arguments [0], "#E5");
 709                         Assert.AreEqual (typeof (int), arguments [1].GetType (), "#E6");
 710                         Assert.AreEqual (3, arguments [1], "#E7");
 711                         Assert.IsTrue (idesc.IsComplete, "#E8");
 712                         mi = idesc.MemberInfo as MethodInfo;
 713                         Assert.IsNotNull (mi, "#E9");
 714                         Assert.AreEqual ("ToObject", mi.Name, "#E10");
 715                         Assert.AreEqual (typeof (Enum), mi.DeclaringType, "#E11");
 716                         parameters = mi.GetParameters ();
 717                         Assert.AreEqual (2, parameters.Length, "#E12");
 718                         Assert.AreEqual (typeof (Type), parameters [0].ParameterType, "#E13");
 719                         Assert.AreEqual (typeof (int), parameters [1].ParameterType, "#E14");
 720
 721                         try {
 722                                 converter.ConvertTo (null, CultureInfo.InvariantCulture,
 723                                         null, typeof (InstanceDescriptor));
 724                                 Assert.Fail ("#F1");
 725                         } catch (NotSupportedException ex) {
 726                                 // 'EnumConverter' is unable to convert '(null)'
 727                                 // to 'System.ComponentModel.Design.Serialization.InstanceDescriptor'
 728                                 Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#F2");
 729                                 Assert.IsNull (ex.InnerException, "#F3");
 730                                 Assert.IsNotNull (ex.Message, "#F4");
 731                                 Assert.IsTrue (ex.Message.IndexOf ("'" + typeof (EnumConverter).Name + "'") != -1, "#F5");
 732                                 Assert.IsTrue (ex.Message.IndexOf ("'(null)'") != -1, "#F6");
 733                                 Assert.IsTrue (ex.Message.IndexOf ("'" + typeof (InstanceDescriptor).FullName + "'") != -1, "#F7");
 734                         }
 735
 736                         try {
 737                                 converter.ConvertTo (null, CultureInfo.InvariantCulture,
 738                                         "2,1", typeof (InstanceDescriptor));
 739                                 Assert.Fail ("#G1");
 740                         } catch (FormatException ex) {
 741                                 // Input string was not in a correct format
 742                                 Assert.AreEqual (typeof (FormatException), ex.GetType (), "#G2");
 743                                 Assert.IsNull (ex.InnerException, "#G3");
 744                                 Assert.IsNotNull (ex.Message, "#G4");
 745                         }
 746
 747                         try {
 748                                 converter.ConvertTo (null, CultureInfo.InvariantCulture,
 749                                         "Cc", typeof (InstanceDescriptor));
 750                                 Assert.Fail ("#H1");
 751                         } catch (FormatException ex) {
 752                                 // Input string was not in a correct format
 753                                 Assert.AreEqual (typeof (FormatException), ex.GetType (), "#H2");
 754                                 Assert.IsNull (ex.InnerException, "#H3");
 755                                 Assert.IsNotNull (ex.Message, "#H4");
 756                         }
 757
 758                         try {
 759                                 converter.ConvertTo (null, CultureInfo.InvariantCulture,
 760                                         (E2) 666 | (E2) 222, typeof (InstanceDescriptor));
 761                                 Assert.Fail ("#I1");
 762                         } catch (NotSupportedException ex) {
 763                                 // 'EnumConverter' is unable to convert 'MonoTests.System.ComponentModel.EnumConverterTests+E2'
 764                                 // to 'System.ComponentModel.Design.Serialization.InstanceDescriptor'
 765                                 Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#I2");
 766                                 Assert.IsNull (ex.InnerException, "#I3");
 767                                 Assert.IsNotNull (ex.Message, "#I4");
 768                                 Assert.IsTrue (ex.Message.IndexOf ("'" + typeof (EnumConverter).Name + "'") != -1, "#I5");
 769                                 Assert.IsTrue (ex.Message.IndexOf ("'" + typeof (E2).FullName + "'") != -1, "#I6");
 770                                 Assert.IsTrue (ex.Message.IndexOf ("'" + typeof (InstanceDescriptor).FullName + "'") != -1, "#I7");
 771                         }
 772
 773                         converter = new EnumConverter (typeof (F2));
 774                         idesc = converter.ConvertTo (null, CultureInfo.InvariantCulture,
 775                                 F2.Bb | F2.Dd, typeof (InstanceDescriptor))
 776                                 as InstanceDescriptor;
 777                         Assert.IsNotNull (idesc, "#J1");
 778                         Assert.IsNotNull (idesc.Arguments, "#J2");
 779                         Assert.AreEqual (2, idesc.Arguments.Count, "#J3");
 780                         Assert.AreEqual (typeof (object []), idesc.Arguments.GetType (), "#J4");
 781                         arguments = (object []) idesc.Arguments;
 782                         Assert.AreEqual (typeof (F2), arguments [0], "#J5");
 783                         Assert.AreEqual (typeof (byte), arguments [1].GetType (), "#J6");
 784                         Assert.AreEqual (10, arguments [1], "#J7");
 785                         Assert.IsTrue (idesc.IsComplete, "#J8");
 786                         mi = idesc.MemberInfo as MethodInfo;
 787                         Assert.IsNotNull (mi, "#J9");
 788                         Assert.AreEqual ("ToObject", mi.Name, "#J10");
 789                         Assert.AreEqual (typeof (Enum), mi.DeclaringType, "#J11");
 790                         parameters = mi.GetParameters ();
 791                         Assert.AreEqual (2, parameters.Length, "#J12");
 792                         Assert.AreEqual (typeof (Type), parameters [0].ParameterType, "#J13");
 793                         Assert.AreEqual (typeof (byte), parameters [1].ParameterType, "#J14");
 794                 }
 795
 796                 [Test]
 797                 public void ConvertTo_String ()
 798                 {
 799                         EnumConverter converter = new EnumConverter (typeof (E));
 800
 801                         Assert.AreEqual ("Bb", converter.ConvertTo (null,
 802                                 CultureInfo.InvariantCulture, E.Bb,
 803                                 typeof (string)), "#A1");
 804                         Assert.AreEqual ("Dd", converter.ConvertTo (null,
 805                                 CultureInfo.InvariantCulture, 3,
 806                                 typeof (string)), "#A2");
 807                         Assert.AreEqual (string.Empty, converter.ConvertTo (
 808                                 null, CultureInfo.InvariantCulture, null,
 809                                 typeof (string)), "#A3");
 810                         Assert.AreEqual ("Cc", converter.ConvertTo (
 811                                 null, CultureInfo.InvariantCulture, (E) 2,
 812                                 typeof (string)), "#A4");
 813                         Assert.AreEqual ("Cc", converter.ConvertTo (null,
 814                                 CultureInfo.InvariantCulture, E2.Bb,
 815                                 typeof (string)), "#A5");
 816                         Assert.AreEqual ("Dd", converter.ConvertTo (null,
 817                                 CultureInfo.InvariantCulture, E.Bb | E.Dd,
 818                                 typeof (string)), "#A6");
 819
 820                         try {
 821                                 converter.ConvertTo (null, CultureInfo.InvariantCulture,
 822                                         (E) 666, typeof (string));
 823                                 Assert.Fail ("#B1");
 824                         } catch (ArgumentException ex) {
 825                                 // The value '666' is not a valid value for the enum 'E'
 826                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 827                                 Assert.IsNull (ex.InnerException, "#B3");
 828                                 Assert.IsNotNull (ex.Message, "#B4");
 829                                 Assert.IsTrue (ex.Message.IndexOf ("'666'") != -1, "#B5");
 830                                 Assert.IsTrue (ex.Message.IndexOf ("'E'") != -1, "#B6");
 831                                 Assert.IsNull (ex.ParamName, "#B7");
 832                         }
 833
 834                         try {
 835                                 converter.ConvertTo (null, CultureInfo.InvariantCulture,
 836                                         "Cc", typeof (string));
 837                                 Assert.Fail ("#C1");
 838                         } catch (FormatException ex) {
 839                                 // Input string was not in a correct format
 840                                 Assert.AreEqual (typeof (FormatException), ex.GetType (), "#C2");
 841                                 Assert.IsNull (ex.InnerException, "#C3");
 842                                 Assert.IsNotNull (ex.Message, "#C4");
 843                         }
 844
 845
 846                         converter = new EnumConverter (typeof (E2));
 847
 848                         Assert.AreEqual ("Bb", converter.ConvertTo (null,
 849                                 CultureInfo.InvariantCulture, E2.Bb,
 850                                 typeof (string)), "#B1");
 851                         Assert.AreEqual ("Aa, Bb", converter.ConvertTo (null,
 852                                 CultureInfo.InvariantCulture, 3,
 853                                 typeof (string)), "#B2");
 854                         Assert.AreEqual (string.Empty, converter.ConvertTo (
 855                                 null, CultureInfo.InvariantCulture, null,
 856                                 typeof (string)), "#B3");
 857                         Assert.AreEqual ("Bb", converter.ConvertTo (
 858                                 null, CultureInfo.InvariantCulture, (E2) 2,
 859                                 typeof (string)), "#B4");
 860                         Assert.AreEqual ("Aa, Bb", converter.ConvertTo (
 861                                 null, CultureInfo.InvariantCulture, E.Dd,
 862                                 typeof (string)), "#B5");
 863                         Assert.AreEqual ("Bb, Dd", converter.ConvertTo (null,
 864                                 CultureInfo.InvariantCulture, E2.Bb | E2.Dd,
 865                                 typeof (string)), "#B6");
 866                 }
 867
 868                 enum E
 869                 {
 870                         Aa = 0,
 871                         Bb = 1,
 872                         Cc = 2,
 873                         Dd = 3,
 874                 }
 875
 876                 [Flags]
 877                 enum E2
 878                 {
 879                         Aa = 1,
 880                         Bb = 2,
 881                         Cc = 4,
 882                         Dd = 8,
 883                 }
 884
 885
 886                 [Flags]
 887                 enum E3
 888                 {
 889                         Aa = 0,
 890                         Bb = 1,
 891                         Cc = 2,
 892                         Dd = 4,
 893                 }
 894
 895                 enum F : byte
 896                 {
 897                         Bb = 1,
 898                         Dd = 3
 899                 }
 900
 901                 [Flags]
 902                 enum F2 : byte
 903                 {
 904                         Bb = 2,
 905                         Dd = 8
 906                 }
 907         }
 908 }