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 #endif
 487
 488                 [Test]
 489                 public void ConvertTo_InstanceDescriptor ()
 490                 {
 491                         InstanceDescriptor idesc;
 492                         FieldInfo fi;
 493                         EnumConverter converter = new EnumConverter (typeof (E));
 494
 495                         idesc = converter.ConvertTo (null, CultureInfo.InvariantCulture,
 496                                 E.Bb, typeof (InstanceDescriptor)) as InstanceDescriptor;
 497                         Assert.IsNotNull (idesc, "#A1");
 498                         Assert.IsNotNull (idesc.Arguments, "#A2");
 499                         Assert.AreEqual (0, idesc.Arguments.Count, "#A3");
 500                         Assert.AreEqual (typeof (object []), idesc.Arguments.GetType (), "#A4");
 501                         Assert.IsTrue (idesc.IsComplete, "#A5");
 502                         fi = idesc.MemberInfo as FieldInfo;
 503                         Assert.IsNotNull (fi, "#A6");
 504                         Assert.AreEqual (typeof (E), fi.DeclaringType, "#A7");
 505                         Assert.AreEqual (typeof (E), fi.FieldType, "#A8");
 506                         Assert.IsTrue (fi.IsStatic, "#A9");
 507                         Assert.AreEqual ("Bb", fi.Name, "#A10");
 508                         Assert.AreEqual (E.Bb, fi.GetValue (null), "#A11");
 509
 510
 511                         idesc = converter.ConvertTo (null, CultureInfo.InvariantCulture,
 512                                 "2", typeof (InstanceDescriptor)) as InstanceDescriptor;
 513                         Assert.IsNotNull (idesc, "#B1");
 514                         Assert.IsNotNull (idesc.Arguments, "#B2");
 515                         Assert.AreEqual (0, idesc.Arguments.Count, "#B3");
 516                         Assert.AreEqual (typeof (object []), idesc.Arguments.GetType (), "#B4");
 517                         Assert.IsTrue (idesc.IsComplete, "#B5");
 518                         fi = idesc.MemberInfo as FieldInfo;
 519                         Assert.IsNotNull (fi, "#B6");
 520                         Assert.AreEqual (typeof (E), fi.DeclaringType, "#B7");
 521                         Assert.AreEqual (typeof (E), fi.FieldType, "#B8");
 522                         Assert.IsTrue (fi.IsStatic, "#B9");
 523                         Assert.AreEqual ("Cc", fi.Name, "#B10");
 524                         Assert.AreEqual (E.Cc, fi.GetValue (null), "#B11");
 525
 526
 527                         idesc = converter.ConvertTo (null, CultureInfo.InvariantCulture,
 528                                 2, typeof (InstanceDescriptor)) as InstanceDescriptor;
 529                         Assert.IsNotNull (idesc, "#C1");
 530                         Assert.IsNotNull (idesc.Arguments, "#C2");
 531                         Assert.AreEqual (0, idesc.Arguments.Count, "#C3");
 532                         Assert.AreEqual (typeof (object []), idesc.Arguments.GetType (), "#C4");
 533                         Assert.IsTrue (idesc.IsComplete, "#C5");
 534                         fi = idesc.MemberInfo as FieldInfo;
 535                         Assert.IsNotNull (fi, "#C6");
 536                         Assert.AreEqual (typeof (E), fi.DeclaringType, "#C7");
 537                         Assert.AreEqual (typeof (E), fi.FieldType, "#C8");
 538                         Assert.IsTrue (fi.IsStatic, "#C9");
 539                         Assert.AreEqual ("Cc", fi.Name, "#C10");
 540                         Assert.AreEqual (E.Cc, fi.GetValue (null), "#C11");
 541
 542                         idesc = converter.ConvertTo (null, CultureInfo.InvariantCulture,
 543                                 (E) 2, typeof (InstanceDescriptor)) as InstanceDescriptor;
 544                         Assert.IsNotNull (idesc, "#D1");
 545                         Assert.IsNotNull (idesc.Arguments, "#D2");
 546                         Assert.AreEqual (0, idesc.Arguments.Count, "#D3");
 547                         Assert.AreEqual (typeof (object []), idesc.Arguments.GetType (), "#D4");
 548                         Assert.IsTrue (idesc.IsComplete, "#D5");
 549                         fi = idesc.MemberInfo as FieldInfo;
 550                         Assert.IsNotNull (fi, "#D6");
 551                         Assert.AreEqual (typeof (E), fi.DeclaringType, "#D7");
 552                         Assert.AreEqual (typeof (E), fi.FieldType, "#D8");
 553                         Assert.IsTrue (fi.IsStatic, "#D9");
 554                         Assert.AreEqual ("Cc", fi.Name, "#D10");
 555                         Assert.AreEqual (E.Cc, fi.GetValue (null), "#D11");
 556
 557                         try {
 558                                 converter.ConvertTo (null, CultureInfo.InvariantCulture,
 559                                         null, typeof (InstanceDescriptor));
 560                                 Assert.Fail ("#E1");
 561                         } catch (NotSupportedException ex) {
 562                                 // 'EnumConverter' is unable to convert '(null)'
 563                                 // to 'System.ComponentModel.Design.Serialization.InstanceDescriptor'
 564                                 Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#E2");
 565                                 Assert.IsNull (ex.InnerException, "#E3");
 566                                 Assert.IsNotNull (ex.Message, "#E4");
 567                                 Assert.IsTrue (ex.Message.IndexOf ("'" + typeof (EnumConverter).Name + "'") != -1, "#E5");
 568                                 Assert.IsTrue (ex.Message.IndexOf ("'(null)'") != -1, "#E6");
 569                                 Assert.IsTrue (ex.Message.IndexOf ("'" + typeof (InstanceDescriptor).FullName + "'") != -1, "#E7");
 570                         }
 571
 572                         try {
 573                                 converter.ConvertTo (null, CultureInfo.InvariantCulture,
 574                                         "5", typeof (InstanceDescriptor));
 575                                 Assert.Fail ("#F1");
 576                         } catch (ArgumentException ex) {
 577                                 // The value '5' is not a valid value for the enum 'E'
 578                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#F2");
 579                                 Assert.IsNull (ex.InnerException, "#F3");
 580                                 Assert.IsNotNull (ex.Message, "#F4");
 581                                 Assert.IsTrue (ex.Message.IndexOf ("'5'") != -1, "#F5");
 582                                 Assert.IsTrue (ex.Message.IndexOf ("'E'") != -1, "#F6");
 583                                 Assert.IsNull (ex.ParamName, "#F7");
 584                         }
 585
 586                         try {
 587                                 converter.ConvertTo (null, CultureInfo.InvariantCulture,
 588                                         "Cc", typeof (InstanceDescriptor));
 589                                 Assert.Fail ("#G1");
 590                         } catch (FormatException ex) {
 591                                 // Input string was not in a correct format
 592                                 Assert.AreEqual (typeof (FormatException), ex.GetType (), "#G2");
 593                                 Assert.IsNull (ex.InnerException, "#G3");
 594                                 Assert.IsNotNull (ex.Message, "#G4");
 595                         }
 596
 597                         try {
 598                                 converter.ConvertTo (null, CultureInfo.InvariantCulture,
 599                                         (E) 666, typeof (InstanceDescriptor));
 600                                 Assert.Fail ("#F1");
 601                         } catch (ArgumentException ex) {
 602                                 // The value '666' is not a valid value for the enum 'E'
 603                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#F2");
 604                                 Assert.IsNull (ex.InnerException, "#F3");
 605                                 Assert.IsNotNull (ex.Message, "#F4");
 606                                 Assert.IsTrue (ex.Message.IndexOf ("'666'") != -1, "#F5");
 607                                 Assert.IsTrue (ex.Message.IndexOf ("'E'") != -1, "#F6");
 608                                 Assert.IsNull (ex.ParamName, "#F7");
 609                         }
 610                 }
 611
 612                 [Test]
 613                 public void ConvertTo_InstanceDescriptor_Flags ()
 614                 {
 615                         InstanceDescriptor idesc;
 616                         FieldInfo fi;
 617                         MethodInfo mi;
 618                         ParameterInfo [] parameters;
 619                         object [] arguments;
 620                         EnumConverter converter = new EnumConverter (typeof (E2));
 621
 622                         idesc = converter.ConvertTo (null, CultureInfo.InvariantCulture,
 623                                 E2.Bb, typeof (InstanceDescriptor)) as InstanceDescriptor;
 624                         Assert.IsNotNull (idesc, "#A1");
 625                         Assert.IsNotNull (idesc.Arguments, "#A2");
 626                         Assert.AreEqual (0, idesc.Arguments.Count, "#A3");
 627                         Assert.AreEqual (typeof (object []), idesc.Arguments.GetType (), "#A4");
 628                         Assert.IsTrue (idesc.IsComplete, "#A5");
 629                         fi = idesc.MemberInfo as FieldInfo;
 630                         Assert.IsNotNull (fi, "#A6");
 631                         Assert.AreEqual (typeof (E2), fi.DeclaringType, "#A7");
 632                         Assert.AreEqual (typeof (E2), fi.FieldType, "#A8");
 633                         Assert.IsTrue (fi.IsStatic, "#A9");
 634                         Assert.AreEqual ("Bb", fi.Name, "#A10");
 635                         Assert.AreEqual (E2.Bb, fi.GetValue (null), "#A11");
 636
 637                         idesc = converter.ConvertTo (null, CultureInfo.InvariantCulture,
 638                                 E.Bb, typeof (InstanceDescriptor)) as InstanceDescriptor;
 639                         Assert.IsNotNull (idesc, "#B1");
 640                         Assert.IsNotNull (idesc.Arguments, "#B2");
 641                         Assert.AreEqual (0, idesc.Arguments.Count, "#B3");
 642                         Assert.AreEqual (typeof (object []), idesc.Arguments.GetType (), "#B4");
 643                         Assert.IsTrue (idesc.IsComplete, "#B5");
 644                         fi = idesc.MemberInfo as FieldInfo;
 645                         Assert.IsNotNull (fi, "#B6");
 646                         Assert.AreEqual (typeof (E2), fi.DeclaringType, "#B7");
 647                         Assert.AreEqual (typeof (E2), fi.FieldType, "#B8");
 648                         Assert.IsTrue (fi.IsStatic, "#B9");
 649                         Assert.AreEqual ("Aa", fi.Name, "#B10");
 650                         Assert.AreEqual (E2.Aa, fi.GetValue (null), "#B11");
 651
 652                         idesc = converter.ConvertTo (null, CultureInfo.InvariantCulture,
 653                                 E2.Bb | E2.Dd, typeof (InstanceDescriptor))
 654                                 as InstanceDescriptor;
 655                         Assert.IsNotNull (idesc, "#C1");
 656                         Assert.IsNotNull (idesc.Arguments, "#C2");
 657                         Assert.AreEqual (2, idesc.Arguments.Count, "#C3");
 658                         Assert.AreEqual (typeof (object []), idesc.Arguments.GetType (), "#C4");
 659                         arguments = (object []) idesc.Arguments;
 660                         Assert.AreEqual (typeof (E2), arguments [0], "#C5");
 661                         Assert.AreEqual (typeof (int), arguments [1].GetType (), "#C6");
 662                         Assert.AreEqual (10, arguments [1], "#C7");
 663                         Assert.IsTrue (idesc.IsComplete, "#C8");
 664                         mi = idesc.MemberInfo as MethodInfo;
 665                         Assert.IsNotNull (mi, "#C9");
 666                         Assert.AreEqual ("ToObject", mi.Name, "#C10");
 667                         Assert.AreEqual (typeof (Enum), mi.DeclaringType, "#C11");
 668                         parameters = mi.GetParameters ();
 669                         Assert.AreEqual (2, parameters.Length, "#C12");
 670                         Assert.AreEqual (typeof (Type), parameters [0].ParameterType, "#C13");
 671                         Assert.AreEqual (typeof (int), parameters [1].ParameterType, "#C14");
 672
 673                         idesc = converter.ConvertTo (null, CultureInfo.InvariantCulture,
 674                                 "5", typeof (InstanceDescriptor)) as InstanceDescriptor;
 675                         Assert.IsNotNull (idesc, "#D1");
 676                         Assert.IsNotNull (idesc.Arguments, "#D2");
 677                         Assert.AreEqual (2, idesc.Arguments.Count, "#D3");
 678                         Assert.AreEqual (typeof (object []), idesc.Arguments.GetType (), "#D4");
 679                         arguments = (object []) idesc.Arguments;
 680                         Assert.AreEqual (typeof (E2), arguments [0], "#D5");
 681                         Assert.AreEqual (typeof (int), arguments [1].GetType (), "#D6");
 682                         Assert.AreEqual (5, arguments [1], "#D7");
 683                         Assert.IsTrue (idesc.IsComplete, "#D8");
 684                         mi = idesc.MemberInfo as MethodInfo;
 685                         Assert.IsNotNull (mi, "#D9");
 686                         Assert.AreEqual ("ToObject", mi.Name, "#D10");
 687                         Assert.AreEqual (typeof (Enum), mi.DeclaringType, "#D11");
 688                         parameters = mi.GetParameters ();
 689                         Assert.AreEqual (2, parameters.Length, "#D12");
 690                         Assert.AreEqual (typeof (Type), parameters [0].ParameterType, "#D13");
 691                         Assert.AreEqual (typeof (int), parameters [1].ParameterType, "#D14");
 692
 693                         idesc = converter.ConvertTo (null, CultureInfo.InvariantCulture,
 694                                 3, typeof (InstanceDescriptor)) as InstanceDescriptor;
 695                         Assert.IsNotNull (idesc, "#E1");
 696                         Assert.IsNotNull (idesc.Arguments, "#E2");
 697                         Assert.AreEqual (2, idesc.Arguments.Count, "#E3");
 698                         Assert.AreEqual (typeof (object []), idesc.Arguments.GetType (), "#E4");
 699                         arguments = (object []) idesc.Arguments;
 700                         Assert.AreEqual (typeof (E2), arguments [0], "#E5");
 701                         Assert.AreEqual (typeof (int), arguments [1].GetType (), "#E6");
 702                         Assert.AreEqual (3, arguments [1], "#E7");
 703                         Assert.IsTrue (idesc.IsComplete, "#E8");
 704                         mi = idesc.MemberInfo as MethodInfo;
 705                         Assert.IsNotNull (mi, "#E9");
 706                         Assert.AreEqual ("ToObject", mi.Name, "#E10");
 707                         Assert.AreEqual (typeof (Enum), mi.DeclaringType, "#E11");
 708                         parameters = mi.GetParameters ();
 709                         Assert.AreEqual (2, parameters.Length, "#E12");
 710                         Assert.AreEqual (typeof (Type), parameters [0].ParameterType, "#E13");
 711                         Assert.AreEqual (typeof (int), parameters [1].ParameterType, "#E14");
 712
 713                         try {
 714                                 converter.ConvertTo (null, CultureInfo.InvariantCulture,
 715                                         null, typeof (InstanceDescriptor));
 716                                 Assert.Fail ("#F1");
 717                         } catch (NotSupportedException ex) {
 718                                 // 'EnumConverter' is unable to convert '(null)'
 719                                 // to 'System.ComponentModel.Design.Serialization.InstanceDescriptor'
 720                                 Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#F2");
 721                                 Assert.IsNull (ex.InnerException, "#F3");
 722                                 Assert.IsNotNull (ex.Message, "#F4");
 723                                 Assert.IsTrue (ex.Message.IndexOf ("'" + typeof (EnumConverter).Name + "'") != -1, "#F5");
 724                                 Assert.IsTrue (ex.Message.IndexOf ("'(null)'") != -1, "#F6");
 725                                 Assert.IsTrue (ex.Message.IndexOf ("'" + typeof (InstanceDescriptor).FullName + "'") != -1, "#F7");
 726                         }
 727
 728                         try {
 729                                 converter.ConvertTo (null, CultureInfo.InvariantCulture,
 730                                         "2,1", typeof (InstanceDescriptor));
 731                                 Assert.Fail ("#G1");
 732                         } catch (FormatException ex) {
 733                                 // Input string was not in a correct format
 734                                 Assert.AreEqual (typeof (FormatException), ex.GetType (), "#G2");
 735                                 Assert.IsNull (ex.InnerException, "#G3");
 736                                 Assert.IsNotNull (ex.Message, "#G4");
 737                         }
 738
 739                         try {
 740                                 converter.ConvertTo (null, CultureInfo.InvariantCulture,
 741                                         "Cc", typeof (InstanceDescriptor));
 742                                 Assert.Fail ("#H1");
 743                         } catch (FormatException ex) {
 744                                 // Input string was not in a correct format
 745                                 Assert.AreEqual (typeof (FormatException), ex.GetType (), "#H2");
 746                                 Assert.IsNull (ex.InnerException, "#H3");
 747                                 Assert.IsNotNull (ex.Message, "#H4");
 748                         }
 749
 750                         try {
 751                                 converter.ConvertTo (null, CultureInfo.InvariantCulture,
 752                                         (E2) 666 | (E2) 222, typeof (InstanceDescriptor));
 753                                 Assert.Fail ("#I1");
 754                         } catch (NotSupportedException ex) {
 755                                 // 'EnumConverter' is unable to convert 'MonoTests.System.ComponentModel.EnumConverterTests+E2'
 756                                 // to 'System.ComponentModel.Design.Serialization.InstanceDescriptor'
 757                                 Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#I2");
 758                                 Assert.IsNull (ex.InnerException, "#I3");
 759                                 Assert.IsNotNull (ex.Message, "#I4");
 760                                 Assert.IsTrue (ex.Message.IndexOf ("'" + typeof (EnumConverter).Name + "'") != -1, "#I5");
 761                                 Assert.IsTrue (ex.Message.IndexOf ("'" + typeof (E2).FullName + "'") != -1, "#I6");
 762                                 Assert.IsTrue (ex.Message.IndexOf ("'" + typeof (InstanceDescriptor).FullName + "'") != -1, "#I7");
 763                         }
 764
 765                         converter = new EnumConverter (typeof (F2));
 766                         idesc = converter.ConvertTo (null, CultureInfo.InvariantCulture,
 767                                 F2.Bb | F2.Dd, typeof (InstanceDescriptor))
 768                                 as InstanceDescriptor;
 769                         Assert.IsNotNull (idesc, "#J1");
 770                         Assert.IsNotNull (idesc.Arguments, "#J2");
 771                         Assert.AreEqual (2, idesc.Arguments.Count, "#J3");
 772                         Assert.AreEqual (typeof (object []), idesc.Arguments.GetType (), "#J4");
 773                         arguments = (object []) idesc.Arguments;
 774                         Assert.AreEqual (typeof (F2), arguments [0], "#J5");
 775                         Assert.AreEqual (typeof (byte), arguments [1].GetType (), "#J6");
 776                         Assert.AreEqual (10, arguments [1], "#J7");
 777                         Assert.IsTrue (idesc.IsComplete, "#J8");
 778                         mi = idesc.MemberInfo as MethodInfo;
 779                         Assert.IsNotNull (mi, "#J9");
 780                         Assert.AreEqual ("ToObject", mi.Name, "#J10");
 781                         Assert.AreEqual (typeof (Enum), mi.DeclaringType, "#J11");
 782                         parameters = mi.GetParameters ();
 783                         Assert.AreEqual (2, parameters.Length, "#J12");
 784                         Assert.AreEqual (typeof (Type), parameters [0].ParameterType, "#J13");
 785                         Assert.AreEqual (typeof (byte), parameters [1].ParameterType, "#J14");
 786                 }
 787
 788                 [Test]
 789                 public void ConvertTo_String ()
 790                 {
 791                         EnumConverter converter = new EnumConverter (typeof (E));
 792
 793                         Assert.AreEqual ("Bb", converter.ConvertTo (null,
 794                                 CultureInfo.InvariantCulture, E.Bb,
 795                                 typeof (string)), "#A1");
 796                         Assert.AreEqual ("Dd", converter.ConvertTo (null,
 797                                 CultureInfo.InvariantCulture, 3,
 798                                 typeof (string)), "#A2");
 799                         Assert.AreEqual (string.Empty, converter.ConvertTo (
 800                                 null, CultureInfo.InvariantCulture, null,
 801                                 typeof (string)), "#A3");
 802                         Assert.AreEqual ("Cc", converter.ConvertTo (
 803                                 null, CultureInfo.InvariantCulture, (E) 2,
 804                                 typeof (string)), "#A4");
 805                         Assert.AreEqual ("Cc", converter.ConvertTo (null,
 806                                 CultureInfo.InvariantCulture, E2.Bb,
 807                                 typeof (string)), "#A5");
 808                         Assert.AreEqual ("Dd", converter.ConvertTo (null,
 809                                 CultureInfo.InvariantCulture, E.Bb | E.Dd,
 810                                 typeof (string)), "#A6");
 811
 812                         try {
 813                                 converter.ConvertTo (null, CultureInfo.InvariantCulture,
 814                                         (E) 666, typeof (string));
 815                                 Assert.Fail ("#B1");
 816                         } catch (ArgumentException ex) {
 817                                 // The value '666' is not a valid value for the enum 'E'
 818                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 819                                 Assert.IsNull (ex.InnerException, "#B3");
 820                                 Assert.IsNotNull (ex.Message, "#B4");
 821                                 Assert.IsTrue (ex.Message.IndexOf ("'666'") != -1, "#B5");
 822                                 Assert.IsTrue (ex.Message.IndexOf ("'E'") != -1, "#B6");
 823                                 Assert.IsNull (ex.ParamName, "#B7");
 824                         }
 825
 826                         try {
 827                                 converter.ConvertTo (null, CultureInfo.InvariantCulture,
 828                                         "Cc", typeof (string));
 829                                 Assert.Fail ("#C1");
 830                         } catch (FormatException ex) {
 831                                 // Input string was not in a correct format
 832                                 Assert.AreEqual (typeof (FormatException), ex.GetType (), "#C2");
 833                                 Assert.IsNull (ex.InnerException, "#C3");
 834                                 Assert.IsNotNull (ex.Message, "#C4");
 835                         }
 836
 837
 838                         converter = new EnumConverter (typeof (E2));
 839
 840                         Assert.AreEqual ("Bb", converter.ConvertTo (null,
 841                                 CultureInfo.InvariantCulture, E2.Bb,
 842                                 typeof (string)), "#B1");
 843                         Assert.AreEqual ("Aa, Bb", converter.ConvertTo (null,
 844                                 CultureInfo.InvariantCulture, 3,
 845                                 typeof (string)), "#B2");
 846                         Assert.AreEqual (string.Empty, converter.ConvertTo (
 847                                 null, CultureInfo.InvariantCulture, null,
 848                                 typeof (string)), "#B3");
 849                         Assert.AreEqual ("Bb", converter.ConvertTo (
 850                                 null, CultureInfo.InvariantCulture, (E2) 2,
 851                                 typeof (string)), "#B4");
 852                         Assert.AreEqual ("Aa, Bb", converter.ConvertTo (
 853                                 null, CultureInfo.InvariantCulture, E.Dd,
 854                                 typeof (string)), "#B5");
 855                         Assert.AreEqual ("Bb, Dd", converter.ConvertTo (null,
 856                                 CultureInfo.InvariantCulture, E2.Bb | E2.Dd,
 857                                 typeof (string)), "#B6");
 858                 }
 859
 860                 enum E
 861                 {
 862                         Aa = 0,
 863                         Bb = 1,
 864                         Cc = 2,
 865                         Dd = 3,
 866                 }
 867
 868                 [Flags]
 869                 enum E2
 870                 {
 871                         Aa = 1,
 872                         Bb = 2,
 873                         Cc = 4,
 874                         Dd = 8,
 875                 }
 876
 877                 enum F : byte
 878                 {
 879                         Bb = 1,
 880                         Dd = 3
 881                 }
 882
 883                 [Flags]
 884                 enum F2 : byte
 885                 {
 886                         Bb = 2,
 887                         Dd = 8
 888                 }
 889         }
 890 }