mcs/class/Managed.Windows.Forms/Test/System.Windows.Forms/UpDownTest.cs

   1 //\r
   2 // \r
   3 //\r
   4 // Authors:\r
   5 //      Alexander Olk (alex.olk@googlemail.com)\r
   6 //      Gert Driesen (drieseng@users.sourceforge.net)\r
   7 //\r
   8 \r
   9 using System;\r
  10 using System.Collections;\r
  11 using System.Drawing;\r
  12 using System.Globalization;\r
  13 using System.Windows.Forms;\r
  14 \r
  15 using NUnit.Framework;\r
  16 \r
  17 namespace MonoTests.System.Windows.Forms\r
  18 {\r
  19         [TestFixture]\r
  20         public class UpDownTest\r
  21         {\r
  22                 [SetUp]\r
  23                 public void SetUp ()\r
  24                 {\r
  25                         Reset ();\r
  26                 }\r
  27 \r
  28                 private void Reset ()\r
  29                 {\r
  30                         selected_item_changed = 0;\r
  31                         text_changed = 0;\r
  32                         value_changed = 0;\r
  33                 }\r
  34 \r
  35                 [Test]\r
  36                 public void UpDownActiveControlTest ()\r
  37                 {\r
  38                         NumericUpDown n1 = new NumericUpDown ();\r
  39                         Assert.IsNull (n1.ActiveControl, "1");\r
  40                 }\r
  41 \r
  42                 [Test]\r
  43                 public void UpDownBasePropTest ()\r
  44                 {\r
  45                         NumericUpDown n1 = new NumericUpDown ();\r
  46                         \r
  47                         Assert.AreEqual (BorderStyle.Fixed3D, n1.BorderStyle, "#1");\r
  48                         Assert.AreEqual (true, n1.InterceptArrowKeys, "#2");\r
  49                         Assert.AreEqual (LeftRightAlignment.Right, n1.UpDownAlign, "#3");\r
  50                 }\r
  51 \r
  52                 [Test]\r
  53                 public void ToStringTest ()\r
  54                 {\r
  55                         NumericUpDown n1 = new NumericUpDown ();\r
  56 \r
  57                         Assert.AreEqual ("System.Windows.Forms.NumericUpDown, Minimum = 0, Maximum = 100", n1.ToString (), "1");\r
  58 \r
  59                         n1.Minimum = 0.33m;\r
  60                         n1.Maximum = 100.33m;\r
  61                         Assert.AreEqual (string.Format (CultureInfo.CurrentCulture,\r
  62                                 "System.Windows.Forms.NumericUpDown, Minimum = {0}, Maximum = {1}",\r
  63                                 0.33, 100.33), n1.ToString (), "2");\r
  64                 }\r
  65                 \r
  66                 [Test]\r
  67                 public void NumericUpDownStandardPropTest ()\r
  68                 {\r
  69                         NumericUpDown n1 = new NumericUpDown ();\r
  70                         \r
  71                         Assert.AreEqual (100, n1.Maximum, "#4");\r
  72                         Assert.AreEqual (0, n1.Minimum, "#5");\r
  73                         Assert.AreEqual (0, n1.Value, "#6");\r
  74                         Assert.AreEqual (0, n1.DecimalPlaces, "#7");\r
  75                         Assert.IsFalse (n1.Hexadecimal, "#8");\r
  76                         Assert.IsFalse (n1.ThousandsSeparator, "#9");\r
  77                         Assert.AreEqual (1, n1.Increment, "#10");\r
  78                 }\r
  79 \r
  80                 [Test]\r
  81                 public void NumericUpDownEnhancedPropTest ()\r
  82                 {\r
  83                         NumericUpDown n1 = new NumericUpDown ();\r
  84                         \r
  85                         n1.Minimum = 200;\r
  86                         Assert.AreEqual (200, n1.Maximum, "#11");\r
  87                         Assert.AreEqual (200, n1.Value, "#12");\r
  88                         \r
  89                         n1.Minimum = 100;\r
  90                         n1.Maximum = 50;\r
  91                         Assert.AreEqual (50, n1.Minimum, "#13");\r
  92                         \r
  93                         n1.Minimum = 0;\r
  94                         n1.Maximum = 100;\r
  95                         n1.Value = 90;\r
  96                         n1.Maximum = 50;\r
  97                         Assert.AreEqual (50, n1.Value, "#14");\r
  98                         \r
  99                         n1.Minimum = 0;\r
 100                         n1.Maximum = 100;\r
 101                         n1.Value = 90;\r
 102                         n1.DownButton ();\r
 103                         Assert.AreEqual (89, n1.Value, "#15");\r
 104                         \r
 105                         n1.UpButton ();\r
 106                         Assert.AreEqual (90, n1.Value, "#16");\r
 107                 }\r
 108 \r
 109                 [Test]\r
 110                 [Category ("NotWorking")]\r
 111                 public void NumericUpDownEditValidateTest ()\r
 112                 {\r
 113                         NumericNew nn = new NumericNew ();\r
 114                         Assert.IsTrue (nn.update_edit_text_called, "#17");\r
 115                         \r
 116                         Assert.IsFalse (nn.user_edit, "#18");\r
 117                         \r
 118                         nn.Reset ();\r
 119                         nn.user_edit = true;\r
 120                         nn.Text = "10";\r
 121                         Assert.IsTrue (nn.validate_edit_text_called, "#19");\r
 122                         Assert.IsTrue (nn.update_edit_text_called, "#20");\r
 123                         \r
 124                         nn.Reset ();\r
 125                         nn.user_edit = false;\r
 126                         nn.Text = "11";\r
 127                         Assert.IsTrue (nn.validate_edit_text_called, "#21");\r
 128                         Assert.IsTrue (nn.update_edit_text_called, "#22");\r
 129                         \r
 130                         nn.DownButton ();\r
 131                         Assert.AreEqual (10, nn.Value, "#23");\r
 132                 }\r
 133 \r
 134                 [Test]\r
 135                 [Category ("NotWorking")]\r
 136                 public void NumericUpDown_BeginInit ()\r
 137                 {\r
 138                         NumericNew nud = new NumericNew ();\r
 139                         nud.TextChanged += new EventHandler (NumericUpDown_TextChanged);\r
 140                         nud.ValueChanged += new EventHandler (NumericUpDown_ValueChanged);\r
 141                         Assert.AreEqual (2, nud.CallStack.Count, "#A1");\r
 142                         Assert.AreEqual ("ValidateEditText", nud.CallStack [0], "#A2");\r
 143                         Assert.AreEqual ("UpdateEditText", nud.CallStack [1], "#A3");\r
 144                         Assert.AreEqual (0, nud.Value, "#A4");\r
 145                         Assert.AreEqual (2, nud.CallStack.Count, "#A5");\r
 146                         Assert.AreEqual (0, value_changed, "#A6");\r
 147                         Assert.AreEqual (0, text_changed, "#A7");\r
 148 \r
 149                         nud.BeginInit ();\r
 150                         Assert.AreEqual (2, nud.CallStack.Count, "#B1");\r
 151                         nud.Value = 10;\r
 152                         Assert.AreEqual (3, nud.CallStack.Count, "#B2");\r
 153                         Assert.AreEqual ("UpdateEditText", nud.CallStack [2], "#B3");\r
 154                         Assert.AreEqual ("0", nud.Text, "#B4");\r
 155                         Assert.AreEqual (10, nud.Value, "#B5");\r
 156                         Assert.AreEqual (3, nud.CallStack.Count, "#B6");\r
 157                         Assert.AreEqual (1, value_changed, "#B7");\r
 158                         Assert.AreEqual (0, text_changed, "#B8");\r
 159                         nud.EndInit ();\r
 160                         Assert.AreEqual (4, nud.CallStack.Count, "#B9");\r
 161                         Assert.AreEqual ("UpdateEditText", nud.CallStack [3], "#B10");\r
 162                         Assert.AreEqual (1, text_changed, "#B11");\r
 163                         Assert.AreEqual ("10", nud.Text, "#B12");\r
 164                         Assert.AreEqual (10, nud.Value, "#B13");\r
 165                         Assert.AreEqual (4, nud.CallStack.Count, "#B14");\r
 166                         Assert.AreEqual (1, value_changed, "#B15");\r
 167                         Assert.AreEqual (1, text_changed, "#B16");\r
 168 \r
 169                         // multiple calls to BeginInit are undone by a single EndInit call\r
 170                         nud.BeginInit ();\r
 171                         nud.BeginInit ();\r
 172                         Assert.AreEqual (4, nud.CallStack.Count, "#C1");\r
 173                         nud.Value = 20;\r
 174                         Assert.AreEqual (5, nud.CallStack.Count, "#C2");\r
 175                         Assert.AreEqual ("UpdateEditText", nud.CallStack [4], "#C3");\r
 176                         Assert.AreEqual ("10", nud.Text, "#C4");\r
 177                         Assert.AreEqual (20, nud.Value, "#C5");\r
 178                         Assert.AreEqual (5, nud.CallStack.Count, "#C6");\r
 179                         Assert.AreEqual (2, value_changed, "#C7");\r
 180                         Assert.AreEqual (1, text_changed, "#C8");\r
 181                         nud.EndInit ();\r
 182                         Assert.AreEqual (6, nud.CallStack.Count, "#C9");\r
 183                         Assert.AreEqual ("UpdateEditText", nud.CallStack [5], "#C10");\r
 184                         Assert.AreEqual (2, text_changed, "#C11");\r
 185                         Assert.AreEqual ("20", nud.Text, "#C12");\r
 186                         Assert.AreEqual (20, nud.Value, "#C13");\r
 187                         Assert.AreEqual (6, nud.CallStack.Count, "#C14");\r
 188                         Assert.AreEqual (2, value_changed, "#C15");\r
 189                         Assert.AreEqual (2, text_changed, "#C16");\r
 190                 }\r
 191 \r
 192                 [Test]\r
 193                 [Category ("NotWorking")]\r
 194                 public void NumericUpDown_ChangingText ()\r
 195                 {\r
 196                         NumericNew nud = new NumericNew ();\r
 197                         nud.TextChanged += new EventHandler (NumericUpDown_TextChanged);\r
 198                         nud.ValueChanged += new EventHandler (NumericUpDown_ValueChanged);\r
 199                         Assert.IsFalse (nud.changing_text, "#A1");\r
 200                         Assert.IsFalse (nud.user_edit, "#A2");\r
 201                         Assert.AreEqual (0, text_changed, "#A3");\r
 202 \r
 203                         nud.Text = "1";\r
 204                         Assert.IsFalse (nud.changing_text, "#B1");\r
 205                         Assert.IsFalse (nud.user_edit, "#B2");\r
 206                         Assert.AreEqual (5, nud.CallStack.Count, "#B3");\r
 207                         Assert.AreEqual (1, text_changed, "#B4");\r
 208 \r
 209                         nud.changing_text = true;\r
 210                         nud.Text = "2";\r
 211                         Assert.IsFalse (nud.changing_text, "#C1");\r
 212                         Assert.IsFalse (nud.user_edit, "#C2");\r
 213                         Assert.AreEqual (5, nud.CallStack.Count, "#C3");\r
 214                         Assert.AreEqual (2, text_changed, "#C4");\r
 215                 }\r
 216 \r
 217                 [Test]\r
 218                 [Category ("NotWorking")]\r
 219                 public void NumericUpDown_EndInit ()\r
 220                 {\r
 221                         NumericNew nud = new NumericNew ();\r
 222                         nud.TextChanged += new EventHandler (NumericUpDown_TextChanged);\r
 223                         nud.ValueChanged += new EventHandler (NumericUpDown_ValueChanged);\r
 224                         Assert.AreEqual (2, nud.CallStack.Count, "#A1");\r
 225                         Assert.AreEqual ("ValidateEditText", nud.CallStack [0], "#A2");\r
 226                         Assert.AreEqual ("UpdateEditText", nud.CallStack [1], "#A3");\r
 227                         Assert.AreEqual (0, nud.Value, "#A4");\r
 228                         Assert.AreEqual (2, nud.CallStack.Count, "#A5");\r
 229                         Assert.AreEqual (0, value_changed, "#A6");\r
 230                         Assert.AreEqual (0, text_changed, "#A7");\r
 231 \r
 232                         // EndInit without corresponding BeginInit\r
 233                         nud.EndInit ();\r
 234                         Assert.AreEqual (3, nud.CallStack.Count, "#B1");\r
 235                         Assert.AreEqual ("UpdateEditText", nud.CallStack [1], "#B2");\r
 236                         Assert.AreEqual (0, nud.Value, "#B3");\r
 237                         Assert.AreEqual (3, nud.CallStack.Count, "#B4");\r
 238                         Assert.AreEqual (0, value_changed, "#B5");\r
 239                         Assert.AreEqual (0, text_changed, "#B6");\r
 240                 }\r
 241 \r
 242                 [Test]\r
 243                 [Category ("NotWorking")]\r
 244                 public void NumericUpDown_UpButton ()\r
 245                 {\r
 246                         NumericNew nud = new NumericNew ();\r
 247                         nud.TextChanged += new EventHandler (NumericUpDown_TextChanged);\r
 248                         nud.ValueChanged += new EventHandler (NumericUpDown_ValueChanged);\r
 249                         nud.UpButton ();\r
 250                         Assert.AreEqual (3, nud.CallStack.Count, "#A1");\r
 251                         Assert.AreEqual ("ValidateEditText", nud.CallStack [0], "#A2");\r
 252                         Assert.AreEqual ("UpdateEditText", nud.CallStack [1], "#A3");\r
 253                         Assert.AreEqual ("UpdateEditText", nud.CallStack [2], "#A4");\r
 254                         Assert.AreEqual (1, value_changed, "#A5");\r
 255                         Assert.AreEqual (1, nud.Value, "#A6");\r
 256                         Assert.AreEqual (3, nud.CallStack.Count, "#A7");\r
 257                         Assert.AreEqual (1, value_changed, "#A8");\r
 258                         Assert.AreEqual (1, text_changed, "#A9");\r
 259 \r
 260                         nud.Text = "5";\r
 261                         nud.UpButton ();\r
 262                         Assert.AreEqual (7, nud.CallStack.Count, "#B1");\r
 263                         Assert.AreEqual ("ValidateEditText", nud.CallStack [3], "#B2");\r
 264                         Assert.AreEqual ("UpdateEditText", nud.CallStack [4], "#B3");\r
 265                         Assert.AreEqual ("UpdateEditText", nud.CallStack [5], "#B4");\r
 266                         Assert.AreEqual ("UpdateEditText", nud.CallStack [6], "#B5");\r
 267                         Assert.AreEqual (3, value_changed, "#B6");\r
 268                         Assert.AreEqual (6, nud.Value, "#B7");\r
 269                         Assert.AreEqual ("6", nud.Text, "#B8");\r
 270                         Assert.AreEqual (7, nud.CallStack.Count, "#B9");\r
 271                         Assert.AreEqual (3, value_changed, "#B10");\r
 272                         Assert.AreEqual (3, text_changed, "#B11");\r
 273 \r
 274                         nud.Text = "7";\r
 275                         nud.user_edit = true;\r
 276                         nud.UpButton ();\r
 277                         Assert.AreEqual (11, nud.CallStack.Count, "#C1");\r
 278                         Assert.AreEqual ("ValidateEditText", nud.CallStack [7], "#C2");\r
 279                         Assert.AreEqual ("UpdateEditText", nud.CallStack [8], "#C3");\r
 280                         Assert.AreEqual ("UpdateEditText", nud.CallStack [9], "#C4");\r
 281                         Assert.AreEqual ("UpdateEditText", nud.CallStack [10], "#C5");\r
 282                         Assert.AreEqual (5, value_changed, "#C6");\r
 283                         Assert.AreEqual (8, nud.Value, "#C7");\r
 284                         Assert.AreEqual (11, nud.CallStack.Count, "#C8");\r
 285                         Assert.AreEqual (5, value_changed, "#C9");\r
 286                         Assert.AreEqual (5, text_changed, "#C10");\r
 287                         nud.user_edit = false;\r
 288                         Assert.AreEqual ("8", nud.Text, "#C11");\r
 289                         Assert.AreEqual (11, nud.CallStack.Count, "#C12");\r
 290                         Assert.AreEqual (5, value_changed, "#C13");\r
 291                         Assert.AreEqual (5, text_changed, "#C14");\r
 292 \r
 293                         nud.user_edit = false;\r
 294                         nud.Text = "555";\r
 295                         nud.user_edit = true;\r
 296                         nud.UpButton ();\r
 297                         Assert.AreEqual (14, nud.CallStack.Count, "#D1");\r
 298                         Assert.AreEqual ("ValidateEditText", nud.CallStack [11], "#D2");\r
 299                         Assert.AreEqual ("UpdateEditText", nud.CallStack [12], "#D3");\r
 300                         Assert.AreEqual ("UpdateEditText", nud.CallStack [13], "#D4");\r
 301                         Assert.AreEqual (6, value_changed, "#D5");\r
 302                         Assert.AreEqual (100, nud.Value, "#D6");\r
 303                         Assert.AreEqual (14, nud.CallStack.Count, "#D7");\r
 304                         Assert.AreEqual (6, value_changed, "#D8");\r
 305                         Assert.AreEqual (7, text_changed, "#D9");\r
 306                         nud.user_edit = false;\r
 307                         Assert.AreEqual ("100", nud.Text, "#D10");\r
 308                         Assert.AreEqual (14, nud.CallStack.Count, "#D11");\r
 309                         Assert.AreEqual (6, value_changed, "#D12");\r
 310                         Assert.AreEqual (7, text_changed, "#D13");\r
 311                 }\r
 312 \r
 313                 [Test]\r
 314                 [Category ("NotWorking")]\r
 315                 public void NumericUpDown_Value ()\r
 316                 {\r
 317                         // obtain Value when UserEdit is false\r
 318                         NumericNew nud = new NumericNew ();\r
 319                         nud.TextChanged += new EventHandler (NumericUpDown_TextChanged);\r
 320                         nud.ValueChanged += new EventHandler (NumericUpDown_ValueChanged);\r
 321                         Assert.AreEqual (2, nud.CallStack.Count, "#A1");\r
 322                         Assert.AreEqual ("ValidateEditText", nud.CallStack [0], "#A2");\r
 323                         Assert.AreEqual ("UpdateEditText", nud.CallStack [1], "#A3");\r
 324                         Assert.AreEqual (0, nud.Value, "#A4");\r
 325                         Assert.AreEqual (2, nud.CallStack.Count, "#A5");\r
 326                         Assert.AreEqual (0, value_changed, "#A6");\r
 327                         Assert.AreEqual (0, text_changed, "#A7");\r
 328 \r
 329                         // obtain Value when UserEdit is true\r
 330                         nud.user_edit = true;\r
 331                         Assert.AreEqual (2, nud.CallStack.Count, "#B1");\r
 332                         Assert.AreEqual (0, nud.Value, "#B2");\r
 333                         Assert.AreEqual (4, nud.CallStack.Count, "#B3");\r
 334                         Assert.AreEqual ("ValidateEditText", nud.CallStack [2], "#B4");\r
 335                         Assert.AreEqual ("UpdateEditText", nud.CallStack [3], "#B5");\r
 336                         Assert.AreEqual (0, value_changed, "#B6");\r
 337                         Assert.AreEqual (0, text_changed, "#B7");\r
 338 \r
 339                         // modify Value when UserEdit is false\r
 340                         nud.user_edit = false;\r
 341                         nud.Value = 10;\r
 342                         Assert.AreEqual (5, nud.CallStack.Count, "#C1");\r
 343                         Assert.AreEqual ("UpdateEditText", nud.CallStack [4], "#C2");\r
 344                         Assert.AreEqual (1, value_changed, "#C3");\r
 345                         Assert.AreEqual (1, text_changed, "#C4");\r
 346                         Assert.AreEqual (10, nud.Value, "#C5");\r
 347                         Assert.AreEqual (5, nud.CallStack.Count, "#C6");\r
 348                         Assert.AreEqual (1, value_changed, "#C7");\r
 349                         Assert.AreEqual (1, text_changed, "#C8");\r
 350 \r
 351                         // setting same Value\r
 352                         nud.Value = 10;\r
 353                         Assert.AreEqual (5, nud.CallStack.Count, "#D1");\r
 354                         Assert.AreEqual (1, value_changed, "#D2");\r
 355                         Assert.AreEqual (10, nud.Value, "#D3");\r
 356                         Assert.AreEqual (5, nud.CallStack.Count, "#D4");\r
 357                         Assert.AreEqual (1, value_changed, "#D5");\r
 358                         Assert.AreEqual (1, text_changed, "#D6");\r
 359 \r
 360                         // modify Value when UserEdit is true\r
 361                         nud.user_edit = true;\r
 362                         nud.Value = 20;\r
 363                         Assert.AreEqual (7, nud.CallStack.Count, "#E1");\r
 364                         Assert.AreEqual ("UpdateEditText", nud.CallStack [5], "#E2");\r
 365                         Assert.AreEqual ("UpdateEditText", nud.CallStack [6], "#E3");\r
 366                         Assert.AreEqual (3, value_changed, "#E4");\r
 367                         Assert.AreEqual (1, text_changed, "#E5");\r
 368                         nud.user_edit = false; // reset UserEdit to avoid Value being parsed from Text\r
 369                         Assert.AreEqual (10, nud.Value, "#E6");\r
 370                         Assert.AreEqual (7, nud.CallStack.Count, "#E7");\r
 371                         Assert.AreEqual (3, value_changed, "#E8");\r
 372                         Assert.AreEqual (1, text_changed, "#E9");\r
 373                 }\r
 374 \r
 375                 [Test]\r
 376                 [Category ("NotWorking")]\r
 377                 public void NumericUpDown_Value_Invalid ()\r
 378                 {\r
 379                         NumericNew nud = new NumericNew ();\r
 380 \r
 381                         try {\r
 382                                 nud.Value = 1000;\r
 383                                 Assert.Fail ("#A1");\r
 384 #if NET_2_0\r
 385                         } catch (ArgumentOutOfRangeException ex) {\r
 386                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");\r
 387                                 Assert.IsNotNull (ex.Message, "#A3");\r
 388                                 Assert.IsNotNull (ex.ParamName, "#A4");\r
 389                                 Assert.AreEqual ("Value", ex.ParamName, "#A5");\r
 390                                 Assert.IsNull (ex.InnerException, "#A6");\r
 391                         }\r
 392 #else\r
 393                         } catch (ArgumentException ex) {\r
 394                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");\r
 395                                 Assert.IsNotNull (ex.Message, "#A3");\r
 396                                 Assert.IsNull (ex.ParamName, "#A4");\r
 397                                 Assert.IsNull (ex.InnerException, "#A5");\r
 398                         }\r
 399 #endif\r
 400 \r
 401                         try {\r
 402                                 nud.Value = 1000;\r
 403                                 Assert.Fail ("#B1");\r
 404 #if NET_2_0\r
 405                         } catch (ArgumentOutOfRangeException ex) {\r
 406                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");\r
 407                                 Assert.IsNotNull (ex.Message, "#B3");\r
 408                                 Assert.IsNotNull (ex.ParamName, "#B4");\r
 409                                 Assert.AreEqual ("Value", ex.ParamName, "#B5");\r
 410                                 Assert.IsNull (ex.InnerException, "#B6");\r
 411                         }\r
 412 #else\r
 413                         } catch (ArgumentException ex) {\r
 414                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");\r
 415                                 Assert.IsNotNull (ex.Message, "#B3");\r
 416                                 Assert.IsNull (ex.ParamName, "#B4");\r
 417                                 Assert.IsNull (ex.InnerException, "#B5");\r
 418                         }\r
 419 #endif\r
 420 \r
 421                         try {\r
 422                                 nud.Value = -1000;\r
 423                                 Assert.Fail ("#C1");\r
 424 #if NET_2_0\r
 425                         } catch (ArgumentOutOfRangeException ex) {\r
 426                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");\r
 427                                 Assert.IsNotNull (ex.Message, "#C3");\r
 428                                 Assert.IsNotNull (ex.ParamName, "#C4");\r
 429                                 Assert.AreEqual ("Value", ex.ParamName, "#C5");\r
 430                                 Assert.IsNull (ex.InnerException, "#C6");\r
 431                         }\r
 432 #else\r
 433                         } catch (ArgumentException ex) {\r
 434                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");\r
 435                                 Assert.IsNotNull (ex.Message, "#C3");\r
 436                                 Assert.IsNull (ex.ParamName, "#C4");\r
 437                                 Assert.IsNull (ex.InnerException, "#C5");\r
 438                         }\r
 439 #endif\r
 440 \r
 441                         nud.BeginInit ();\r
 442 \r
 443                         nud.Value = 1000;\r
 444                         Assert.AreEqual (1000, nud.Value, "#D1");\r
 445                         nud.Value = 1000;\r
 446                         Assert.AreEqual (1000, nud.Value, "#D2");\r
 447                         nud.Value = -1000;\r
 448                         Assert.AreEqual (-1000, nud.Value, "#D3");\r
 449                         nud.EndInit ();\r
 450                         try {\r
 451                                 nud.Value = -1000;\r
 452                                 Assert.Fail ("#E1");\r
 453 #if NET_2_0\r
 454                         } catch (ArgumentOutOfRangeException ex) {\r
 455                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#E2");\r
 456                                 Assert.IsNotNull (ex.Message, "#E3");\r
 457                                 Assert.IsNotNull (ex.ParamName, "#E4");\r
 458                                 Assert.AreEqual ("Value", ex.ParamName, "#E5");\r
 459                                 Assert.IsNull (ex.InnerException, "#E6");\r
 460                         }\r
 461 #else\r
 462                         } catch (ArgumentException ex) {\r
 463                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#E2");\r
 464                                 Assert.IsNotNull (ex.Message, "#E3");\r
 465                                 Assert.IsNull (ex.ParamName, "#E4");\r
 466                                 Assert.IsNull (ex.InnerException, "#E5");\r
 467                         }\r
 468 #endif\r
 469                 }\r
 470 \r
 471                 void NumericUpDown_TextChanged (object sender, EventArgs e)\r
 472                 {\r
 473                         text_changed++;\r
 474                 }\r
 475 \r
 476                 void NumericUpDown_ValueChanged (object sender, EventArgs e)\r
 477                 {\r
 478                         value_changed++;\r
 479                 }\r
 480 \r
 481                 public class NumericNew : NumericUpDown\r
 482                 {\r
 483                         public bool update_edit_text_called = false;\r
 484                         public bool validate_edit_text_called = false;\r
 485                         private ArrayList _callStack = new ArrayList ();\r
 486 \r
 487                         public ArrayList CallStack {\r
 488                                 get { return _callStack; }\r
 489                         }\r
 490 \r
 491                         public bool user_edit {\r
 492                                 get {\r
 493                                         return UserEdit;\r
 494                                 }\r
 495                                 set {\r
 496                                         UserEdit = value;\r
 497                                 }\r
 498                         }\r
 499 \r
 500                         public bool changing_text {\r
 501                                 get {\r
 502                                         return ChangingText;\r
 503                                 }\r
 504                                 set {\r
 505                                         ChangingText = value;\r
 506                                 }\r
 507                         }\r
 508 \r
 509                         public void Reset ()\r
 510                         {\r
 511                                 update_edit_text_called = false;\r
 512                                 validate_edit_text_called = false;\r
 513                                 _callStack.Clear ();\r
 514                         }\r
 515 \r
 516                         protected override void UpdateEditText ()\r
 517                         {\r
 518                                 _callStack.Add ("UpdateEditText");\r
 519                                 update_edit_text_called = true;\r
 520                                 base.UpdateEditText ();\r
 521                         }\r
 522 \r
 523                         protected override void ValidateEditText ()\r
 524                         {\r
 525                                 _callStack.Add ("ValidateEditText");\r
 526                                 validate_edit_text_called = true;\r
 527                                 base.ValidateEditText ();\r
 528                         }\r
 529                 }\r
 530 \r
 531                 [Test]\r
 532                 public void DomainUpDownStandardPropTest ()\r
 533                 {\r
 534                         DomainUpDown d1 = new DomainUpDown ();\r
 535                         \r
 536                         Assert.AreEqual (0, d1.Items.Count, "#24");\r
 537                         Assert.AreEqual (false, d1.Sorted, "#25");\r
 538                         Assert.AreEqual (false, d1.Wrap, "#26");\r
 539                         Assert.AreEqual ("System.Windows.Forms.DomainUpDown, Items.Count: 0, SelectedIndex: -1", d1.ToString (), "#26a");\r
 540                         \r
 541                         d1.Items.Add ("item1");\r
 542                         d1.Items.Add ("item2");\r
 543                         d1.Items.Add ("item3");\r
 544                         d1.Items.Add ("item4");\r
 545                         \r
 546                         Assert.AreEqual (4, d1.Items.Count, "#27");\r
 547                         Assert.AreEqual (-1, d1.SelectedIndex, "#28");\r
 548                         Assert.AreEqual (null, d1.SelectedItem, "#29");\r
 549                 }\r
 550                 \r
 551                 [Test]\r
 552                 [Category ("NotWorking")]\r
 553                 public void DomainUpDownEnhancedPropTest ()\r
 554                 {\r
 555                         DomainUpDown d1 = new DomainUpDown ();\r
 556                         \r
 557                         d1.Items.Add ("item1");\r
 558                         d1.Items.Add ("item2");\r
 559                         d1.Items.Add ("item3");\r
 560                         d1.Items.Add ("item4");\r
 561                                 \r
 562                         d1.SelectedIndex = 3;\r
 563                         Assert.AreEqual (3, d1.SelectedIndex, "#30");\r
 564                         \r
 565                         d1.Items.Remove ("item1");\r
 566                         \r
 567                         Assert.AreEqual (3, d1.Items.Count, "#31");\r
 568                         Assert.AreEqual (2, d1.SelectedIndex, "#32");\r
 569                         \r
 570                         d1.Items.Remove ("item4");\r
 571                         Assert.AreEqual (2, d1.Items.Count, "#33");\r
 572                         Assert.AreEqual (-1, d1.SelectedIndex, "#34");\r
 573                         Assert.AreEqual (null, d1.SelectedItem, "#35");\r
 574                         \r
 575                         // strange, ArgumentOutOfRangeException on windows\r
 576                         // d1.SelectedIndex = 1;\r
 577                         //Assert.AreEqual (1, d1.SelectedIndex, "#36");\r
 578                         \r
 579                         d1.Items.Clear ();\r
 580                         Assert.AreEqual (0, d1.Items.Count, "#37");\r
 581                         Assert.AreEqual (-1, d1.SelectedIndex, "#38");\r
 582                         Assert.AreEqual (null, d1.SelectedItem, "#39");\r
 583                         \r
 584                         d1.Items.Add ("zitem1");\r
 585                         d1.Items.Add ("oitem2");\r
 586                         d1.Items.Add ("mitem3");\r
 587                         d1.Items.Add ("aitem4");\r
 588                         \r
 589                         d1.SelectedIndex = 0;\r
 590                         Assert.AreEqual ("zitem1", d1.SelectedItem.ToString (), "#40");\r
 591                         \r
 592                         d1.Sorted = true;\r
 593                         Assert.AreEqual ("aitem4", d1.SelectedItem.ToString (), "#41");\r
 594                         Assert.AreEqual ("aitem4", d1.Items[0].ToString (), "#42");\r
 595                         \r
 596                         d1.Items.Clear ();\r
 597                         d1.Items.Add ("item1");\r
 598                         d1.Items.Add ("item2");\r
 599                         d1.Items.Add ("item3");\r
 600                         d1.Items.Add ("item4");\r
 601                         d1.SelectedIndex = 0;\r
 602                         \r
 603                         d1.UpButton ();\r
 604                         Assert.AreEqual ("item1", d1.SelectedItem.ToString (), "#43");\r
 605                         \r
 606                         d1.DownButton ();\r
 607                         Assert.AreEqual ("item2", d1.SelectedItem.ToString (), "#44");\r
 608                         \r
 609                         d1.SelectedIndex = 0;\r
 610                         d1.Wrap = true;\r
 611                         d1.UpButton ();\r
 612                         Assert.AreEqual ("item4", d1.SelectedItem.ToString (), "#45");\r
 613                         \r
 614                         d1.DownButton ();\r
 615                         Assert.AreEqual ("item1", d1.SelectedItem.ToString (), "#46");\r
 616                         \r
 617                         d1.Text = "item3";\r
 618                         Assert.AreEqual (null, d1.SelectedItem, "#47");\r
 619                 }\r
 620 \r
 621                 [Test]\r
 622                 [Category ("NotWorking")]\r
 623                 public void DomainUpDown_SelectedIndex ()\r
 624                 {\r
 625                         MockDomainUpDown dud = new MockDomainUpDown ();\r
 626                         dud.SelectedItemChanged += new EventHandler (DomainUpDown_SelectedItemChanged);\r
 627                         dud.TextChanged += new EventHandler (DomainUpDown_TextChanged);\r
 628                         Assert.AreEqual (1, dud.CallStack.Count, "#A1");\r
 629                         Assert.AreEqual ("set_Text: (0)", dud.CallStack [0], "#A2");\r
 630                         Assert.AreEqual (0, selected_item_changed, "#A3");\r
 631                         Assert.AreEqual (0, text_changed, "#A4");\r
 632                         Assert.AreEqual (-1, dud.SelectedIndex, "#A5");\r
 633 \r
 634                         string itemA = "itemA";\r
 635                         dud.Items.Add (itemA);\r
 636                         Assert.AreEqual (1, dud.CallStack.Count, "#B1");\r
 637                         Assert.AreEqual (0, selected_item_changed, "#B2");\r
 638                         Assert.AreEqual (0, text_changed, "#B3");\r
 639                         Assert.AreEqual (-1, dud.SelectedIndex, "#B4");\r
 640 \r
 641                         dud.SelectedIndex = 0;\r
 642                         Assert.AreEqual (4, dud.CallStack.Count, "#C1");\r
 643                         Assert.AreEqual ("UpdateEditText", dud.CallStack [1], "#C2");\r
 644                         Assert.AreEqual ("set_Text:itemA (5)", dud.CallStack [2], "#C3");\r
 645                         Assert.AreEqual ("OnChanged", dud.CallStack [3], "#C4");\r
 646                         Assert.AreEqual (1, selected_item_changed, "#C5");\r
 647                         Assert.AreEqual (1, text_changed, "#C6");\r
 648                         Assert.AreEqual (0, dud.SelectedIndex, "#C7");\r
 649 \r
 650                         dud.SelectedIndex = 0;\r
 651                         Assert.AreEqual (4, dud.CallStack.Count, "#D1");\r
 652                         Assert.AreEqual (1, selected_item_changed, "#D2");\r
 653                         Assert.AreEqual (1, text_changed, "#D3");\r
 654                         Assert.AreEqual (0, dud.SelectedIndex, "#D4");\r
 655 \r
 656                         dud.SelectedIndex = -1;\r
 657                         Assert.AreEqual (4, dud.CallStack.Count, "#E1");\r
 658                         Assert.AreEqual (1, selected_item_changed, "#E2");\r
 659                         Assert.AreEqual (1, text_changed, "#E3");\r
 660                         Assert.AreEqual (-1, dud.SelectedIndex, "#E4");\r
 661 \r
 662                         dud.SelectedIndex = 0;\r
 663                         Assert.AreEqual (6, dud.CallStack.Count, "#F1");\r
 664                         Assert.AreEqual ("UpdateEditText", dud.CallStack [4], "#F2");\r
 665                         Assert.AreEqual ("set_Text:itemA (5)", dud.CallStack [5], "#F3");\r
 666                         Assert.AreEqual (1, selected_item_changed, "#F4");\r
 667                         Assert.AreEqual (1, text_changed, "#F5");\r
 668                         Assert.AreEqual (0, dud.SelectedIndex, "#F6");\r
 669 \r
 670                         string itemAbis = "itemA";\r
 671                         dud.Items.Add (itemAbis);\r
 672                         Assert.AreEqual (6, dud.CallStack.Count, "#G1");\r
 673                         Assert.AreEqual (1, selected_item_changed, "#G2");\r
 674                         Assert.AreEqual (1, text_changed, "#G3");\r
 675                         Assert.AreEqual (0, dud.SelectedIndex, "#G4");\r
 676 \r
 677                         dud.SelectedIndex = 1;\r
 678                         Assert.AreEqual (8, dud.CallStack.Count, "#H1");\r
 679                         Assert.AreEqual ("UpdateEditText", dud.CallStack [6], "#H2");\r
 680                         Assert.AreEqual ("set_Text:itemA (5)", dud.CallStack [7], "#H3");\r
 681                         Assert.AreEqual (1, selected_item_changed, "#H4");\r
 682                         Assert.AreEqual (1, text_changed, "#H5");\r
 683                         Assert.AreEqual (1, dud.SelectedIndex, "#H6");\r
 684 \r
 685                         string itemB = "itemB";\r
 686                         dud.Items.Add (itemB);\r
 687                         Assert.AreEqual (8, dud.CallStack.Count, "#I1");\r
 688                         Assert.AreEqual (1, selected_item_changed, "#I2");\r
 689                         Assert.AreEqual (1, text_changed, "#I3");\r
 690                         Assert.AreEqual (1, dud.SelectedIndex, "#I4");\r
 691 \r
 692                         dud.SelectedIndex = 2;\r
 693                         Assert.AreEqual (11, dud.CallStack.Count, "#J1");\r
 694                         Assert.AreEqual ("UpdateEditText", dud.CallStack [8], "#J2");\r
 695                         Assert.AreEqual ("set_Text:itemB (5)", dud.CallStack [9], "#J3");\r
 696                         Assert.AreEqual ("OnChanged", dud.CallStack [10], "#J4");\r
 697                         Assert.AreEqual (2, selected_item_changed, "#J5");\r
 698                         Assert.AreEqual (2, text_changed, "#J6");\r
 699                         Assert.AreEqual (2, dud.SelectedIndex, "#J7");\r
 700                 }\r
 701 \r
 702                 [Test]\r
 703                 [Category ("NotWorking")]\r
 704                 public void DomainUpDown_Items_Add ()\r
 705                 {\r
 706                         MockItem itemA = new MockItem ("itemA");\r
 707                         MockItem itemB = new MockItem ("itemB");\r
 708                         MockItem itemC = new MockItem ("itemC");\r
 709 \r
 710                         MockDomainUpDown dud = new MockDomainUpDown ();\r
 711                         dud.SelectedItemChanged += new EventHandler (DomainUpDown_SelectedItemChanged);\r
 712                         dud.TextChanged += new EventHandler (DomainUpDown_TextChanged);\r
 713                         dud.Reset ();\r
 714 \r
 715                         dud.Items.Add (itemA);\r
 716                         Assert.AreEqual (0, dud.CallStack.Count, "#A1");\r
 717                         Assert.AreEqual (0, selected_item_changed, "#A2");\r
 718                         Assert.AreEqual (0, text_changed, "#A3");\r
 719                         Assert.AreEqual (-1, dud.SelectedIndex, "#A4");\r
 720                         Assert.AreEqual (string.Empty, dud.Text, "#A5");\r
 721                         Assert.AreEqual (1, dud.Items.Count, "#A6");\r
 722                         Assert.AreSame (itemA, dud.Items [0], "#A7");\r
 723 \r
 724                         dud.Items.Add (itemC);\r
 725                         Assert.AreEqual (0, dud.CallStack.Count, "#B1");\r
 726                         Assert.AreEqual (0, selected_item_changed, "#B2");\r
 727                         Assert.AreEqual (0, text_changed, "#B3");\r
 728                         Assert.AreEqual (-1, dud.SelectedIndex, "#B4");\r
 729                         Assert.AreEqual (string.Empty, dud.Text, "#B5");\r
 730                         Assert.AreEqual (2, dud.Items.Count, "#B6");\r
 731                         Assert.AreSame (itemC, dud.Items [1], "#B7");\r
 732 \r
 733                         dud.Items.Add (itemA);\r
 734                         Assert.AreEqual (0, dud.CallStack.Count, "#C1");\r
 735                         Assert.AreEqual (0, selected_item_changed, "#C2");\r
 736                         Assert.AreEqual (0, text_changed, "#C3");\r
 737                         Assert.AreEqual (-1, dud.SelectedIndex, "#C4");\r
 738                         Assert.AreEqual (string.Empty, dud.Text, "#C5");\r
 739                         Assert.AreEqual (3, dud.Items.Count, "#C6");\r
 740                         Assert.AreSame (itemA, dud.Items [2], "#C7");\r
 741 \r
 742                         dud.Sorted = true;\r
 743                         Assert.AreEqual (3, dud.Items.Count, "#D1");\r
 744                         Assert.AreSame (itemA, dud.Items [0], "#D2");\r
 745                         Assert.AreSame (itemA, dud.Items [1], "#D3");\r
 746                         Assert.AreSame (itemC, dud.Items [2], "#D4");\r
 747 \r
 748                         // adding item causes re-sort\r
 749                         dud.Items.Add (itemB);\r
 750                         Assert.AreEqual (0, dud.CallStack.Count, "#E1");\r
 751                         Assert.AreEqual (0, selected_item_changed, "#E2");\r
 752                         Assert.AreEqual (0, text_changed, "#E3");\r
 753                         Assert.AreEqual (-1, dud.SelectedIndex, "#E4");\r
 754                         Assert.AreEqual (string.Empty, dud.Text, "#E5");\r
 755                         Assert.AreEqual (4, dud.Items.Count, "#E6");\r
 756                         Assert.AreSame (itemA, dud.Items [0], "#E7");\r
 757                         Assert.AreSame (itemA, dud.Items [1], "#E8");\r
 758                         Assert.AreSame (itemB, dud.Items [2], "#E9");\r
 759                         Assert.AreSame (itemC, dud.Items [3], "#E10");\r
 760                 }\r
 761 \r
 762                 [Test]\r
 763                 [Category ("NotWorking")]\r
 764                 public void DomainUpDown_Items_Indexer ()\r
 765                 {\r
 766                         MockItem itemA = new MockItem ("itemA");\r
 767                         MockItem itemAbis = new MockItem ("itemA");\r
 768                         MockItem itemB = new MockItem ("itemB");\r
 769                         MockItem itemC = new MockItem ("itemC");\r
 770                         MockItem itemD = new MockItem ("itemD");\r
 771                         MockItem itemE = new MockItem ("itemE");\r
 772 \r
 773                         TestHelper.RemoveWarning (itemAbis);\r
 774                         \r
 775                         MockDomainUpDown dud = new MockDomainUpDown ();\r
 776                         dud.SelectedItemChanged += new EventHandler (DomainUpDown_SelectedItemChanged);\r
 777                         dud.TextChanged += new EventHandler (DomainUpDown_TextChanged);\r
 778                         dud.Items.Add (itemC);\r
 779                         dud.Items.Add (itemA);\r
 780                         dud.Items.Add (itemB);\r
 781                         dud.Items.Add (itemA);\r
 782                         dud.SelectedIndex = 1;\r
 783                         dud.Reset ();\r
 784                         Reset ();\r
 785 \r
 786                         Assert.AreSame (itemC, dud.Items [0], "#A1");\r
 787                         Assert.AreSame (itemA, dud.Items [1], "#A2");\r
 788                         Assert.AreSame (itemB, dud.Items [2], "#A3");\r
 789                         Assert.AreSame (itemA, dud.Items [3], "#A4");\r
 790                         Assert.AreEqual (itemA.Text, dud.Text, "#A5");\r
 791 \r
 792                         dud.Items [3] = itemD;\r
 793                         Assert.AreEqual (0, dud.CallStack.Count, "#B1");\r
 794                         Assert.AreEqual (0, selected_item_changed, "#B2");\r
 795                         Assert.AreEqual (0, text_changed, "#B3");\r
 796                         Assert.AreEqual (1, dud.SelectedIndex, "#B4");\r
 797                         Assert.AreEqual (itemA.Text, dud.Text, "#B5");\r
 798 \r
 799                         dud.Items [1] = itemE;\r
 800                         Assert.AreEqual (3, dud.CallStack.Count, "#C1");\r
 801                         Assert.AreEqual ("UpdateEditText", dud.CallStack [0], "#C2");\r
 802                         Assert.AreEqual ("set_Text:itemE (5)", dud.CallStack [1], "#C3");\r
 803                         Assert.AreEqual ("OnChanged", dud.CallStack [2], "#C4");\r
 804                         Assert.AreEqual (1, selected_item_changed, "#C5");\r
 805                         Assert.AreEqual (1, text_changed, "#C6");\r
 806                         Assert.AreEqual (1, dud.SelectedIndex, "#C7");\r
 807                         Assert.AreEqual (itemE.Text, dud.Text, "#C8");\r
 808 \r
 809                         dud.Sorted = true;\r
 810                         Assert.AreEqual (8, dud.CallStack.Count, "#D1");\r
 811                         Assert.AreEqual ("UpdateEditText", dud.CallStack [3], "#D2");\r
 812                         Assert.AreEqual ("set_Text:itemC (5)", dud.CallStack [4], "#D3");\r
 813                         Assert.AreEqual ("OnChanged", dud.CallStack [5], "#D4");\r
 814                         Assert.AreEqual ("UpdateEditText", dud.CallStack [6], "#D5");\r
 815                         Assert.AreEqual ("set_Text:itemC (5)", dud.CallStack [7], "#D6");\r
 816                         Assert.AreEqual (2, selected_item_changed, "#D7");\r
 817                         Assert.AreEqual (2, text_changed, "#D8");\r
 818                         Assert.AreEqual (1, dud.SelectedIndex, "#D9");\r
 819                         Assert.AreEqual (itemC.Text, dud.Text, "#D10");\r
 820                         Assert.AreSame (itemB, dud.Items [0], "#D11");\r
 821                         Assert.AreSame (itemC, dud.Items [1], "#D12");\r
 822                         Assert.AreSame (itemD, dud.Items [2], "#D13");\r
 823                         Assert.AreSame (itemE, dud.Items [3], "#D14");\r
 824 \r
 825                         dud.Items [3] = itemA;\r
 826                         Assert.AreEqual (13, dud.CallStack.Count, "#E1");\r
 827                         Assert.AreEqual ("UpdateEditText", dud.CallStack [8], "#E2");\r
 828                         Assert.AreEqual ("set_Text:itemB (5)", dud.CallStack [9], "#E3");\r
 829                         Assert.AreEqual ("OnChanged", dud.CallStack [10], "#E4");\r
 830                         Assert.AreEqual ("UpdateEditText", dud.CallStack [11], "#E5");\r
 831                         Assert.AreEqual ("set_Text:itemB (5)", dud.CallStack [12], "#E6");\r
 832                         Assert.AreEqual (3, selected_item_changed, "#E7");\r
 833                         Assert.AreEqual (3, text_changed, "#E8");\r
 834                         Assert.AreEqual (1, dud.SelectedIndex, "#E9");\r
 835                         Assert.AreEqual (itemB.Text, dud.Text, "#E10");\r
 836                 }\r
 837 \r
 838                 [Test]\r
 839                 [Category ("NotWorking")]\r
 840                 public void DomainUpDown_Items_Indexer_Null ()\r
 841                 {\r
 842                         MockDomainUpDown dud = new MockDomainUpDown ();\r
 843                         dud.Items.Add ("itemA");\r
 844                         dud.Items.Add ("itemB");\r
 845                         dud.Items.Add ("itemC");\r
 846                         dud.SelectedIndex = 0;\r
 847 \r
 848                         // TODO: report as MS bug\r
 849                         dud.Items [2] = null;\r
 850                         dud.Items [1] = null;\r
 851                         try {\r
 852                                 dud.Items [0] = null;\r
 853                                 Assert.Fail ();\r
 854                         } catch (NullReferenceException ex) {\r
 855                                 TestHelper.RemoveWarning (ex);\r
 856                         }\r
 857                 }\r
 858 \r
 859                 [Test]\r
 860                 public void DomainUpDown_Items_Insert ()\r
 861                 {\r
 862                         // TODO\r
 863                 }\r
 864 \r
 865                 [Test]\r
 866                 public void DomainUpDown_Items_Remove ()\r
 867                 {\r
 868                         // TODO\r
 869                 }\r
 870 \r
 871                 [Test]\r
 872                 public void DomainUpDown_Items_RemoveAt ()\r
 873                 {\r
 874                         // TODO\r
 875                 }\r
 876 \r
 877                 [Test]\r
 878                 [Category ("NotWorking")]\r
 879                 public void DomainUpDown_SelectedIndex_Invalid ()\r
 880                 {\r
 881                         DomainUpDown dud = new DomainUpDown ();\r
 882                         dud.Items.Add ("item1");\r
 883 \r
 884                         try {\r
 885                                 dud.SelectedIndex = -2;\r
 886                                 Assert.Fail ("#A1");\r
 887 #if NET_2_0\r
 888                         } catch (ArgumentOutOfRangeException ex) {\r
 889                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");\r
 890                                 Assert.IsNotNull (ex.Message, "#A3");\r
 891                                 Assert.IsNotNull (ex.ParamName, "#A4");\r
 892                                 Assert.AreEqual ("SelectedIndex", ex.ParamName, "#A5");\r
 893                                 Assert.IsNull (ex.InnerException, "#A6");\r
 894                         }\r
 895 #else\r
 896                         } catch (ArgumentException ex) {\r
 897                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");\r
 898                                 Assert.IsNotNull (ex.Message, "#A3");\r
 899                                 Assert.IsNull (ex.ParamName, "#A4");\r
 900                                 Assert.IsNull (ex.InnerException, "#A5");\r
 901                         }\r
 902 #endif\r
 903 \r
 904                         try {\r
 905                                 dud.SelectedIndex = 1;\r
 906                                 Assert.Fail ("#B1");\r
 907 #if NET_2_0\r
 908                         } catch (ArgumentOutOfRangeException ex) {\r
 909                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");\r
 910                                 Assert.IsNotNull (ex.Message, "#A3");\r
 911                                 Assert.IsNotNull (ex.ParamName, "#A4");\r
 912                                 Assert.AreEqual ("SelectedIndex", ex.ParamName, "#A5");\r
 913                                 Assert.IsNull (ex.InnerException, "#A6");\r
 914                         }\r
 915 #else\r
 916                         } catch (ArgumentException ex) {\r
 917                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");\r
 918                                 Assert.IsNotNull (ex.Message, "#B3");\r
 919                                 Assert.IsNull (ex.ParamName, "#B4");\r
 920                                 Assert.IsNull (ex.InnerException, "#B5");\r
 921                         }\r
 922 #endif\r
 923                 }\r
 924 \r
 925                 [Test]\r
 926                 public void DomainUpDown_SelectedItem_Null ()\r
 927                 {\r
 928                         DomainUpDown dud = new DomainUpDown ();\r
 929                         dud.Items.Add ("item1");\r
 930                         dud.SelectedIndex = 0;\r
 931                         Assert.AreEqual (0, dud.SelectedIndex, "#A1");\r
 932                         Assert.IsNotNull (dud.SelectedItem, "#A2");\r
 933 \r
 934                         dud.SelectedItem = null;\r
 935                         Assert.AreEqual (-1, dud.SelectedIndex, "#B1");\r
 936                         Assert.IsNull (dud.SelectedItem, "#B2");\r
 937                 }\r
 938 \r
 939                 void DomainUpDown_TextChanged (object sender, EventArgs e)\r
 940                 {\r
 941                         text_changed++;\r
 942                 }\r
 943 \r
 944                 void DomainUpDown_SelectedItemChanged (object sender, EventArgs e)\r
 945                 {\r
 946                         selected_item_changed++;\r
 947                 }\r
 948 \r
 949                 public class MockDomainUpDown : DomainUpDown\r
 950                 {\r
 951                         private ArrayList _callStack = new ArrayList ();\r
 952 \r
 953                         public ArrayList CallStack {\r
 954                                 get { return _callStack; }\r
 955                         }\r
 956 \r
 957                         public bool user_edit {\r
 958                                 get {\r
 959                                         return UserEdit;\r
 960                                 }\r
 961                                 set {\r
 962                                         UserEdit = value;\r
 963                                 }\r
 964                         }\r
 965 \r
 966                         public bool changing_text {\r
 967                                 get {\r
 968                                         return ChangingText;\r
 969                                 }\r
 970                                 set {\r
 971                                         ChangingText = value;\r
 972                                 }\r
 973                         }\r
 974 \r
 975                         public void Reset ()\r
 976                         {\r
 977                                 _callStack.Clear ();\r
 978                         }\r
 979 \r
 980                         public override string Text {\r
 981                                 get {\r
 982                                         return base.Text;\r
 983                                 }\r
 984                                 set {\r
 985                                         if (value == null)\r
 986                                                 _callStack.Add ("set_Text:null");\r
 987                                         else\r
 988                                                 _callStack.Add ("set_Text:" + value + " (" + value.Length + ")");\r
 989                                         base.Text = value;\r
 990                                 }\r
 991                         }\r
 992 \r
 993                         protected override void OnChanged (object source, EventArgs e)\r
 994                         {\r
 995                                 _callStack.Add ("OnChanged");\r
 996                                 base.OnChanged (source, e);\r
 997                         }\r
 998 \r
 999                         protected override void UpdateEditText ()\r
1000                         {\r
1001                                 _callStack.Add ("UpdateEditText");\r
1002                                 base.UpdateEditText ();\r
1003                         }\r
1004 \r
1005                         protected override void ValidateEditText ()\r
1006                         {\r
1007                                 _callStack.Add ("ValidateEditText");\r
1008                                 base.ValidateEditText ();\r
1009                         }\r
1010                 }\r
1011 \r
1012                 private int selected_item_changed = 0;\r
1013                 private int text_changed = 0;\r
1014                 private int value_changed = 0;\r
1015 \r
1016                 public class MockItem\r
1017                 {\r
1018                         public MockItem (string text)\r
1019                         {\r
1020                                 _text = text;\r
1021                         }\r
1022 \r
1023                         public string Text {\r
1024                                 get { return _text; }\r
1025                         }\r
1026 \r
1027                         public override string ToString ()\r
1028                         {\r
1029                                 return _text;\r
1030                         }\r
1031 \r
1032                         private readonly string _text;\r
1033                 }\r
1034         }\r
1035 }\r