mcs/class/Mono.C5/current/Test/BasesTest.cs

   1 /*\r
   2  Copyright (c) 2003-2006 Niels Kokholm and Peter Sestoft\r
   3  Permission is hereby granted, free of charge, to any person obtaining a copy\r
   4  of this software and associated documentation files (the "Software"), to deal\r
   5  in the Software without restriction, including without limitation the rights\r
   6  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r
   7  copies of the Software, and to permit persons to whom the Software is\r
   8  furnished to do so, subject to the following conditions:\r
   9  \r
  10  The above copyright notice and this permission notice shall be included in\r
  11  all copies or substantial portions of the Software.\r
  12  \r
  13  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
  14  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r
  15  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r
  16  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r
  17  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r
  18  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r
  19  SOFTWARE.\r
  20 */\r
  21 \r
  22 using System;\r
  23 using C5;\r
  24 using NUnit.Framework;\r
  25 using SCG = System.Collections.Generic;\r
  26 \r
  27 \r
  28 namespace C5UnitTests.support\r
  29 {\r
  30   namespace bases\r
  31   {\r
  32     [TestFixture]\r
  33     public class ArrayBaseTest\r
  34     {\r
  35       class ABT : ArrayBase<string>\r
  36       {\r
  37         public ABT() : base(8,NaturalEqualityComparer<string>.Default) { }\r
  38 \r
  39         public override string Choose() { if (size > 0) return array[0]; throw new NoSuchItemException(); }\r
  40 \r
  41         public string this[int i] { get { return array[i]; } set { array[i] = value; } }\r
  42 \r
  43 \r
  44         public int thesize { get { return size; } set { size = value; } }\r
  45       }\r
  46 \r
  47 \r
  48       [Test]\r
  49       public void Check()\r
  50       {\r
  51         ABT abt = new ABT();\r
  52 \r
  53         abt.thesize = 3;\r
  54         abt[2] = "aaa";\r
  55         // Assert.IsFalse(abt.Check());\r
  56         abt[0] = "##";\r
  57         abt[1] = "##";\r
  58         Assert.IsTrue(abt.Check());\r
  59       }\r
  60     }\r
  61   }\r
  62 \r
  63   namespace itemops\r
  64   {\r
  65     [TestFixture]\r
  66     public class Comparers\r
  67     {\r
  68       class dbl : IComparable<dbl>\r
  69       {\r
  70         double d;\r
  71 \r
  72         public dbl(double din) { d = din; }\r
  73 \r
  74         public int CompareTo(dbl that)\r
  75         {\r
  76           return d < that.d ? -1 : d == that.d ? 0 : 1;\r
  77         }\r
  78         public bool Equals(dbl that) { return d == that.d; }\r
  79       }\r
  80 \r
  81       [Test]\r
  82       [ExpectedException(typeof(NotComparableException))]\r
  83       public void NotComparable()\r
  84       {\r
  85         SCG.IComparer<object> foo = Comparer<object>.Default;\r
  86       }\r
  87 \r
  88       [Test]\r
  89       public void GenericC()\r
  90       {\r
  91         SCG.IComparer<dbl> h = new NaturalComparer<dbl>();\r
  92         dbl s = new dbl(3.4);\r
  93         dbl t = new dbl(3.4);\r
  94         dbl u = new dbl(7.4);\r
  95 \r
  96         Assert.AreEqual(0, h.Compare(s, t));\r
  97         Assert.IsTrue(h.Compare(s, u) < 0);\r
  98       }\r
  99 \r
 100 \r
 101       [Test]\r
 102       public void OrdinaryC()\r
 103       {\r
 104         SCG.IComparer<string> h = new NaturalComparerO<string>();\r
 105         string s = "bamse";\r
 106         string t = "bamse";\r
 107         string u = "bimse";\r
 108 \r
 109         Assert.AreEqual(0, h.Compare(s, t));\r
 110         Assert.IsTrue(h.Compare(s, u) < 0);\r
 111       }\r
 112 \r
 113 \r
 114       [Test]\r
 115       public void GenericCViaBuilder()\r
 116       {\r
 117         SCG.IComparer<dbl> h = Comparer<dbl>.Default;\r
 118         dbl s = new dbl(3.4);\r
 119         dbl t = new dbl(3.4);\r
 120         dbl u = new dbl(7.4);\r
 121 \r
 122         Assert.AreEqual(0, h.Compare(s, t));\r
 123         Assert.IsTrue(h.Compare(s, u) < 0);\r
 124         Assert.AreSame(h, Comparer<dbl>.Default);\r
 125       }\r
 126 \r
 127 \r
 128       [Test]\r
 129       public void OrdinaryCViaBuilder()\r
 130       {\r
 131         SCG.IComparer<string> h = Comparer<string>.Default;\r
 132         string s = "bamse";\r
 133         string t = "bamse";\r
 134         string u = "bimse";\r
 135 \r
 136         Assert.AreEqual(0, h.Compare(s, t));\r
 137         Assert.IsTrue(h.Compare(s, u) < 0);\r
 138         Assert.AreSame(h, Comparer<string>.Default);\r
 139 \r
 140       }\r
 141 \r
 142 \r
 143       [Test]\r
 144       public void ICViaBuilder()\r
 145       {\r
 146         SCG.IComparer<int> h = Comparer<int>.Default;\r
 147         int s = 4;\r
 148         int t = 4;\r
 149         int u = 5;\r
 150 \r
 151         Assert.AreEqual(0, h.Compare(s, t));\r
 152         Assert.IsTrue(h.Compare(s, u) < 0);\r
 153         Assert.AreSame(h, Comparer<int>.Default);\r
 154 \r
 155       }\r
 156 \r
 157       [Test]\r
 158       public void Nulls()\r
 159       {\r
 160         Assert.IsTrue(Comparer<string>.Default.Compare(null, "abe") < 0);\r
 161         Assert.IsTrue(Comparer<string>.Default.Compare(null, null) == 0);\r
 162         Assert.IsTrue(Comparer<string>.Default.Compare("abe", null) > 0);\r
 163       }\r
 164     }\r
 165 \r
 166     [TestFixture]\r
 167     public class EqualityComparers\r
 168     {\r
 169       [Test]\r
 170       public void ReftypeequalityComparer()\r
 171       {\r
 172         SCG.IEqualityComparer<string> h = NaturalEqualityComparer<string>.Default;\r
 173         string s = "bamse";\r
 174         string t = "bamse";\r
 175         string u = "bimse";\r
 176 \r
 177         Assert.AreEqual(s.GetHashCode(), h.GetHashCode(s));\r
 178         Assert.IsTrue(h.Equals(s, t));\r
 179         Assert.IsFalse(h.Equals(s, u));\r
 180       }\r
 181 \r
 182 \r
 183       [Test]\r
 184       public void ValuetypeequalityComparer()\r
 185       {\r
 186         SCG.IEqualityComparer<double> h = NaturalEqualityComparer<double>.Default;\r
 187         double s = 3.4;\r
 188         double t = 3.4;\r
 189         double u = 5.7;\r
 190 \r
 191         Assert.AreEqual(s.GetHashCode(), h.GetHashCode(s));\r
 192         Assert.IsTrue(h.Equals(s, t));\r
 193         Assert.IsFalse(h.Equals(s, u));\r
 194       }\r
 195 \r
 196       internal class REHTest { public override int GetHashCode() { return 37; } }\r
 197 \r
 198       [Test]\r
 199       public void ReferenceEqualityEqualityComparerTest()\r
 200       {\r
 201         REHTest rehtest = new REHTest();\r
 202         SCG.IEqualityComparer<REHTest> equalityComparer = ReferenceEqualityComparer<REHTest>.Default;\r
 203         Assert.AreEqual(37, rehtest.GetHashCode());\r
 204         Assert.IsFalse(equalityComparer.GetHashCode(rehtest) == 37);\r
 205       }\r
 206 \r
 207       [Test]\r
 208       public void ReftypeequalityComparerViaBuilder()\r
 209       {\r
 210         SCG.IEqualityComparer<string> h = EqualityComparer<string>.Default;\r
 211         string s = "bamse";\r
 212         string t = "bamse";\r
 213         string u = "bimse";\r
 214 \r
 215         Assert.AreEqual(s.GetHashCode(), h.GetHashCode(s));\r
 216         Assert.IsTrue(h.Equals(s, t));\r
 217         Assert.IsFalse(h.Equals(s, u));\r
 218         Assert.AreSame(h, EqualityComparer<string>.Default);\r
 219       }\r
 220 \r
 221 \r
 222       [Test]\r
 223       public void ValuetypeequalityComparerViaBuilder()\r
 224       {\r
 225         SCG.IEqualityComparer<double> h = EqualityComparer<double>.Default;\r
 226         double s = 3.4;\r
 227         double t = 3.4;\r
 228         double u = 5.7;\r
 229 \r
 230         Assert.AreEqual(s.GetHashCode(), h.GetHashCode(s));\r
 231         Assert.IsTrue(h.Equals(s, t));\r
 232         Assert.IsFalse(h.Equals(s, u));\r
 233         Assert.AreSame(h, EqualityComparer<double>.Default);\r
 234       }\r
 235 \r
 236 \r
 237       [Test]\r
 238       public void IntequalityComparerViaBuilder()\r
 239       {\r
 240         SCG.IEqualityComparer<int> h = EqualityComparer<int>.Default;\r
 241         int s = 3;\r
 242         int t = 3;\r
 243         int u = 5;\r
 244 \r
 245         Assert.AreEqual(s.GetHashCode(), h.GetHashCode(s));\r
 246         Assert.IsTrue(h.Equals(s, t));\r
 247         Assert.IsFalse(h.Equals(s, u));\r
 248         Assert.AreSame(h, EqualityComparer<int>.Default);\r
 249       }\r
 250 \r
 251       [Test]\r
 252       public void DoubleequalityComparerViaBuilder()\r
 253       {\r
 254         SCG.IEqualityComparer<double> h = EqualityComparer<double>.Default;\r
 255         double s = 3.1;\r
 256         double t = 3.1;\r
 257         double u = 5.2;\r
 258 \r
 259         Assert.AreEqual(s.GetHashCode(), h.GetHashCode(s));\r
 260         Assert.IsTrue(h.Equals(s, t));\r
 261         Assert.IsFalse(h.Equals(s, u));\r
 262         Assert.AreSame(h, EqualityComparer<double>.Default);\r
 263       }\r
 264 \r
 265       [Test]\r
 266       public void CharequalityComparerViaBuilder()\r
 267       {\r
 268         SCG.IEqualityComparer<char> h = EqualityComparer<char>.Default;\r
 269         char s = 'å';\r
 270         char t = 'å';\r
 271         char u = 'r';\r
 272 \r
 273         Assert.AreEqual(s.GetHashCode(), h.GetHashCode(s));\r
 274         Assert.IsTrue(h.Equals(s, t));\r
 275         Assert.IsFalse(h.Equals(s, u));\r
 276         Assert.AreSame(h, EqualityComparer<char>.Default);\r
 277       }\r
 278 \r
 279       [Test]\r
 280       public void ByteequalityComparerViaBuilder()\r
 281       {\r
 282         SCG.IEqualityComparer<byte> h = EqualityComparer<byte>.Default;\r
 283         byte s = 3;\r
 284         byte t = 3;\r
 285         byte u = 5;\r
 286 \r
 287         Assert.AreEqual(s.GetHashCode(), h.GetHashCode(s));\r
 288         Assert.IsTrue(h.Equals(s, t));\r
 289         Assert.IsFalse(h.Equals(s, u));\r
 290         Assert.AreSame(h, EqualityComparer<byte>.Default);\r
 291       }\r
 292 \r
 293       [Test]\r
 294       public void UnseqequalityComparerViaBuilder()\r
 295       {\r
 296         SCG.IEqualityComparer<ICollection<int>> h = EqualityComparer<ICollection<int>>.Default;\r
 297         ICollection<int> s = new LinkedList<int>();\r
 298         ICollection<int> t = new LinkedList<int>();\r
 299         ICollection<int> u = new LinkedList<int>();\r
 300         s.Add(1); s.Add(2); s.Add(3);\r
 301         t.Add(3); t.Add(2); t.Add(1);\r
 302         u.Add(3); u.Add(2); u.Add(4);\r
 303         Assert.AreEqual(s.GetUnsequencedHashCode(), h.GetHashCode(s));\r
 304         Assert.IsTrue(h.Equals(s, t));\r
 305         Assert.IsFalse(h.Equals(s, u));\r
 306         Assert.AreSame(h, EqualityComparer<ICollection<int>>.Default);\r
 307       }\r
 308 \r
 309       [Test]\r
 310       public void SeqequalityComparerViaBuilder2()\r
 311       {\r
 312         SCG.IEqualityComparer<LinkedList<int>> h = EqualityComparer<LinkedList<int>>.Default;\r
 313         LinkedList<int> s = new LinkedList<int>();\r
 314         s.Add(1); s.Add(2); s.Add(3);\r
 315         Assert.AreEqual(CHC.sequencedhashcode(1, 2, 3), h.GetHashCode(s));\r
 316       }\r
 317 \r
 318       [Test]\r
 319       public void UnseqequalityComparerViaBuilder2()\r
 320       {\r
 321         SCG.IEqualityComparer<HashSet<int>> h = EqualityComparer<HashSet<int>>.Default;\r
 322         HashSet<int> s = new HashSet<int>();\r
 323         s.Add(1); s.Add(2); s.Add(3);\r
 324         Assert.AreEqual(CHC.unsequencedhashcode(1, 2, 3), h.GetHashCode(s));\r
 325       }\r
 326 \r
 327       //generic types implementing collection interfaces\r
 328       [Test]\r
 329       public void SeqequalityComparerViaBuilder3()\r
 330       {\r
 331         SCG.IEqualityComparer<IList<int>> h = EqualityComparer<IList<int>>.Default;\r
 332         IList<int> s = new LinkedList<int>();\r
 333         s.Add(1); s.Add(2); s.Add(3);\r
 334         Assert.AreEqual(CHC.sequencedhashcode(1, 2, 3), h.GetHashCode(s));\r
 335       }\r
 336 \r
 337       interface IFoo<T> : ICollection<T> { void Bamse();      }\r
 338 \r
 339       class Foo<T> : HashSet<T>, IFoo<T>\r
 340       {\r
 341         internal Foo() : base() { }\r
 342         public void Bamse() { }\r
 343       }\r
 344 \r
 345       [Test]\r
 346       public void UnseqequalityComparerViaBuilder3()\r
 347       {\r
 348         SCG.IEqualityComparer<IFoo<int>> h = EqualityComparer<IFoo<int>>.Default;\r
 349         IFoo<int> s = new Foo<int>();\r
 350         s.Add(1); s.Add(2); s.Add(3);\r
 351         Assert.AreEqual(CHC.unsequencedhashcode(1, 2, 3), h.GetHashCode(s));\r
 352       }\r
 353 \r
 354       //Nongeneric types implementing collection types:\r
 355       interface IBaz : ISequenced<int> { void Bamse(); }\r
 356 \r
 357       class Baz : LinkedList<int>, IBaz\r
 358       {\r
 359         internal Baz() : base() { }\r
 360         public void Bamse() { }\r
 361         //int ISequenced<int>.GetHashCode() { return sequencedhashcode(); }\r
 362         //bool ISequenced<int>.Equals(ISequenced<int> that) { return sequencedequals(that); }\r
 363       }\r
 364 \r
 365 #warning This test fails because of an error in .Net 2.0\r
 366       //[Test]\r
 367       public void SeqequalityComparerViaBuilder4()\r
 368       {\r
 369         SCG.IEqualityComparer<IBaz> h = EqualityComparer<IBaz>.Default;\r
 370         IBaz s = new Baz();\r
 371         s.Add(1); s.Add(2); s.Add(3);\r
 372         Assert.AreEqual(CHC.sequencedhashcode(1, 2, 3), h.GetHashCode(s));\r
 373       }\r
 374 \r
 375       interface IBar : ICollection<int>\r
 376       {\r
 377         void Bamse();\r
 378       }\r
 379 \r
 380       class Bar : HashSet<int>, IBar\r
 381       {\r
 382         internal Bar() : base() { }\r
 383         public void Bamse() { }\r
 384 \r
 385         //TODO: remove all this workaround stuff:\r
 386  \r
 387         bool ICollection<int>.ContainsAll<U>(System.Collections.Generic.IEnumerable<U> items) \r
 388         {\r
 389           throw new NotImplementedException();\r
 390         }\r
 391  \r
 392         void ICollection<int>.RemoveAll<U>(System.Collections.Generic.IEnumerable<U> items) \r
 393         {\r
 394           throw new NotImplementedException();\r
 395         }\r
 396 \r
 397         void ICollection<int>.RetainAll<U>(System.Collections.Generic.IEnumerable<U> items) \r
 398         {\r
 399           throw new NotImplementedException();\r
 400         }\r
 401 \r
 402         void IExtensible<int>.AddAll<U>(System.Collections.Generic.IEnumerable<U> items) \r
 403         {\r
 404           throw new NotImplementedException();\r
 405         }\r
 406 \r
 407       }\r
 408 \r
 409       [Test]\r
 410       public void UnseqequalityComparerViaBuilder4()\r
 411       {\r
 412         SCG.IEqualityComparer<IBar> h = EqualityComparer<IBar>.Default;\r
 413         IBar s = new Bar();\r
 414         s.Add(1); s.Add(2); s.Add(3);\r
 415         Assert.AreEqual(CHC.unsequencedhashcode(1, 2, 3), h.GetHashCode(s));\r
 416       }\r
 417     }\r
 418   }\r
 419 }\r