597 lines
18 KiB
C#
597 lines
18 KiB
C#
|
/*
|
|||
|
|
Copyright (c) 2003-2006 Niels Kokholm and Peter Sestoft
|
|||
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|||
|
|
of this software and associated documentation files (the "Software"), to deal
|
|||
|
|
in the Software without restriction, including without limitation the rights
|
|||
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|||
|
|
copies of the Software, and to permit persons to whom the Software is
|
|||
|
|
furnished to do so, subject to the following conditions:
|
|||
|
|
|
|||
|
|
The above copyright notice and this permission notice shall be included in
|
|||
|
|
all copies or substantial portions of the Software.
|
|||
|
|
|
|||
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|||
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|||
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|||
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|||
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|||
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|||
|
|
SOFTWARE.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
using System;
|
|||
|
|
using C5;
|
|||
|
|
using NUnit.Framework;
|
|||
|
|
using SCG = System.Collections.Generic;
|
|||
|
|
|
|||
|
|
|
|||
|
|
namespace C5UnitTests.support
|
|||
|
|
{
|
|||
|
|
namespace bases
|
|||
|
|
{
|
|||
|
|
[TestFixture]
|
|||
|
|
public class ArrayBaseTest
|
|||
|
|
{
|
|||
|
|
class ABT : ArrayBase<string>
|
|||
|
|
{
|
|||
|
|
public ABT() : base(8,NaturalEqualityComparer<string>.Default) { }
|
|||
|
|
|
|||
|
|
public override string Choose() { if (size > 0) return array[0]; throw new NoSuchItemException(); }
|
|||
|
|
|
|||
|
|
public string this[int i] { get { return array[i]; } set { array[i] = value; } }
|
|||
|
|
|
|||
|
|
|
|||
|
|
public int thesize { get { return size; } set { size = value; } }
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void Check()
|
|||
|
|
{
|
|||
|
|
ABT abt = new ABT();
|
|||
|
|
|
|||
|
|
abt.thesize = 3;
|
|||
|
|
abt[2] = "aaa";
|
|||
|
|
// Assert.IsFalse(abt.Check());
|
|||
|
|
abt[0] = "##";
|
|||
|
|
abt[1] = "##";
|
|||
|
|
Assert.IsTrue(abt.Check());
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
namespace itemops
|
|||
|
|
{
|
|||
|
|
[TestFixture]
|
|||
|
|
public class Comparers
|
|||
|
|
{
|
|||
|
|
class dbl : IComparable<dbl>
|
|||
|
|
{
|
|||
|
|
double d;
|
|||
|
|
|
|||
|
|
public dbl(double din) { d = din; }
|
|||
|
|
|
|||
|
|
public int CompareTo(dbl that)
|
|||
|
|
{
|
|||
|
|
return d < that.d ? -1 : d == that.d ? 0 : 1;
|
|||
|
|
}
|
|||
|
|
public bool Equals(dbl that) { return d == that.d; }
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
[ExpectedException(typeof(NotComparableException))]
|
|||
|
|
public void NotComparable()
|
|||
|
|
{
|
|||
|
|
SCG.IComparer<object> foo = Comparer<object>.Default;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void GenericC()
|
|||
|
|
{
|
|||
|
|
SCG.IComparer<dbl> h = new NaturalComparer<dbl>();
|
|||
|
|
dbl s = new dbl(3.4);
|
|||
|
|
dbl t = new dbl(3.4);
|
|||
|
|
dbl u = new dbl(7.4);
|
|||
|
|
|
|||
|
|
Assert.AreEqual(0, h.Compare(s, t));
|
|||
|
|
Assert.IsTrue(h.Compare(s, u) < 0);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void OrdinaryC()
|
|||
|
|
{
|
|||
|
|
SCG.IComparer<string> h = new NaturalComparerO<string>();
|
|||
|
|
string s = "bamse";
|
|||
|
|
string t = "bamse";
|
|||
|
|
string u = "bimse";
|
|||
|
|
|
|||
|
|
Assert.AreEqual(0, h.Compare(s, t));
|
|||
|
|
Assert.IsTrue(h.Compare(s, u) < 0);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void GenericCViaBuilder()
|
|||
|
|
{
|
|||
|
|
SCG.IComparer<dbl> h = Comparer<dbl>.Default;
|
|||
|
|
dbl s = new dbl(3.4);
|
|||
|
|
dbl t = new dbl(3.4);
|
|||
|
|
dbl u = new dbl(7.4);
|
|||
|
|
|
|||
|
|
Assert.AreEqual(0, h.Compare(s, t));
|
|||
|
|
Assert.IsTrue(h.Compare(s, u) < 0);
|
|||
|
|
Assert.AreSame(h, Comparer<dbl>.Default);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void OrdinaryCViaBuilder()
|
|||
|
|
{
|
|||
|
|
SCG.IComparer<string> h = Comparer<string>.Default;
|
|||
|
|
string s = "bamse";
|
|||
|
|
string t = "bamse";
|
|||
|
|
string u = "bimse";
|
|||
|
|
|
|||
|
|
Assert.AreEqual(0, h.Compare(s, t));
|
|||
|
|
Assert.IsTrue(h.Compare(s, u) < 0);
|
|||
|
|
Assert.AreSame(h, Comparer<string>.Default);
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public void ComparerViaBuilderTest<T>(T item1, T item2)
|
|||
|
|
where T : IComparable<T>
|
|||
|
|
{
|
|||
|
|
SCG.IComparer<T> h = Comparer<T>.Default;
|
|||
|
|
Assert.AreSame(h, Comparer<T>.Default);
|
|||
|
|
Assert.AreEqual(0, h.Compare(item1, item1));
|
|||
|
|
Assert.AreEqual(0, h.Compare(item2, item2));
|
|||
|
|
Assert.IsTrue(h.Compare(item1, item2) < 0);
|
|||
|
|
Assert.IsTrue(h.Compare(item2, item1) > 0);
|
|||
|
|
Assert.AreEqual(Math.Sign(item1.CompareTo(item2)), Math.Sign(h.Compare(item1, item2)));
|
|||
|
|
Assert.AreEqual(Math.Sign(item2.CompareTo(item1)), Math.Sign(h.Compare(item2, item1)));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void PrimitiveComparersViaBuilder()
|
|||
|
|
{
|
|||
|
|
ComparerViaBuilderTest<char>('A', 'a');
|
|||
|
|
ComparerViaBuilderTest<sbyte>(-122, 126);
|
|||
|
|
ComparerViaBuilderTest<byte>(122, 126);
|
|||
|
|
ComparerViaBuilderTest<short>(-30000, 3);
|
|||
|
|
ComparerViaBuilderTest<ushort>(3, 50000);
|
|||
|
|
ComparerViaBuilderTest<int>(-10000000, 10000);
|
|||
|
|
ComparerViaBuilderTest<uint>(10000000, 3000000000);
|
|||
|
|
ComparerViaBuilderTest<long>(-1000000000000, 10000000);
|
|||
|
|
ComparerViaBuilderTest<ulong>(10000000000000UL, 10000000000004UL);
|
|||
|
|
ComparerViaBuilderTest<float>(-0.001F, 0.00001F);
|
|||
|
|
ComparerViaBuilderTest<double>(-0.001, 0.00001E-200);
|
|||
|
|
ComparerViaBuilderTest<decimal>(-20.001M, 19.999M);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// This test is obsoleted by the one above, but we keep it for good measure
|
|||
|
|
[Test]
|
|||
|
|
public void IntComparerViaBuilder()
|
|||
|
|
{
|
|||
|
|
SCG.IComparer<int> h = Comparer<int>.Default;
|
|||
|
|
int s = 4;
|
|||
|
|
int t = 4;
|
|||
|
|
int u = 5;
|
|||
|
|
|
|||
|
|
Assert.AreEqual(0, h.Compare(s, t));
|
|||
|
|
Assert.IsTrue(h.Compare(s, u) < 0);
|
|||
|
|
Assert.AreSame(h, Comparer<int>.Default);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void Nulls()
|
|||
|
|
{
|
|||
|
|
Assert.IsTrue(Comparer<string>.Default.Compare(null, "abe") < 0);
|
|||
|
|
Assert.IsTrue(Comparer<string>.Default.Compare(null, null) == 0);
|
|||
|
|
Assert.IsTrue(Comparer<string>.Default.Compare("abe", null) > 0);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[TestFixture]
|
|||
|
|
public class EqualityComparers
|
|||
|
|
{
|
|||
|
|
[Test]
|
|||
|
|
public void ReftypeequalityComparer()
|
|||
|
|
{
|
|||
|
|
SCG.IEqualityComparer<string> h = NaturalEqualityComparer<string>.Default;
|
|||
|
|
string s = "bamse";
|
|||
|
|
string t = "bamse";
|
|||
|
|
string u = "bimse";
|
|||
|
|
|
|||
|
|
Assert.AreEqual(s.GetHashCode(), h.GetHashCode(s));
|
|||
|
|
Assert.IsTrue(h.Equals(s, t));
|
|||
|
|
Assert.IsFalse(h.Equals(s, u));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void ValuetypeequalityComparer()
|
|||
|
|
{
|
|||
|
|
SCG.IEqualityComparer<double> h = NaturalEqualityComparer<double>.Default;
|
|||
|
|
double s = 3.4;
|
|||
|
|
double t = 3.4;
|
|||
|
|
double u = 5.7;
|
|||
|
|
|
|||
|
|
Assert.AreEqual(s.GetHashCode(), h.GetHashCode(s));
|
|||
|
|
Assert.IsTrue(h.Equals(s, t));
|
|||
|
|
Assert.IsFalse(h.Equals(s, u));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
internal class REHTest { public override int GetHashCode() { return 37; } }
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void ReferenceEqualityEqualityComparerTest()
|
|||
|
|
{
|
|||
|
|
REHTest rehtest = new REHTest();
|
|||
|
|
SCG.IEqualityComparer<REHTest> equalityComparer = ReferenceEqualityComparer<REHTest>.Default;
|
|||
|
|
Assert.AreEqual(37, rehtest.GetHashCode());
|
|||
|
|
Assert.IsFalse(equalityComparer.GetHashCode(rehtest) == 37);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void ReftypeequalityComparerViaBuilder()
|
|||
|
|
{
|
|||
|
|
SCG.IEqualityComparer<string> h = EqualityComparer<string>.Default;
|
|||
|
|
string s = "bamse";
|
|||
|
|
string t = "bamse";
|
|||
|
|
string u = "bimse";
|
|||
|
|
|
|||
|
|
Assert.AreEqual(s.GetHashCode(), h.GetHashCode(s));
|
|||
|
|
Assert.IsTrue(h.Equals(s, t));
|
|||
|
|
Assert.IsFalse(h.Equals(s, u));
|
|||
|
|
Assert.AreSame(h, EqualityComparer<string>.Default);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void ValuetypeequalityComparerViaBuilder()
|
|||
|
|
{
|
|||
|
|
SCG.IEqualityComparer<double> h = EqualityComparer<double>.Default;
|
|||
|
|
double s = 3.4;
|
|||
|
|
double t = 3.4;
|
|||
|
|
double u = 5.7;
|
|||
|
|
|
|||
|
|
Assert.AreEqual(s.GetHashCode(), h.GetHashCode(s));
|
|||
|
|
Assert.IsTrue(h.Equals(s, t));
|
|||
|
|
Assert.IsFalse(h.Equals(s, u));
|
|||
|
|
Assert.AreSame(h, EqualityComparer<double>.Default);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void CharequalityComparerViaBuilder()
|
|||
|
|
{
|
|||
|
|
SCG.IEqualityComparer<char> h = EqualityComparer<char>.Default;
|
|||
|
|
char s = '<27>';
|
|||
|
|
char t = '<27>';
|
|||
|
|
char u = 'r';
|
|||
|
|
|
|||
|
|
Assert.AreEqual(s.GetHashCode(), h.GetHashCode(s));
|
|||
|
|
Assert.IsTrue(h.Equals(s, t));
|
|||
|
|
Assert.IsFalse(h.Equals(s, u));
|
|||
|
|
Assert.AreSame(h, EqualityComparer<char>.Default);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void SbyteequalityComparerViaBuilder()
|
|||
|
|
{
|
|||
|
|
SCG.IEqualityComparer<sbyte> h = EqualityComparer<sbyte>.Default;
|
|||
|
|
sbyte s = 3;
|
|||
|
|
sbyte t = 3;
|
|||
|
|
sbyte u = -5;
|
|||
|
|
|
|||
|
|
Assert.AreEqual(s.GetHashCode(), h.GetHashCode(s));
|
|||
|
|
Assert.IsTrue(h.Equals(s, t));
|
|||
|
|
Assert.IsFalse(h.Equals(s, u));
|
|||
|
|
Assert.AreSame(h, EqualityComparer<sbyte>.Default);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void ByteequalityComparerViaBuilder()
|
|||
|
|
{
|
|||
|
|
SCG.IEqualityComparer<byte> h = EqualityComparer<byte>.Default;
|
|||
|
|
byte s = 3;
|
|||
|
|
byte t = 3;
|
|||
|
|
byte u = 5;
|
|||
|
|
|
|||
|
|
Assert.AreEqual(s.GetHashCode(), h.GetHashCode(s));
|
|||
|
|
Assert.IsTrue(h.Equals(s, t));
|
|||
|
|
Assert.IsFalse(h.Equals(s, u));
|
|||
|
|
Assert.AreSame(h, EqualityComparer<byte>.Default);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void ShortequalityComparerViaBuilder()
|
|||
|
|
{
|
|||
|
|
SCG.IEqualityComparer<short> h = EqualityComparer<short>.Default;
|
|||
|
|
short s = 3;
|
|||
|
|
short t = 3;
|
|||
|
|
short u = -5;
|
|||
|
|
|
|||
|
|
Assert.AreEqual(s.GetHashCode(), h.GetHashCode(s));
|
|||
|
|
Assert.IsTrue(h.Equals(s, t));
|
|||
|
|
Assert.IsFalse(h.Equals(s, u));
|
|||
|
|
Assert.AreSame(h, EqualityComparer<short>.Default);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void UshortequalityComparerViaBuilder()
|
|||
|
|
{
|
|||
|
|
SCG.IEqualityComparer<ushort> h = EqualityComparer<ushort>.Default;
|
|||
|
|
ushort s = 3;
|
|||
|
|
ushort t = 3;
|
|||
|
|
ushort u = 60000;
|
|||
|
|
|
|||
|
|
Assert.AreEqual(s.GetHashCode(), h.GetHashCode(s));
|
|||
|
|
Assert.IsTrue(h.Equals(s, t));
|
|||
|
|
Assert.IsFalse(h.Equals(s, u));
|
|||
|
|
Assert.AreSame(h, EqualityComparer<ushort>.Default);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void IntequalityComparerViaBuilder()
|
|||
|
|
{
|
|||
|
|
SCG.IEqualityComparer<int> h = EqualityComparer<int>.Default;
|
|||
|
|
int s = 3;
|
|||
|
|
int t = 3;
|
|||
|
|
int u = -5;
|
|||
|
|
|
|||
|
|
Assert.AreEqual(s.GetHashCode(), h.GetHashCode(s));
|
|||
|
|
Assert.IsTrue(h.Equals(s, t));
|
|||
|
|
Assert.IsFalse(h.Equals(s, u));
|
|||
|
|
Assert.AreSame(h, EqualityComparer<int>.Default);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void UintequalityComparerViaBuilder()
|
|||
|
|
{
|
|||
|
|
SCG.IEqualityComparer<uint> h = EqualityComparer<uint>.Default;
|
|||
|
|
uint s = 3;
|
|||
|
|
uint t = 3;
|
|||
|
|
uint u = 3000000000;
|
|||
|
|
|
|||
|
|
Assert.AreEqual(s.GetHashCode(), h.GetHashCode(s));
|
|||
|
|
Assert.IsTrue(h.Equals(s, t));
|
|||
|
|
Assert.IsFalse(h.Equals(s, u));
|
|||
|
|
Assert.AreSame(h, EqualityComparer<uint>.Default);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void LongequalityComparerViaBuilder()
|
|||
|
|
{
|
|||
|
|
SCG.IEqualityComparer<long> h = EqualityComparer<long>.Default;
|
|||
|
|
long s = 3;
|
|||
|
|
long t = 3;
|
|||
|
|
long u = -500000000000000L;
|
|||
|
|
|
|||
|
|
Assert.AreEqual(s.GetHashCode(), h.GetHashCode(s));
|
|||
|
|
Assert.IsTrue(h.Equals(s, t));
|
|||
|
|
Assert.IsFalse(h.Equals(s, u));
|
|||
|
|
Assert.AreSame(h, EqualityComparer<long>.Default);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void UlongequalityComparerViaBuilder()
|
|||
|
|
{
|
|||
|
|
SCG.IEqualityComparer<ulong> h = EqualityComparer<ulong>.Default;
|
|||
|
|
ulong s = 3;
|
|||
|
|
ulong t = 3;
|
|||
|
|
ulong u = 500000000000000UL;
|
|||
|
|
|
|||
|
|
Assert.AreEqual(s.GetHashCode(), h.GetHashCode(s));
|
|||
|
|
Assert.IsTrue(h.Equals(s, t));
|
|||
|
|
Assert.IsFalse(h.Equals(s, u));
|
|||
|
|
Assert.AreSame(h, EqualityComparer<ulong>.Default);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void FloatequalityComparerViaBuilder()
|
|||
|
|
{
|
|||
|
|
SCG.IEqualityComparer<float> h = EqualityComparer<float>.Default;
|
|||
|
|
float s = 3.1F;
|
|||
|
|
float t = 3.1F;
|
|||
|
|
float u = -5.2F;
|
|||
|
|
|
|||
|
|
Assert.AreEqual(s.GetHashCode(), h.GetHashCode(s));
|
|||
|
|
Assert.IsTrue(h.Equals(s, t));
|
|||
|
|
Assert.IsFalse(h.Equals(s, u));
|
|||
|
|
Assert.AreSame(h, EqualityComparer<float>.Default);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void DoubleequalityComparerViaBuilder()
|
|||
|
|
{
|
|||
|
|
SCG.IEqualityComparer<double> h = EqualityComparer<double>.Default;
|
|||
|
|
double s = 3.12345;
|
|||
|
|
double t = 3.12345;
|
|||
|
|
double u = -5.2;
|
|||
|
|
|
|||
|
|
Assert.AreEqual(s.GetHashCode(), h.GetHashCode(s));
|
|||
|
|
Assert.IsTrue(h.Equals(s, t));
|
|||
|
|
Assert.IsFalse(h.Equals(s, u));
|
|||
|
|
Assert.AreSame(h, EqualityComparer<double>.Default);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void DecimalequalityComparerViaBuilder()
|
|||
|
|
{
|
|||
|
|
SCG.IEqualityComparer<decimal> h = EqualityComparer<decimal>.Default;
|
|||
|
|
decimal s = 3.0001M;
|
|||
|
|
decimal t = 3.0001M;
|
|||
|
|
decimal u = -500000000000000M;
|
|||
|
|
|
|||
|
|
Assert.AreEqual(s.GetHashCode(), h.GetHashCode(s));
|
|||
|
|
Assert.IsTrue(h.Equals(s, t));
|
|||
|
|
Assert.IsFalse(h.Equals(s, u));
|
|||
|
|
Assert.AreSame(h, EqualityComparer<decimal>.Default);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void UnseqequalityComparerViaBuilder()
|
|||
|
|
{
|
|||
|
|
SCG.IEqualityComparer<ICollection<int>> h = EqualityComparer<ICollection<int>>.Default;
|
|||
|
|
ICollection<int> s = new LinkedList<int>();
|
|||
|
|
ICollection<int> t = new LinkedList<int>();
|
|||
|
|
ICollection<int> u = new LinkedList<int>();
|
|||
|
|
s.Add(1); s.Add(2); s.Add(3);
|
|||
|
|
t.Add(3); t.Add(2); t.Add(1);
|
|||
|
|
u.Add(3); u.Add(2); u.Add(4);
|
|||
|
|
Assert.AreEqual(s.GetUnsequencedHashCode(), h.GetHashCode(s));
|
|||
|
|
Assert.IsTrue(h.Equals(s, t));
|
|||
|
|
Assert.IsFalse(h.Equals(s, u));
|
|||
|
|
Assert.AreSame(h, EqualityComparer<ICollection<int>>.Default);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void SeqequalityComparerViaBuilder2()
|
|||
|
|
{
|
|||
|
|
SCG.IEqualityComparer<LinkedList<int>> h = EqualityComparer<LinkedList<int>>.Default;
|
|||
|
|
LinkedList<int> s = new LinkedList<int>();
|
|||
|
|
s.Add(1); s.Add(2); s.Add(3);
|
|||
|
|
Assert.AreEqual(CHC.sequencedhashcode(1, 2, 3), h.GetHashCode(s));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void UnseqequalityComparerViaBuilder2()
|
|||
|
|
{
|
|||
|
|
SCG.IEqualityComparer<HashSet<int>> h = EqualityComparer<HashSet<int>>.Default;
|
|||
|
|
HashSet<int> s = new HashSet<int>();
|
|||
|
|
s.Add(1); s.Add(2); s.Add(3);
|
|||
|
|
Assert.AreEqual(CHC.unsequencedhashcode(1, 2, 3), h.GetHashCode(s));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//generic types implementing collection interfaces
|
|||
|
|
[Test]
|
|||
|
|
public void SeqequalityComparerViaBuilder3()
|
|||
|
|
{
|
|||
|
|
SCG.IEqualityComparer<IList<int>> h = EqualityComparer<IList<int>>.Default;
|
|||
|
|
IList<int> s = new LinkedList<int>();
|
|||
|
|
s.Add(1); s.Add(2); s.Add(3);
|
|||
|
|
Assert.AreEqual(CHC.sequencedhashcode(1, 2, 3), h.GetHashCode(s));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
interface IFoo<T> : ICollection<T> { void Bamse(); }
|
|||
|
|
|
|||
|
|
class Foo<T> : HashSet<T>, IFoo<T>
|
|||
|
|
{
|
|||
|
|
internal Foo() : base() { }
|
|||
|
|
public void Bamse() { }
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void UnseqequalityComparerViaBuilder3()
|
|||
|
|
{
|
|||
|
|
SCG.IEqualityComparer<IFoo<int>> h = EqualityComparer<IFoo<int>>.Default;
|
|||
|
|
IFoo<int> s = new Foo<int>();
|
|||
|
|
s.Add(1); s.Add(2); s.Add(3);
|
|||
|
|
Assert.AreEqual(CHC.unsequencedhashcode(1, 2, 3), h.GetHashCode(s));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//Nongeneric types implementing collection types:
|
|||
|
|
interface IBaz : ISequenced<int> { void Bamse(); }
|
|||
|
|
|
|||
|
|
class Baz : LinkedList<int>, IBaz
|
|||
|
|
{
|
|||
|
|
internal Baz() : base() { }
|
|||
|
|
public void Bamse() { }
|
|||
|
|
//int ISequenced<int>.GetHashCode() { return sequencedhashcode(); }
|
|||
|
|
//bool ISequenced<int>.Equals(ISequenced<int> that) { return sequencedequals(that); }
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void SeqequalityComparerViaBuilder4()
|
|||
|
|
{
|
|||
|
|
SCG.IEqualityComparer<IBaz> h = EqualityComparer<IBaz>.Default;
|
|||
|
|
IBaz s = new Baz();
|
|||
|
|
s.Add(1); s.Add(2); s.Add(3);
|
|||
|
|
Assert.AreEqual(CHC.sequencedhashcode(1, 2, 3), h.GetHashCode(s));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
interface IBar : ICollection<int>
|
|||
|
|
{
|
|||
|
|
void Bamse();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
class Bar : HashSet<int>, IBar
|
|||
|
|
{
|
|||
|
|
internal Bar() : base() { }
|
|||
|
|
public void Bamse() { }
|
|||
|
|
|
|||
|
|
//TODO: remove all this workaround stuff:
|
|||
|
|
|
|||
|
|
bool ICollection<int>.ContainsAll<U>(System.Collections.Generic.IEnumerable<U> items)
|
|||
|
|
{
|
|||
|
|
throw new NotImplementedException();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void ICollection<int>.RemoveAll<U>(System.Collections.Generic.IEnumerable<U> items)
|
|||
|
|
{
|
|||
|
|
throw new NotImplementedException();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void ICollection<int>.RetainAll<U>(System.Collections.Generic.IEnumerable<U> items)
|
|||
|
|
{
|
|||
|
|
throw new NotImplementedException();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void IExtensible<int>.AddAll<U>(System.Collections.Generic.IEnumerable<U> items)
|
|||
|
|
{
|
|||
|
|
throw new NotImplementedException();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void UnseqequalityComparerViaBuilder4()
|
|||
|
|
{
|
|||
|
|
SCG.IEqualityComparer<IBar> h = EqualityComparer<IBar>.Default;
|
|||
|
|
IBar s = new Bar();
|
|||
|
|
s.Add(1); s.Add(2); s.Add(3);
|
|||
|
|
Assert.AreEqual(CHC.unsequencedhashcode(1, 2, 3), h.GetHashCode(s));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void StaticEqualityComparerWithNull()
|
|||
|
|
{
|
|||
|
|
ArrayList<double> arr = new ArrayList<double>();
|
|||
|
|
SCG.IEqualityComparer<double> eqc = EqualityComparer<double>.Default;
|
|||
|
|
Assert.IsTrue(CollectionBase<double>.StaticEquals(arr, arr, eqc));
|
|||
|
|
Assert.IsTrue(CollectionBase<double>.StaticEquals(null, null, eqc));
|
|||
|
|
Assert.IsFalse(CollectionBase<double>.StaticEquals(arr, null, eqc));
|
|||
|
|
Assert.IsFalse(CollectionBase<double>.StaticEquals(null, arr, eqc));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private class EveryThingIsEqual : SCG.IEqualityComparer<Object>
|
|||
|
|
{
|
|||
|
|
public new bool Equals(Object o1, Object o2)
|
|||
|
|
{
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public new int GetHashCode(Object o)
|
|||
|
|
{
|
|||
|
|
return 1;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void UnsequencedCollectionComparerEquality()
|
|||
|
|
{
|
|||
|
|
// Repro for bug20101103
|
|||
|
|
SCG.IEqualityComparer<Object> eqc = new EveryThingIsEqual();
|
|||
|
|
Object o1 = new Object(), o2 = new Object();
|
|||
|
|
C5.ICollection<Object> coll1 = new ArrayList<Object>(eqc),
|
|||
|
|
coll2 = new ArrayList<Object>(eqc);
|
|||
|
|
coll1.Add(o1);
|
|||
|
|
coll2.Add(o2);
|
|||
|
|
Assert.IsFalse(o1.Equals(o2));
|
|||
|
|
Assert.IsTrue(coll1.UnsequencedEquals(coll2));
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|