mcs/class/System.Web/Test/System.Web.UI.WebControls/BaseCompareValidatorTest.cs

   1 //
   2 // Tests for System.Web.UI.WebControls.BaseCompareValidator
   3 //
   4 // Author:
   5 //      Chris Toshok (toshok@novell.com)
   6 //      Yoni Klain   (Yonik@mainsoft.com)
   7 //
   8
   9 //
  10 // Copyright (C) 2005 Novell, Inc (http://www.novell.com)
  11 //
  12 // Permission is hereby granted, free of charge, to any person obtaining
  13 // a copy of this software and associated documentation files (the
  14 // "Software"), to deal in the Software without restriction, including
  15 // without limitation the rights to use, copy, modify, merge, publish,
  16 // distribute, sublicense, and/or sell copies of the Software, and to
  17 // permit persons to whom the Software is furnished to do so, subject to
  18 // the following conditions:
  19 //
  20 // The above copyright notice and this permission notice shall be
  21 // included in all copies or substantial portions of the Software.
  22 //
  23 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  27 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  28 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  29 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  30 //
  31
  32 using NUnit.Framework;
  33 using System;
  34 using System.IO;
  35 using System.Globalization;
  36 using System.Threading;
  37 using System.Web;
  38 using System.Web.UI;
  39 using System.Web.UI.WebControls;
  40 using MonoTests.SystemWeb.Framework;
  41
  42 namespace MonoTests.System.Web.UI.WebControls
  43 {
  44         class BaseCompareValidatorPoker : BaseCompareValidator {
  45                 public BaseCompareValidatorPoker ()
  46                 {
  47                         TrackViewState ();
  48                 }
  49
  50                 public object SaveState ()
  51                 {
  52                         return SaveViewState ();
  53                 }
  54
  55                 public void LoadState (object o)
  56                 {
  57                         LoadViewState (o);
  58                 }
  59
  60                 public void CheckControlProperties ()
  61                 {
  62                         ControlPropertiesValid ();
  63                 }
  64
  65                 protected override bool EvaluateIsValid ()
  66                 {
  67                         return true;
  68                 }
  69
  70                 public new bool Compare(string leftText,
  71                                         string rightText,
  72                                         ValidationCompareOperator op,
  73                                         ValidationDataType type)
  74                 {
  75                         return BaseCompareValidator.Compare (leftText,
  76                                                              rightText,
  77                                                              op, type);
  78                 }
  79
  80                 public new bool Convert (string text,
  81                                          ValidationDataType type,
  82                                          out object value)
  83                 {
  84                         return BaseCompareValidator.Convert (text, type, out value);
  85                 }
  86
  87                 public new bool CanConvert(string text,
  88                                            ValidationDataType type)
  89                 {
  90                         return BaseCompareValidator.CanConvert (text, type);
  91                 }
  92
  93                 public new string GetDateElementOrder ()
  94                 {
  95                         return BaseCompareValidator.GetDateElementOrder();
  96                 }
  97
  98                 public new int GetFullYear (int two_digit_year)
  99                 {
 100                         return BaseCompareValidator.GetFullYear (two_digit_year);
 101                 }
 102
 103                 public int GetCutoffYear ()
 104                 {
 105                         return BaseCompareValidator.CutoffYear;
 106                 }
 107         }
 108
 109         [TestFixture]
 110         public class BaseCompareValidatorTest : ValidatorTest
 111         {
 112
 113                 [Test]
 114                 public void DefaultProperties ()
 115                 {
 116                         BaseCompareValidatorPoker p = new BaseCompareValidatorPoker ();
 117
 118                         Assert.AreEqual (ValidationDataType.String, p.Type, "CultureInvariantValues");
 119                         Assert.AreEqual (false, p.CultureInvariantValues, "CultureInvariantValues");
 120                 }
 121
 122                 [Test]
 123                 public void AssignProperties ()
 124                 {
 125                         BaseCompareValidatorPoker p = new BaseCompareValidatorPoker ();
 126
 127                         p.Type = ValidationDataType.Double;
 128                         Assert.AreEqual (ValidationDataType.Double, p.Type, "CultureInvariantValues");
 129                         p.CultureInvariantValues = true;
 130                         Assert.AreEqual (true, p.CultureInvariantValues, "CultureInvariantValues");
 131                 }
 132
 133                 [Test]
 134                 public void ViewState ()
 135                 {
 136                         BaseCompareValidatorPoker p = new BaseCompareValidatorPoker ();
 137
 138                         p.Type = ValidationDataType.Double;
 139                         p.CultureInvariantValues = true;
 140
 141                         BaseCompareValidatorPoker copy = new BaseCompareValidatorPoker ();
 142                         copy.LoadState (p.SaveState ());
 143
 144                         Assert.AreEqual (ValidationDataType.Double, copy.Type, "A1");
 145                         Assert.AreEqual (true, copy.CultureInvariantValues, "A1");
 146                 }
 147
 148                 [Test]
 149                 public void CanConvert ()
 150                 {
 151                         CultureInfo currentCulture = Thread.CurrentThread.CurrentCulture;
 152                         CultureInfo currentUICulture = Thread.CurrentThread.CurrentUICulture;
 153
 154                         try {
 155                                 CultureInfo ci = CultureInfo.GetCultureInfo ("en-US");
 156                                 Thread.CurrentThread.CurrentCulture = ci;
 157                                 Thread.CurrentThread.CurrentUICulture = ci;
 158                                 RunCanConvertTests ();
 159                         } finally {
 160                                 Thread.CurrentThread.CurrentCulture = currentCulture;
 161                                 Thread.CurrentThread.CurrentUICulture = currentUICulture;
 162                         }
 163                 }
 164
 165                 void RunCanConvertTests ()
 166                 {
 167                         BaseCompareValidatorPoker p = new BaseCompareValidatorPoker ();
 168
 169                         /* an integer constant */
 170                         Assert.IsTrue (p.CanConvert ("10", ValidationDataType.String), "B1");
 171                         Assert.IsTrue (p.CanConvert ("10", ValidationDataType.Integer), "B2");
 172                         Assert.IsTrue (p.CanConvert ("10", ValidationDataType.Double), "B3");
 173                         Assert.IsFalse (p.CanConvert ("10", ValidationDataType.Date), "B4");
 174                         Assert.IsTrue (p.CanConvert ("10", ValidationDataType.Currency), "B5");
 175
 176                         /* a double constant */
 177                         Assert.IsTrue (p.CanConvert ("10.5", ValidationDataType.String), "B6");
 178                         Assert.IsFalse (p.CanConvert ("10.5", ValidationDataType.Integer), "B7");
 179                         Assert.IsTrue (p.CanConvert ("10.5", ValidationDataType.Double), "B8");
 180 // find a way to do this in a Culture independent way
 181 //                      Assert.IsFalse (p.CanConvert ("10.5", ValidationDataType.Date), "B9");
 182                         Assert.IsTrue (p.CanConvert ("10.5", ValidationDataType.Currency), "B10");
 183
 184                         /* a string constant */
 185                         Assert.IsTrue (p.CanConvert ("hi", ValidationDataType.String), "B11");
 186                         Assert.IsFalse (p.CanConvert ("hi", ValidationDataType.Integer), "B12");
 187                         Assert.IsFalse (p.CanConvert ("hi", ValidationDataType.Double), "B13");
 188                         Assert.IsFalse (p.CanConvert ("hi", ValidationDataType.Date), "B14");
 189                         Assert.IsFalse (p.CanConvert ("hi", ValidationDataType.Currency), "B15");
 190
 191                         /* a currency constant? */
 192                         Assert.IsTrue (p.CanConvert ("10.50", ValidationDataType.String), "B16");
 193                         Assert.IsFalse (p.CanConvert ("10.50", ValidationDataType.Integer), "B17");
 194                         Assert.IsTrue (p.CanConvert ("10.50", ValidationDataType.Double), "B18");
 195                         Assert.IsFalse (p.CanConvert ("10.50", ValidationDataType.Date), "B19");
 196                         Assert.IsTrue (p.CanConvert ("10.50", ValidationDataType.Currency), "B20");
 197
 198                         /* a date constant */
 199                         DateTime dt = new DateTime (2005, 7, 19);
 200                         string dt_str = dt.ToString("d");
 201                         Assert.IsTrue  (p.CanConvert (dt_str, ValidationDataType.String), "B21");
 202                         Assert.IsFalse (p.CanConvert (dt_str, ValidationDataType.Integer), "B22");
 203                         Assert.IsFalse (p.CanConvert (dt_str, ValidationDataType.Double), "B23");
 204                         Assert.IsTrue  (p.CanConvert (dt_str, ValidationDataType.Date), "B24");
 205                         Assert.IsFalse (p.CanConvert (dt_str, ValidationDataType.Currency), "B25");
 206
 207                         /* null? */
 208                         Assert.IsFalse (p.CanConvert (null, ValidationDataType.String), "B26");
 209                         Assert.IsFalse (p.CanConvert (null, ValidationDataType.Integer), "B27");
 210                         Assert.IsFalse (p.CanConvert (null, ValidationDataType.Double), "B28");
 211                         Assert.IsFalse (p.CanConvert (null, ValidationDataType.Date), "B29");
 212                         Assert.IsFalse (p.CanConvert (null, ValidationDataType.Currency), "B30");
 213                 }
 214
 215                 [Test]
 216                 public void Convert ()
 217                 {
 218                         CultureInfo currentCulture = Thread.CurrentThread.CurrentCulture;
 219                         CultureInfo currentUICulture = Thread.CurrentThread.CurrentUICulture;
 220
 221                         try {
 222                                 CultureInfo ci = CultureInfo.GetCultureInfo ("en-US");
 223                                 Thread.CurrentThread.CurrentCulture = ci;
 224                                 Thread.CurrentThread.CurrentUICulture = ci;
 225                                 RunConvertTests ();
 226                         } finally {
 227                                 Thread.CurrentThread.CurrentCulture = currentCulture;
 228                                 Thread.CurrentThread.CurrentUICulture = currentUICulture;
 229                         }
 230                 }
 231
 232                 void RunConvertTests ()
 233                 {
 234                         BaseCompareValidatorPoker p = new BaseCompareValidatorPoker ();
 235                         object result;
 236
 237                         /* an integer constant */
 238                         Assert.IsTrue (p.Convert ("10", ValidationDataType.String, out result), "C1");
 239                         Assert.AreEqual ("10", result, "C2");
 240                         Assert.IsTrue (p.Convert ("10", ValidationDataType.Integer, out result), "C3");
 241                         Assert.AreEqual (10, result, "C4");
 242                         Assert.IsTrue (p.Convert ("10", ValidationDataType.Double, out result), "C5");
 243                         Assert.AreEqual (10.0d, result, "C6");
 244                         Assert.IsFalse (p.Convert ("10", ValidationDataType.Date, out result), "C7");
 245                         Assert.IsNull (result, "C8");
 246                         Assert.IsTrue (p.Convert ("10", ValidationDataType.Currency, out result), "C9");
 247                         Assert.AreEqual (new Decimal (10.0f), result, "C10");
 248
 249                         /* a double constant */
 250                         Assert.IsTrue (p.Convert ("10.5", ValidationDataType.String, out result), "C11");
 251                         Assert.AreEqual ("10.5", result, "C12");
 252                         Assert.IsFalse (p.Convert ("10.5", ValidationDataType.Integer, out result), "C13");
 253                         Assert.IsNull (result, "C14");
 254                         Assert.IsTrue (p.Convert ("10.5", ValidationDataType.Double, out result), "C15");
 255                         Assert.AreEqual (10.5d, result, "C16");
 256 // find a way to do this in a Culture independent way
 257 //                      Assert.IsFalse (p.Convert ("10.5", ValidationDataType.Date, out result), "C17");
 258 //                      Assert.IsNull (result, "C18");
 259                         Assert.IsTrue (p.Convert ("10.5", ValidationDataType.Currency, out result), "C19");
 260                         Assert.AreEqual (new Decimal (10.5f), result, "C20");
 261
 262                         /* a string constant */
 263                         Assert.IsTrue (p.Convert ("hi", ValidationDataType.String, out result), "C21");
 264                         Assert.AreEqual ("hi", result, "C22");
 265                         Assert.IsFalse (p.Convert ("hi", ValidationDataType.Integer, out result), "C23");
 266                         Assert.IsNull (result, "C24");
 267                         Assert.IsFalse (p.Convert ("hi", ValidationDataType.Double, out result), "C25");
 268                         Assert.IsNull (result, "C26");
 269                         Assert.IsFalse (p.Convert ("hi", ValidationDataType.Date, out result), "C27");
 270                         Assert.IsNull (result, "C28");
 271                         Assert.IsFalse (p.Convert ("hi", ValidationDataType.Currency, out result), "C29");
 272                         Assert.IsNull (result, "C30");
 273
 274                         /* a date constant */
 275                         DateTime dt = new DateTime (2005, 7, 19);
 276                         string dt_str = dt.ToString("d");
 277                         Assert.IsTrue  (p.Convert (dt_str, ValidationDataType.String, out result), "C31");
 278                         Assert.AreEqual (dt_str, result, "C32");
 279                         Assert.IsFalse (p.Convert (dt_str, ValidationDataType.Integer, out result), "C33");
 280                         Assert.IsNull (result, "C34");
 281                         Assert.IsFalse (p.Convert (dt_str, ValidationDataType.Double, out result), "C35");
 282                         Assert.IsNull (result, "C36");
 283                         Assert.IsTrue  (p.Convert (dt_str, ValidationDataType.Date, out result), "C37");
 284                         Assert.AreEqual (DateTime.Parse (dt_str), result, "C38");
 285                         Assert.IsFalse (p.Convert (dt_str, ValidationDataType.Currency, out result), "C39");
 286                         Assert.IsNull (result, "C40");
 287
 288                         /* a currency constant? */
 289                         Assert.IsTrue (p.Convert ("10.50", ValidationDataType.String, out result), "C41");
 290                         Assert.AreEqual ("10.50", result, "C42");
 291                         Assert.IsFalse (p.Convert ("10.50", ValidationDataType.Integer, out result), "C43");
 292                         Assert.IsNull (result, "C44");
 293                         Assert.IsTrue (p.Convert ("10.50", ValidationDataType.Double, out result), "C45");
 294                         Assert.AreEqual (10.50d, result, "C46");
 295                         Assert.IsFalse (p.Convert ("10.50", ValidationDataType.Date, out result), "C47");
 296                         Assert.IsNull (result, "C48");
 297                         Assert.IsTrue (p.Convert ("10.50", ValidationDataType.Currency, out result), "C49");
 298                         Assert.AreEqual (Decimal.Parse ("10.50"), result, "C50");
 299                 }
 300
 301                 [Test]
 302                 public void Compare ()
 303                 {
 304                         CultureInfo currentCulture = Thread.CurrentThread.CurrentCulture;
 305                         CultureInfo currentUICulture = Thread.CurrentThread.CurrentUICulture;
 306
 307                         try {
 308                                 CultureInfo ci = CultureInfo.GetCultureInfo ("en-US");
 309                                 Thread.CurrentThread.CurrentCulture = ci;
 310                                 Thread.CurrentThread.CurrentUICulture = ci;
 311                                 RunCompareTests ();
 312                         } finally {
 313                                 Thread.CurrentThread.CurrentCulture = currentCulture;
 314                                 Thread.CurrentThread.CurrentUICulture = currentUICulture;
 315                         }
 316                 }
 317
 318                 void RunCompareTests ()
 319                 {
 320                         BaseCompareValidatorPoker p = new BaseCompareValidatorPoker ();
 321
 322                         /* integer comparisons */
 323                         /* equal */
 324                         Assert.IsTrue  (p.Compare ("10", "10", ValidationCompareOperator.Equal,            ValidationDataType.Integer), "D1");
 325                         Assert.IsFalse (p.Compare ("10", "10", ValidationCompareOperator.NotEqual,         ValidationDataType.Integer), "D2");
 326                         Assert.IsFalse (p.Compare ("10", "10", ValidationCompareOperator.LessThan,         ValidationDataType.Integer), "D3");
 327                         Assert.IsTrue  (p.Compare ("10", "10", ValidationCompareOperator.LessThanEqual,    ValidationDataType.Integer), "D4");
 328                         Assert.IsFalse (p.Compare ("10", "10", ValidationCompareOperator.GreaterThan,      ValidationDataType.Integer), "D5");
 329                         Assert.IsTrue  (p.Compare ("10", "10", ValidationCompareOperator.GreaterThanEqual, ValidationDataType.Integer), "D6");
 330                         /* less than */
 331                         Assert.IsFalse (p.Compare ( "5", "10", ValidationCompareOperator.Equal,            ValidationDataType.Integer), "D7");
 332                         Assert.IsTrue  (p.Compare ( "5", "10", ValidationCompareOperator.NotEqual,         ValidationDataType.Integer), "D8");
 333                         Assert.IsTrue  (p.Compare ( "5", "10", ValidationCompareOperator.LessThan,         ValidationDataType.Integer), "D9");
 334                         Assert.IsTrue  (p.Compare ( "5", "10", ValidationCompareOperator.LessThanEqual,    ValidationDataType.Integer), "D10");
 335                         Assert.IsFalse (p.Compare ( "5", "10", ValidationCompareOperator.GreaterThan,      ValidationDataType.Integer), "D11");
 336                         Assert.IsFalse (p.Compare ( "5", "10", ValidationCompareOperator.GreaterThanEqual, ValidationDataType.Integer), "D12");
 337                         /* greater than */
 338                         Assert.IsFalse (p.Compare ("10",  "5", ValidationCompareOperator.Equal,            ValidationDataType.Integer), "D13");
 339                         Assert.IsTrue  (p.Compare ("10",  "5", ValidationCompareOperator.NotEqual,         ValidationDataType.Integer), "D14");
 340                         Assert.IsFalse (p.Compare ("10",  "5", ValidationCompareOperator.LessThan,         ValidationDataType.Integer), "D15");
 341                         Assert.IsFalse (p.Compare ("10",  "5", ValidationCompareOperator.LessThanEqual,    ValidationDataType.Integer), "D16");
 342                         Assert.IsTrue  (p.Compare ("10",  "5", ValidationCompareOperator.GreaterThan,      ValidationDataType.Integer), "D17");
 343                         Assert.IsTrue  (p.Compare ("10",  "5", ValidationCompareOperator.GreaterThanEqual, ValidationDataType.Integer), "D18");
 344                         /* error conditions */
 345                         Assert.IsFalse (p.Compare ("hi",  "5", ValidationCompareOperator.Equal,            ValidationDataType.Integer), "D13");
 346                         Assert.IsFalse (p.Compare ("hi",  "5", ValidationCompareOperator.NotEqual,         ValidationDataType.Integer), "D14");
 347                         Assert.IsFalse (p.Compare ("hi",  "5", ValidationCompareOperator.LessThan,         ValidationDataType.Integer), "D15");
 348                         Assert.IsFalse (p.Compare ("hi",  "5", ValidationCompareOperator.LessThanEqual,    ValidationDataType.Integer), "D16");
 349                         Assert.IsFalse (p.Compare ("hi",  "5", ValidationCompareOperator.GreaterThan,      ValidationDataType.Integer), "D17");
 350                         Assert.IsFalse (p.Compare ("hi",  "5", ValidationCompareOperator.GreaterThanEqual, ValidationDataType.Integer), "D18");
 351                         Assert.IsFalse (p.Compare (null,  "5", ValidationCompareOperator.Equal,            ValidationDataType.Integer), "D19");
 352
 353                         Assert.IsTrue  (p.Compare ( "5", "hi", ValidationCompareOperator.Equal,            ValidationDataType.Integer), "D20");
 354                         Assert.IsTrue (p.Compare ( "5", "hi", ValidationCompareOperator.NotEqual,         ValidationDataType.Integer), "D21");
 355                         Assert.IsTrue (p.Compare ( "5", "hi", ValidationCompareOperator.LessThan,         ValidationDataType.Integer), "D22");
 356                         Assert.IsTrue (p.Compare ( "5", "hi", ValidationCompareOperator.LessThanEqual,    ValidationDataType.Integer), "D23");
 357                         Assert.IsTrue (p.Compare ( "5", "hi", ValidationCompareOperator.GreaterThan,      ValidationDataType.Integer), "D24");
 358                         Assert.IsTrue (p.Compare ( "5", "hi", ValidationCompareOperator.GreaterThanEqual, ValidationDataType.Integer), "D25");
 359                         Assert.IsTrue (p.Compare ( "5", null, ValidationCompareOperator.Equal,            ValidationDataType.Integer), "D26");
 360                         Assert.IsFalse (p.Compare ( "hi", "hi", ValidationCompareOperator.Equal,            ValidationDataType.Integer), "D111");
 361                         Assert.IsFalse (p.Compare ( null, null, ValidationCompareOperator.Equal,            ValidationDataType.Integer), "D112");
 362
 363                         /* double comparisons */
 364                         /* equal */
 365                         Assert.IsTrue  (p.Compare ("10.5", "10.5", ValidationCompareOperator.Equal,            ValidationDataType.Double), "D27");
 366                         Assert.IsFalse (p.Compare ("10.5", "10.5", ValidationCompareOperator.NotEqual,         ValidationDataType.Double), "D28");
 367                         Assert.IsFalse (p.Compare ("10.5", "10.5", ValidationCompareOperator.LessThan,         ValidationDataType.Double), "D29");
 368                         Assert.IsTrue  (p.Compare ("10.5", "10.5", ValidationCompareOperator.LessThanEqual,    ValidationDataType.Double), "D30");
 369                         Assert.IsFalse (p.Compare ("10.5", "10.5", ValidationCompareOperator.GreaterThan,      ValidationDataType.Double), "D31");
 370                         Assert.IsTrue  (p.Compare ("10.5", "10.5", ValidationCompareOperator.GreaterThanEqual, ValidationDataType.Double), "D32");
 371                         /* less than */
 372                         Assert.IsFalse (p.Compare ( "5.5", "10.5", ValidationCompareOperator.Equal,            ValidationDataType.Double), "D33");
 373                         Assert.IsTrue  (p.Compare ( "5.5", "10.5", ValidationCompareOperator.NotEqual,         ValidationDataType.Double), "D34");
 374                         Assert.IsTrue  (p.Compare ( "5.5", "10.5", ValidationCompareOperator.LessThan,         ValidationDataType.Double), "D35");
 375                         Assert.IsTrue  (p.Compare ( "5.5", "10.5", ValidationCompareOperator.LessThanEqual,    ValidationDataType.Double), "D36");
 376                         Assert.IsFalse (p.Compare ( "5.5", "10.5", ValidationCompareOperator.GreaterThan,      ValidationDataType.Double), "D37");
 377                         Assert.IsFalse (p.Compare ( "5.5", "10.5", ValidationCompareOperator.GreaterThanEqual, ValidationDataType.Double), "D38");
 378                         /* greater than */
 379                         Assert.IsFalse (p.Compare ("10.5",  "5.5", ValidationCompareOperator.Equal,            ValidationDataType.Double), "D39");
 380                         Assert.IsTrue  (p.Compare ("10.5",  "5.5", ValidationCompareOperator.NotEqual,         ValidationDataType.Double), "D40");
 381                         Assert.IsFalse (p.Compare ("10.5",  "5.5", ValidationCompareOperator.LessThan,         ValidationDataType.Double), "D41");
 382                         Assert.IsFalse (p.Compare ("10.5",  "5.5", ValidationCompareOperator.LessThanEqual,    ValidationDataType.Double), "D42");
 383                         Assert.IsTrue  (p.Compare ("10.5",  "5.5", ValidationCompareOperator.GreaterThan,      ValidationDataType.Double), "D43");
 384                         Assert.IsTrue  (p.Compare ("10.5",  "5.5", ValidationCompareOperator.GreaterThanEqual, ValidationDataType.Double), "D44");
 385                         /* error conditions */
 386                         Assert.IsFalse (p.Compare ("hi",  "5.5", ValidationCompareOperator.Equal,            ValidationDataType.Double), "D45");
 387                         Assert.IsFalse (p.Compare ("hi",  "5.5", ValidationCompareOperator.NotEqual,         ValidationDataType.Double), "D46");
 388                         Assert.IsFalse (p.Compare ("hi",  "5.5", ValidationCompareOperator.LessThan,         ValidationDataType.Double), "D47");
 389                         Assert.IsFalse (p.Compare ("hi",  "5.5", ValidationCompareOperator.LessThanEqual,    ValidationDataType.Double), "D48");
 390                         Assert.IsFalse (p.Compare ("hi",  "5.5", ValidationCompareOperator.GreaterThan,      ValidationDataType.Double), "D49");
 391                         Assert.IsFalse (p.Compare ("hi",  "5.5", ValidationCompareOperator.GreaterThanEqual, ValidationDataType.Double), "D50");
 392                         Assert.IsFalse (p.Compare (null,  "5.5", ValidationCompareOperator.Equal,            ValidationDataType.Double), "D51");
 393
 394                         Assert.IsTrue (p.Compare ( "5.5", "hi", ValidationCompareOperator.Equal,            ValidationDataType.Double), "D52");
 395                         Assert.IsTrue (p.Compare ( "5.5", "hi", ValidationCompareOperator.NotEqual,         ValidationDataType.Double), "D53");
 396                         Assert.IsTrue (p.Compare ( "5.5", "hi", ValidationCompareOperator.LessThan,         ValidationDataType.Double), "D54");
 397                         Assert.IsTrue (p.Compare ( "5.5", "hi", ValidationCompareOperator.LessThanEqual,    ValidationDataType.Double), "D55");
 398                         Assert.IsTrue (p.Compare ( "5.5", "hi", ValidationCompareOperator.GreaterThan,      ValidationDataType.Double), "D56");
 399                         Assert.IsTrue (p.Compare ( "5.5", "hi", ValidationCompareOperator.GreaterThanEqual, ValidationDataType.Double), "D57");
 400                         Assert.IsTrue (p.Compare ( "5.5", null, ValidationCompareOperator.Equal,            ValidationDataType.Double), "D58");
 401                         Assert.IsFalse (p.Compare ( "hi", "hi", ValidationCompareOperator.Equal,            ValidationDataType.Double), "D26");
 402                         Assert.IsFalse (p.Compare ( null, null, ValidationCompareOperator.Equal,            ValidationDataType.Double), "D26");
 403
 404                         /* string comparisons */
 405                         /* equal */
 406                         Assert.IsTrue  (p.Compare ("hi", "hi", ValidationCompareOperator.Equal,            ValidationDataType.String), "D59");
 407                         Assert.IsFalse (p.Compare ("hi", "hi", ValidationCompareOperator.NotEqual,         ValidationDataType.String), "D60");
 408                         Assert.IsFalse (p.Compare ("hi", "hi", ValidationCompareOperator.LessThan,         ValidationDataType.String), "D61");
 409                         Assert.IsTrue  (p.Compare ("hi", "hi", ValidationCompareOperator.LessThanEqual,    ValidationDataType.String), "D62");
 410                         Assert.IsFalse (p.Compare ("hi", "hi", ValidationCompareOperator.GreaterThan,      ValidationDataType.String), "D63");
 411                         Assert.IsTrue  (p.Compare ("hi", "hi", ValidationCompareOperator.GreaterThanEqual, ValidationDataType.String), "D64");
 412                         /* less than */
 413                         Assert.IsFalse (p.Compare ( "bye", "hi", ValidationCompareOperator.Equal,            ValidationDataType.String), "D65");
 414                         Assert.IsTrue  (p.Compare ( "bye", "hi", ValidationCompareOperator.NotEqual,         ValidationDataType.String), "D66");
 415                         Assert.IsTrue  (p.Compare ( "bye", "hi", ValidationCompareOperator.LessThan,         ValidationDataType.String), "D67");
 416                         Assert.IsTrue  (p.Compare ( "bye", "hi", ValidationCompareOperator.LessThanEqual,    ValidationDataType.String), "D68");
 417                         Assert.IsFalse (p.Compare ( "bye", "hi", ValidationCompareOperator.GreaterThan,      ValidationDataType.String), "D69");
 418                         Assert.IsFalse (p.Compare ( "bye", "hi", ValidationCompareOperator.GreaterThanEqual, ValidationDataType.String), "D70");
 419                         /* greater than */
 420                         Assert.IsFalse (p.Compare ("hi",  "bye", ValidationCompareOperator.Equal,            ValidationDataType.String), "D71");
 421                         Assert.IsTrue  (p.Compare ("hi",  "bye", ValidationCompareOperator.NotEqual,         ValidationDataType.String), "D72");
 422                         Assert.IsFalse (p.Compare ("hi",  "bye", ValidationCompareOperator.LessThan,         ValidationDataType.String), "D73");
 423                         Assert.IsFalse (p.Compare ("hi",  "bye", ValidationCompareOperator.LessThanEqual,    ValidationDataType.String), "D74");
 424                         Assert.IsTrue  (p.Compare ("hi",  "bye", ValidationCompareOperator.GreaterThan,      ValidationDataType.String), "D75");
 425                         Assert.IsTrue  (p.Compare ("hi",  "bye", ValidationCompareOperator.GreaterThanEqual, ValidationDataType.String), "D76");
 426
 427                         /* error conditions */
 428                         Assert.IsFalse (p.Compare (null,  "hi", ValidationCompareOperator.Equal,             ValidationDataType.String), "D113");
 429                         Assert.IsTrue  (p.Compare ("hi",  null, ValidationCompareOperator.Equal,             ValidationDataType.String), "D114");
 430                         Assert.IsFalse (p.Compare ( null, null, ValidationCompareOperator.Equal,             ValidationDataType.String), "D115");
 431
 432
 433                         /* date comparisons */
 434                         /* equal */
 435                         DateTime dt1 = new DateTime (2005, 7, 18);
 436                         DateTime dt2 = new DateTime (2005, 7, 19);
 437                         string dt1_str = dt1.ToString("d");
 438                         string dt2_str = dt2.ToString("d");
 439
 440                         Assert.IsTrue  (p.Compare (dt2_str, dt2_str, ValidationCompareOperator.Equal,            ValidationDataType.Date), "D59");
 441                         Assert.IsFalse (p.Compare (dt2_str, dt2_str, ValidationCompareOperator.NotEqual,         ValidationDataType.Date), "D60");
 442                         Assert.IsFalse (p.Compare (dt2_str, dt2_str, ValidationCompareOperator.LessThan,         ValidationDataType.Date), "D61");
 443                         Assert.IsTrue  (p.Compare (dt2_str, dt2_str, ValidationCompareOperator.LessThanEqual,    ValidationDataType.Date), "D62");
 444                         Assert.IsFalse (p.Compare (dt2_str, dt2_str, ValidationCompareOperator.GreaterThan,      ValidationDataType.Date), "D63");
 445                         Assert.IsTrue  (p.Compare (dt2_str, dt2_str, ValidationCompareOperator.GreaterThanEqual, ValidationDataType.Date), "D64");
 446                         /* less than */
 447                         Assert.IsFalse (p.Compare ( dt1_str, dt2_str, ValidationCompareOperator.Equal,            ValidationDataType.Date), "D65");
 448                         Assert.IsTrue  (p.Compare ( dt1_str, dt2_str, ValidationCompareOperator.NotEqual,         ValidationDataType.Date), "D66");
 449                         Assert.IsTrue  (p.Compare ( dt1_str, dt2_str, ValidationCompareOperator.LessThan,         ValidationDataType.Date), "D67");
 450                         Assert.IsTrue  (p.Compare ( dt1_str, dt2_str, ValidationCompareOperator.LessThanEqual,    ValidationDataType.Date), "D68");
 451                         Assert.IsFalse (p.Compare ( dt1_str, dt2_str, ValidationCompareOperator.GreaterThan,      ValidationDataType.Date), "D69");
 452                         Assert.IsFalse (p.Compare ( dt1_str, dt2_str, ValidationCompareOperator.GreaterThanEqual, ValidationDataType.Date), "D70");
 453                         /* greater than */
 454                         Assert.IsFalse (p.Compare (dt2_str,  dt1_str, ValidationCompareOperator.Equal,            ValidationDataType.Date), "D71");
 455                         Assert.IsTrue  (p.Compare (dt2_str,  dt1_str, ValidationCompareOperator.NotEqual,         ValidationDataType.Date), "D72");
 456                         Assert.IsFalse (p.Compare (dt2_str,  dt1_str, ValidationCompareOperator.LessThan,         ValidationDataType.Date), "D73");
 457                         Assert.IsFalse (p.Compare (dt2_str,  dt1_str, ValidationCompareOperator.LessThanEqual,    ValidationDataType.Date), "D74");
 458                         Assert.IsTrue  (p.Compare (dt2_str,  dt1_str, ValidationCompareOperator.GreaterThan,      ValidationDataType.Date), "D75");
 459                         Assert.IsTrue  (p.Compare (dt2_str,  dt1_str, ValidationCompareOperator.GreaterThanEqual, ValidationDataType.Date), "D76");
 460
 461                         /* error conditions */
 462                         Assert.IsFalse (p.Compare (null,  dt2_str, ValidationCompareOperator.Equal,             ValidationDataType.Date), "D77");
 463                         Assert.IsTrue  (p.Compare (dt2_str,  null, ValidationCompareOperator.Equal,             ValidationDataType.Date), "D78");
 464                         Assert.IsFalse (p.Compare ("hi",  null, ValidationCompareOperator.Equal,             ValidationDataType.Date), "D116");
 465                         Assert.IsFalse (p.Compare ( null, null, ValidationCompareOperator.Equal,             ValidationDataType.Date), "D117");
 466
 467                         /* currency comparisons */
 468                         /* equal */
 469                         Assert.IsTrue  (p.Compare ("10.50", "10.50", ValidationCompareOperator.Equal,            ValidationDataType.Currency), "D79");
 470                         Assert.IsFalse (p.Compare ("10.50", "10.50", ValidationCompareOperator.NotEqual,         ValidationDataType.Currency), "D80");
 471                         Assert.IsFalse (p.Compare ("10.50", "10.50", ValidationCompareOperator.LessThan,         ValidationDataType.Currency), "D81");
 472                         Assert.IsTrue  (p.Compare ("10.50", "10.50", ValidationCompareOperator.LessThanEqual,    ValidationDataType.Currency), "D82");
 473                         Assert.IsFalse (p.Compare ("10.50", "10.50", ValidationCompareOperator.GreaterThan,      ValidationDataType.Currency), "D83");
 474                         Assert.IsTrue  (p.Compare ("10.50", "10.50", ValidationCompareOperator.GreaterThanEqual, ValidationDataType.Currency), "D84");
 475                         /* less than */
 476                         Assert.IsFalse (p.Compare ( "5.50", "10.50", ValidationCompareOperator.Equal,            ValidationDataType.Currency), "D85");
 477                         Assert.IsTrue  (p.Compare ( "5.50", "10.50", ValidationCompareOperator.NotEqual,         ValidationDataType.Currency), "D86");
 478                         Assert.IsTrue  (p.Compare ( "5.50", "10.50", ValidationCompareOperator.LessThan,         ValidationDataType.Currency), "D87");
 479                         Assert.IsTrue  (p.Compare ( "5.50", "10.50", ValidationCompareOperator.LessThanEqual,    ValidationDataType.Currency), "D88");
 480                         Assert.IsFalse (p.Compare ( "5.50", "10.50", ValidationCompareOperator.GreaterThan,      ValidationDataType.Currency), "D89");
 481                         Assert.IsFalse (p.Compare ( "5.50", "10.50", ValidationCompareOperator.GreaterThanEqual, ValidationDataType.Currency), "D90");
 482                         /* greater than */
 483                         Assert.IsFalse (p.Compare ("10.50",  "5.50", ValidationCompareOperator.Equal,            ValidationDataType.Currency), "D91");
 484                         Assert.IsTrue  (p.Compare ("10.50",  "5.50", ValidationCompareOperator.NotEqual,         ValidationDataType.Currency), "D92");
 485                         Assert.IsFalse (p.Compare ("10.50",  "5.50", ValidationCompareOperator.LessThan,         ValidationDataType.Currency), "D93");
 486                         Assert.IsFalse (p.Compare ("10.50",  "5.50", ValidationCompareOperator.LessThanEqual,    ValidationDataType.Currency), "D94");
 487                         Assert.IsTrue  (p.Compare ("10.50",  "5.50", ValidationCompareOperator.GreaterThan,      ValidationDataType.Currency), "D95");
 488                         Assert.IsTrue  (p.Compare ("10.50",  "5.50", ValidationCompareOperator.GreaterThanEqual, ValidationDataType.Currency), "D96");
 489                         /* error conditions */
 490                         Assert.IsFalse (p.Compare ("hi",  "5.50", ValidationCompareOperator.Equal,            ValidationDataType.Currency), "D97");
 491                         Assert.IsFalse (p.Compare ("hi",  "5.50", ValidationCompareOperator.NotEqual,         ValidationDataType.Currency), "D98");
 492                         Assert.IsFalse (p.Compare ("hi",  "5.50", ValidationCompareOperator.LessThan,         ValidationDataType.Currency), "D99");
 493                         Assert.IsFalse (p.Compare ("hi",  "5.50", ValidationCompareOperator.LessThanEqual,    ValidationDataType.Currency), "D100");
 494                         Assert.IsFalse (p.Compare ("hi",  "5.50", ValidationCompareOperator.GreaterThan,      ValidationDataType.Currency), "D101");
 495                         Assert.IsFalse (p.Compare ("hi",  "5.50", ValidationCompareOperator.GreaterThanEqual, ValidationDataType.Currency), "D102");
 496                         Assert.IsFalse (p.Compare (null,  "5.50", ValidationCompareOperator.Equal,            ValidationDataType.Currency), "D103");
 497
 498                         Assert.IsTrue (p.Compare ( "5.50", "hi", ValidationCompareOperator.Equal,            ValidationDataType.Currency), "D104");
 499                         Assert.IsTrue (p.Compare ( "5.50", "hi", ValidationCompareOperator.NotEqual,         ValidationDataType.Currency), "D105");
 500                         Assert.IsTrue (p.Compare ( "5.50", "hi", ValidationCompareOperator.LessThan,         ValidationDataType.Currency), "D106");
 501                         Assert.IsTrue (p.Compare ( "5.50", "hi", ValidationCompareOperator.LessThanEqual,    ValidationDataType.Currency), "D107");
 502                         Assert.IsTrue (p.Compare ( "5.50", "hi", ValidationCompareOperator.GreaterThan,      ValidationDataType.Currency), "D108");
 503                         Assert.IsTrue (p.Compare ( "5.50", "hi", ValidationCompareOperator.GreaterThanEqual, ValidationDataType.Currency), "D109");
 504                         Assert.IsTrue (p.Compare ( "5.50", null, ValidationCompareOperator.Equal,            ValidationDataType.Currency), "D110");
 505
 506                         Assert.IsFalse (p.Compare ("hi",  null, ValidationCompareOperator.Equal,             ValidationDataType.Currency), "D118");
 507                         Assert.IsFalse (p.Compare ( null, null, ValidationCompareOperator.Equal,             ValidationDataType.Currency), "D119");
 508                 }
 509
 510                 [Test]
 511                 public void MiscPropertiesAndMethods()
 512                 {
 513                         BaseCompareValidatorPoker p = new BaseCompareValidatorPoker ();
 514
 515                         Assert.AreEqual (p.GetCutoffYear(), 2029, "E1");
 516                         Assert.AreEqual (p.GetFullYear (29), 2029, "E2");
 517                         Assert.AreEqual (p.GetFullYear (30), 1930, "E3");
 518
 519                         Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-GB", false);
 520                         Assert.AreEqual (p.GetDateElementOrder (), "dmy", "E4");
 521
 522                         Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US", false);
 523                         Assert.AreEqual (p.GetDateElementOrder (), "mdy", "E5");
 524
 525                         Thread.CurrentThread.CurrentCulture = new CultureInfo ("af-ZA", false);
 526                         Assert.AreEqual (p.GetDateElementOrder (), "ymd", "E6");
 527                 }
 528
 529                 [Test]
 530                 public void CultureInvariantValues_1 ()
 531                 {
 532                         Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US", false);
 533                         //  Current date format --> "dmy"
 534                         Page p = new Page ();
 535
 536                         CompareValidator v = new CompareValidator ();
 537                         v.ControlToValidate = "tb1";
 538                         v.Type = ValidationDataType.Date;
 539                         v.ValueToCompare = "2005/12/24";
 540                         v.CultureInvariantValues = true;
 541
 542                         TextBox tb1 = new TextBox ();
 543                         tb1.ID = "tb1";
 544                         tb1.Text = "12.24.2005";
 545
 546                         p.Controls.Add (tb1);
 547                         p.Controls.Add (v);
 548
 549                         v.Validate ();
 550                         Assert.AreEqual (true, v.IsValid, "CultureInvariantValues#1");
 551
 552                         tb1.Text = "12/24/2005";
 553                         v.Validate ();
 554                         Assert.AreEqual (true, v.IsValid, "CultureInvariantValues#2");
 555
 556                         tb1.Text = "2005.12.24";
 557                         v.Validate ();
 558                         Assert.AreEqual (true, v.IsValid, "CultureInvariantValues#3");
 559
 560                         tb1.Text = "2005.24.12";
 561                         v.Validate ();
 562                         Assert.AreEqual (false, v.IsValid, "CultureInvariantValues#4");
 563                 }
 564
 565                 [Test]
 566                 public void CultureInvariantValues_2 ()
 567                 {
 568
 569                         Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-GB", false);
 570                         //  Current date format --> "dmy"
 571                         Page p = new Page ();
 572
 573                         CompareValidator v = new CompareValidator ();
 574                         v.ControlToValidate = "tb1";
 575                         v.Type = ValidationDataType.Date;
 576                         v.ValueToCompare = "24/12/2005";
 577                         v.CultureInvariantValues = false;
 578
 579                         TextBox tb1 = new TextBox ();
 580                         tb1.ID = "tb1";
 581                         tb1.Text = "24.12.2005";
 582
 583                         p.Controls.Add (tb1);
 584                         p.Controls.Add (v);
 585
 586                         v.Validate ();
 587                         Assert.AreEqual (true, v.IsValid, "CultureInvariantValues#1");
 588
 589                         tb1.Text = "24-12-2005";
 590                         v.Validate ();
 591                         Assert.AreEqual (true, v.IsValid, "CultureInvariantValues#2");
 592
 593                         tb1.Text = "2005/12/24";
 594                         v.Validate ();
 595                         Assert.AreEqual (true, v.IsValid, "CultureInvariantValues#3");
 596
 597                         tb1.Text = "2005.24.12";
 598                         v.Validate ();
 599                         Assert.AreEqual (false, v.IsValid, "CultureInvariantValues#4");
 600                 }
 601
 602                 [Test]
 603                 [ExpectedException(typeof(HttpException))]
 604                 public void CultureInvariantValues_Exception ()
 605                 {
 606
 607                         Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-GB", false);
 608                         //  Current date format --> "dmy"
 609                         Page p = new Page ();
 610
 611                         CompareValidator v = new CompareValidator ();
 612                         v.ControlToValidate = "tb1";
 613                         v.Type = ValidationDataType.Date;
 614                         v.ValueToCompare = "12--24--2005";
 615                         v.CultureInvariantValues = false;
 616
 617                         TextBox tb1 = new TextBox ();
 618                         tb1.ID = "tb1";
 619                         tb1.Text = "24.12.2005";
 620
 621                         p.Controls.Add (tb1);
 622                         p.Controls.Add (v);
 623
 624                         v.Validate ();
 625                         Assert.AreEqual (true, v.IsValid, "CultureInvariantValues#1");
 626
 627                         tb1.Text = "24-12-2005";
 628                         v.Validate ();
 629                 }
 630         }
 631 }