1
|
/*
|
2
|
Copyright (c) 2003-2006 Niels Kokholm and Peter Sestoft
|
3
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
4
|
of this software and associated documentation files (the "Software"), to deal
|
5
|
in the Software without restriction, including without limitation the rights
|
6
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
7
|
copies of the Software, and to permit persons to whom the Software is
|
8
|
furnished to do so, subject to the following conditions:
|
9
|
|
10
|
The above copyright notice and this permission notice shall be included in
|
11
|
all copies or substantial portions of the Software.
|
12
|
|
13
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
14
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
15
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
16
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
17
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
18
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
19
|
SOFTWARE.
|
20
|
*/
|
21
|
|
22
|
using System;
|
23
|
using C5;
|
24
|
using NUnit.Framework;
|
25
|
using SCG = System.Collections.Generic;
|
26
|
|
27
|
|
28
|
namespace C5UnitTests.support
|
29
|
{
|
30
|
namespace bases
|
31
|
{
|
32
|
[TestFixture]
|
33
|
public class ArrayBaseTest
|
34
|
{
|
35
|
class ABT : ArrayBase<string>
|
36
|
{
|
37
|
public ABT() : base(8,NaturalEqualityComparer<string>.Default) { }
|
38
|
|
39
|
public override string Choose() { if (size > 0) return array[0]; throw new NoSuchItemException(); }
|
40
|
|
41
|
public string this[int i] { get { return array[i]; } set { array[i] = value; } }
|
42
|
|
43
|
|
44
|
public int thesize { get { return size; } set { size = value; } }
|
45
|
}
|
46
|
|
47
|
|
48
|
[Test]
|
49
|
public void Check()
|
50
|
{
|
51
|
ABT abt = new ABT();
|
52
|
|
53
|
abt.thesize = 3;
|
54
|
abt[2] = "aaa";
|
55
|
// Assert.IsFalse(abt.Check());
|
56
|
abt[0] = "##";
|
57
|
abt[1] = "##";
|
58
|
Assert.IsTrue(abt.Check());
|
59
|
}
|
60
|
}
|
61
|
}
|
62
|
|
63
|
namespace itemops
|
64
|
{
|
65
|
[TestFixture]
|
66
|
public class Comparers
|
67
|
{
|
68
|
class dbl : IComparable<dbl>
|
69
|
{
|
70
|
double d;
|
71
|
|
72
|
public dbl(double din) { d = din; }
|
73
|
|
74
|
public int CompareTo(dbl that)
|
75
|
{
|
76
|
return d < that.d ? -1 : d == that.d ? 0 : 1;
|
77
|
}
|
78
|
public bool Equals(dbl that) { return d == that.d; }
|
79
|
}
|
80
|
|
81
|
[Test]
|
82
|
[ExpectedException(typeof(NotComparableException))]
|
83
|
public void NotComparable()
|
84
|
{
|
85
|
SCG.IComparer<object> foo = Comparer<object>.Default;
|
86
|
}
|
87
|
|
88
|
[Test]
|
89
|
public void GenericC()
|
90
|
{
|
91
|
SCG.IComparer<dbl> h = new NaturalComparer<dbl>();
|
92
|
dbl s = new dbl(3.4);
|
93
|
dbl t = new dbl(3.4);
|
94
|
dbl u = new dbl(7.4);
|
95
|
|
96
|
Assert.AreEqual(0, h.Compare(s, t));
|
97
|
Assert.IsTrue(h.Compare(s, u) < 0);
|
98
|
}
|
99
|
|
100
|
|
101
|
[Test]
|
102
|
public void OrdinaryC()
|
103
|
{
|
104
|
SCG.IComparer<string> h = new NaturalComparerO<string>();
|
105
|
string s = "bamse";
|
106
|
string t = "bamse";
|
107
|
string u = "bimse";
|
108
|
|
109
|
Assert.AreEqual(0, h.Compare(s, t));
|
110
|
Assert.IsTrue(h.Compare(s, u) < 0);
|
111
|
}
|
112
|
|
113
|
|
114
|
[Test]
|
115
|
public void GenericCViaBuilder()
|
116
|
{
|
117
|
SCG.IComparer<dbl> h = Comparer<dbl>.Default;
|
118
|
dbl s = new dbl(3.4);
|
119
|
dbl t = new dbl(3.4);
|
120
|
dbl u = new dbl(7.4);
|
121
|
|
122
|
Assert.AreEqual(0, h.Compare(s, t));
|
123
|
Assert.IsTrue(h.Compare(s, u) < 0);
|
124
|
Assert.AreSame(h, Comparer<dbl>.Default);
|
125
|
}
|
126
|
|
127
|
|
128
|
[Test]
|
129
|
public void OrdinaryCViaBuilder()
|
130
|
{
|
131
|
SCG.IComparer<string> h = Comparer<string>.Default;
|
132
|
string s = "bamse";
|
133
|
string t = "bamse";
|
134
|
string u = "bimse";
|
135
|
|
136
|
Assert.AreEqual(0, h.Compare(s, t));
|
137
|
Assert.IsTrue(h.Compare(s, u) < 0);
|
138
|
Assert.AreSame(h, Comparer<string>.Default);
|
139
|
|
140
|
}
|
141
|
|
142
|
public void ComparerViaBuilderTest<T>(T item1, T item2)
|
143
|
where T : IComparable<T>
|
144
|
{
|
145
|
SCG.IComparer<T> h = Comparer<T>.Default;
|
146
|
Assert.AreSame(h, Comparer<T>.Default);
|
147
|
Assert.AreEqual(0, h.Compare(item1, item1));
|
148
|
Assert.AreEqual(0, h.Compare(item2, item2));
|
149
|
Assert.IsTrue(h.Compare(item1, item2) < 0);
|
150
|
Assert.IsTrue(h.Compare(item2, item1) > 0);
|
151
|
Assert.AreEqual(Math.Sign(item1.CompareTo(item2)), Math.Sign(h.Compare(item1, item2)));
|
152
|
Assert.AreEqual(Math.Sign(item2.CompareTo(item1)), Math.Sign(h.Compare(item2, item1)));
|
153
|
}
|
154
|
|
155
|
[Test]
|
156
|
public void PrimitiveComparersViaBuilder()
|
157
|
{
|
158
|
ComparerViaBuilderTest<char>('A', 'a');
|
159
|
ComparerViaBuilderTest<sbyte>(-122, 126);
|
160
|
ComparerViaBuilderTest<byte>(122, 126);
|
161
|
ComparerViaBuilderTest<short>(-30000, 3);
|
162
|
ComparerViaBuilderTest<ushort>(3, 50000);
|
163
|
ComparerViaBuilderTest<int>(-10000000, 10000);
|
164
|
ComparerViaBuilderTest<uint>(10000000, 3000000000);
|
165
|
ComparerViaBuilderTest<long>(-1000000000000, 10000000);
|
166
|
ComparerViaBuilderTest<ulong>(10000000000000UL, 10000000000004UL);
|
167
|
ComparerViaBuilderTest<float>(-0.001F, 0.00001F);
|
168
|
ComparerViaBuilderTest<double>(-0.001, 0.00001E-200);
|
169
|
ComparerViaBuilderTest<decimal>(-20.001M, 19.999M);
|
170
|
}
|
171
|
|
172
|
// This test is obsoleted by the one above, but we keep it for good measure
|
173
|
[Test]
|
174
|
public void IntComparerViaBuilder()
|
175
|
{
|
176
|
SCG.IComparer<int> h = Comparer<int>.Default;
|
177
|
int s = 4;
|
178
|
int t = 4;
|
179
|
int u = 5;
|
180
|
|
181
|
Assert.AreEqual(0, h.Compare(s, t));
|
182
|
Assert.IsTrue(h.Compare(s, u) < 0);
|
183
|
Assert.AreSame(h, Comparer<int>.Default);
|
184
|
}
|
185
|
|
186
|
[Test]
|
187
|
public void Nulls()
|
188
|
{
|
189
|
Assert.IsTrue(Comparer<string>.Default.Compare(null, "abe") < 0);
|
190
|
Assert.IsTrue(Comparer<string>.Default.Compare(null, null) == 0);
|
191
|
Assert.IsTrue(Comparer<string>.Default.Compare("abe", null) > 0);
|
192
|
}
|
193
|
}
|
194
|
|
195
|
[TestFixture]
|
196
|
public class EqualityComparers
|
197
|
{
|
198
|
[Test]
|
199
|
public void ReftypeequalityComparer()
|
200
|
{
|
201
|
SCG.IEqualityComparer<string> h = NaturalEqualityComparer<string>.Default;
|
202
|
string s = "bamse";
|
203
|
string t = "bamse";
|
204
|
string u = "bimse";
|
205
|
|
206
|
Assert.AreEqual(s.GetHashCode(), h.GetHashCode(s));
|
207
|
Assert.IsTrue(h.Equals(s, t));
|
208
|
Assert.IsFalse(h.Equals(s, u));
|
209
|
}
|
210
|
|
211
|
|
212
|
[Test]
|
213
|
public void ValuetypeequalityComparer()
|
214
|
{
|
215
|
SCG.IEqualityComparer<double> h = NaturalEqualityComparer<double>.Default;
|
216
|
double s = 3.4;
|
217
|
double t = 3.4;
|
218
|
double u = 5.7;
|
219
|
|
220
|
Assert.AreEqual(s.GetHashCode(), h.GetHashCode(s));
|
221
|
Assert.IsTrue(h.Equals(s, t));
|
222
|
Assert.IsFalse(h.Equals(s, u));
|
223
|
}
|
224
|
|
225
|
internal class REHTest { public override int GetHashCode() { return 37; } }
|
226
|
|
227
|
[Test]
|
228
|
public void ReferenceEqualityEqualityComparerTest()
|
229
|
{
|
230
|
REHTest rehtest = new REHTest();
|
231
|
SCG.IEqualityComparer<REHTest> equalityComparer = ReferenceEqualityComparer<REHTest>.Default;
|
232
|
Assert.AreEqual(37, rehtest.GetHashCode());
|
233
|
Assert.IsFalse(equalityComparer.GetHashCode(rehtest) == 37);
|
234
|
}
|
235
|
|
236
|
[Test]
|
237
|
public void ReftypeequalityComparerViaBuilder()
|
238
|
{
|
239
|
SCG.IEqualityComparer<string> h = EqualityComparer<string>.Default;
|
240
|
string s = "bamse";
|
241
|
string t = "bamse";
|
242
|
string u = "bimse";
|
243
|
|
244
|
Assert.AreEqual(s.GetHashCode(), h.GetHashCode(s));
|
245
|
Assert.IsTrue(h.Equals(s, t));
|
246
|
Assert.IsFalse(h.Equals(s, u));
|
247
|
Assert.AreSame(h, EqualityComparer<string>.Default);
|
248
|
}
|
249
|
|
250
|
|
251
|
[Test]
|
252
|
public void ValuetypeequalityComparerViaBuilder()
|
253
|
{
|
254
|
SCG.IEqualityComparer<double> h = EqualityComparer<double>.Default;
|
255
|
double s = 3.4;
|
256
|
double t = 3.4;
|
257
|
double u = 5.7;
|
258
|
|
259
|
Assert.AreEqual(s.GetHashCode(), h.GetHashCode(s));
|
260
|
Assert.IsTrue(h.Equals(s, t));
|
261
|
Assert.IsFalse(h.Equals(s, u));
|
262
|
Assert.AreSame(h, EqualityComparer<double>.Default);
|
263
|
}
|
264
|
|
265
|
[Test]
|
266
|
public void CharequalityComparerViaBuilder()
|
267
|
{
|
268
|
SCG.IEqualityComparer<char> h = EqualityComparer<char>.Default;
|
269
|
char s = '?';
|
270
|
char t = '?';
|
271
|
char u = 'r';
|
272
|
|
273
|
Assert.AreEqual(s.GetHashCode(), h.GetHashCode(s));
|
274
|
Assert.IsTrue(h.Equals(s, t));
|
275
|
Assert.IsFalse(h.Equals(s, u));
|
276
|
Assert.AreSame(h, EqualityComparer<char>.Default);
|
277
|
}
|
278
|
|
279
|
[Test]
|
280
|
public void SbyteequalityComparerViaBuilder()
|
281
|
{
|
282
|
SCG.IEqualityComparer<sbyte> h = EqualityComparer<sbyte>.Default;
|
283
|
sbyte s = 3;
|
284
|
sbyte t = 3;
|
285
|
sbyte u = -5;
|
286
|
|
287
|
Assert.AreEqual(s.GetHashCode(), h.GetHashCode(s));
|
288
|
Assert.IsTrue(h.Equals(s, t));
|
289
|
Assert.IsFalse(h.Equals(s, u));
|
290
|
Assert.AreSame(h, EqualityComparer<sbyte>.Default);
|
291
|
}
|
292
|
|
293
|
[Test]
|
294
|
public void ByteequalityComparerViaBuilder()
|
295
|
{
|
296
|
SCG.IEqualityComparer<byte> h = EqualityComparer<byte>.Default;
|
297
|
byte s = 3;
|
298
|
byte t = 3;
|
299
|
byte u = 5;
|
300
|
|
301
|
Assert.AreEqual(s.GetHashCode(), h.GetHashCode(s));
|
302
|
Assert.IsTrue(h.Equals(s, t));
|
303
|
Assert.IsFalse(h.Equals(s, u));
|
304
|
Assert.AreSame(h, EqualityComparer<byte>.Default);
|
305
|
}
|
306
|
|
307
|
[Test]
|
308
|
public void ShortequalityComparerViaBuilder()
|
309
|
{
|
310
|
SCG.IEqualityComparer<short> h = EqualityComparer<short>.Default;
|
311
|
short s = 3;
|
312
|
short t = 3;
|
313
|
short u = -5;
|
314
|
|
315
|
Assert.AreEqual(s.GetHashCode(), h.GetHashCode(s));
|
316
|
Assert.IsTrue(h.Equals(s, t));
|
317
|
Assert.IsFalse(h.Equals(s, u));
|
318
|
Assert.AreSame(h, EqualityComparer<short>.Default);
|
319
|
}
|
320
|
|
321
|
[Test]
|
322
|
public void UshortequalityComparerViaBuilder()
|
323
|
{
|
324
|
SCG.IEqualityComparer<ushort> h = EqualityComparer<ushort>.Default;
|
325
|
ushort s = 3;
|
326
|
ushort t = 3;
|
327
|
ushort u = 60000;
|
328
|
|
329
|
Assert.AreEqual(s.GetHashCode(), h.GetHashCode(s));
|
330
|
Assert.IsTrue(h.Equals(s, t));
|
331
|
Assert.IsFalse(h.Equals(s, u));
|
332
|
Assert.AreSame(h, EqualityComparer<ushort>.Default);
|
333
|
}
|
334
|
|
335
|
[Test]
|
336
|
public void IntequalityComparerViaBuilder()
|
337
|
{
|
338
|
SCG.IEqualityComparer<int> h = EqualityComparer<int>.Default;
|
339
|
int s = 3;
|
340
|
int t = 3;
|
341
|
int u = -5;
|
342
|
|
343
|
Assert.AreEqual(s.GetHashCode(), h.GetHashCode(s));
|
344
|
Assert.IsTrue(h.Equals(s, t));
|
345
|
Assert.IsFalse(h.Equals(s, u));
|
346
|
Assert.AreSame(h, EqualityComparer<int>.Default);
|
347
|
}
|
348
|
|
349
|
[Test]
|
350
|
public void UintequalityComparerViaBuilder()
|
351
|
{
|
352
|
SCG.IEqualityComparer<uint> h = EqualityComparer<uint>.Default;
|
353
|
uint s = 3;
|
354
|
uint t = 3;
|
355
|
uint u = 3000000000;
|
356
|
|
357
|
Assert.AreEqual(s.GetHashCode(), h.GetHashCode(s));
|
358
|
Assert.IsTrue(h.Equals(s, t));
|
359
|
Assert.IsFalse(h.Equals(s, u));
|
360
|
Assert.AreSame(h, EqualityComparer<uint>.Default);
|
361
|
}
|
362
|
|
363
|
[Test]
|
364
|
public void LongequalityComparerViaBuilder()
|
365
|
{
|
366
|
SCG.IEqualityComparer<long> h = EqualityComparer<long>.Default;
|
367
|
long s = 3;
|
368
|
long t = 3;
|
369
|
long u = -500000000000000L;
|
370
|
|
371
|
Assert.AreEqual(s.GetHashCode(), h.GetHashCode(s));
|
372
|
Assert.IsTrue(h.Equals(s, t));
|
373
|
Assert.IsFalse(h.Equals(s, u));
|
374
|
Assert.AreSame(h, EqualityComparer<long>.Default);
|
375
|
}
|
376
|
|
377
|
[Test]
|
378
|
public void UlongequalityComparerViaBuilder()
|
379
|
{
|
380
|
SCG.IEqualityComparer<ulong> h = EqualityComparer<ulong>.Default;
|
381
|
ulong s = 3;
|
382
|
ulong t = 3;
|
383
|
ulong u = 500000000000000UL;
|
384
|
|
385
|
Assert.AreEqual(s.GetHashCode(), h.GetHashCode(s));
|
386
|
Assert.IsTrue(h.Equals(s, t));
|
387
|
Assert.IsFalse(h.Equals(s, u));
|
388
|
Assert.AreSame(h, EqualityComparer<ulong>.Default);
|
389
|
}
|
390
|
|
391
|
[Test]
|
392
|
public void FloatequalityComparerViaBuilder()
|
393
|
{
|
394
|
SCG.IEqualityComparer<float> h = EqualityComparer<float>.Default;
|
395
|
float s = 3.1F;
|
396
|
float t = 3.1F;
|
397
|
float u = -5.2F;
|
398
|
|
399
|
Assert.AreEqual(s.GetHashCode(), h.GetHashCode(s));
|
400
|
Assert.IsTrue(h.Equals(s, t));
|
401
|
Assert.IsFalse(h.Equals(s, u));
|
402
|
Assert.AreSame(h, EqualityComparer<float>.Default);
|
403
|
}
|
404
|
|
405
|
[Test]
|
406
|
public void DoubleequalityComparerViaBuilder()
|
407
|
{
|
408
|
SCG.IEqualityComparer<double> h = EqualityComparer<double>.Default;
|
409
|
double s = 3.12345;
|
410
|
double t = 3.12345;
|
411
|
double u = -5.2;
|
412
|
|
413
|
Assert.AreEqual(s.GetHashCode(), h.GetHashCode(s));
|
414
|
Assert.IsTrue(h.Equals(s, t));
|
415
|
Assert.IsFalse(h.Equals(s, u));
|
416
|
Assert.AreSame(h, EqualityComparer<double>.Default);
|
417
|
}
|
418
|
|
419
|
[Test]
|
420
|
public void DecimalequalityComparerViaBuilder()
|
421
|
{
|
422
|
SCG.IEqualityComparer<decimal> h = EqualityComparer<decimal>.Default;
|
423
|
decimal s = 3.0001M;
|
424
|
decimal t = 3.0001M;
|
425
|
decimal u = -500000000000000M;
|
426
|
|
427
|
Assert.AreEqual(s.GetHashCode(), h.GetHashCode(s));
|
428
|
Assert.IsTrue(h.Equals(s, t));
|
429
|
Assert.IsFalse(h.Equals(s, u));
|
430
|
Assert.AreSame(h, EqualityComparer<decimal>.Default);
|
431
|
}
|
432
|
|
433
|
[Test]
|
434
|
public void UnseqequalityComparerViaBuilder()
|
435
|
{
|
436
|
SCG.IEqualityComparer<ICollection<int>> h = EqualityComparer<ICollection<int>>.Default;
|
437
|
ICollection<int> s = new LinkedList<int>();
|
438
|
ICollection<int> t = new LinkedList<int>();
|
439
|
ICollection<int> u = new LinkedList<int>();
|
440
|
s.Add(1); s.Add(2); s.Add(3);
|
441
|
t.Add(3); t.Add(2); t.Add(1);
|
442
|
u.Add(3); u.Add(2); u.Add(4);
|
443
|
Assert.AreEqual(s.GetUnsequencedHashCode(), h.GetHashCode(s));
|
444
|
Assert.IsTrue(h.Equals(s, t));
|
445
|
Assert.IsFalse(h.Equals(s, u));
|
446
|
Assert.AreSame(h, EqualityComparer<ICollection<int>>.Default);
|
447
|
}
|
448
|
|
449
|
[Test]
|
450
|
public void SeqequalityComparerViaBuilder2()
|
451
|
{
|
452
|
SCG.IEqualityComparer<LinkedList<int>> h = EqualityComparer<LinkedList<int>>.Default;
|
453
|
LinkedList<int> s = new LinkedList<int>();
|
454
|
s.Add(1); s.Add(2); s.Add(3);
|
455
|
Assert.AreEqual(CHC.sequencedhashcode(1, 2, 3), h.GetHashCode(s));
|
456
|
}
|
457
|
|
458
|
[Test]
|
459
|
public void UnseqequalityComparerViaBuilder2()
|
460
|
{
|
461
|
SCG.IEqualityComparer<HashSet<int>> h = EqualityComparer<HashSet<int>>.Default;
|
462
|
HashSet<int> s = new HashSet<int>();
|
463
|
s.Add(1); s.Add(2); s.Add(3);
|
464
|
Assert.AreEqual(CHC.unsequencedhashcode(1, 2, 3), h.GetHashCode(s));
|
465
|
}
|
466
|
|
467
|
//generic types implementing collection interfaces
|
468
|
[Test]
|
469
|
public void SeqequalityComparerViaBuilder3()
|
470
|
{
|
471
|
SCG.IEqualityComparer<IList<int>> h = EqualityComparer<IList<int>>.Default;
|
472
|
IList<int> s = new LinkedList<int>();
|
473
|
s.Add(1); s.Add(2); s.Add(3);
|
474
|
Assert.AreEqual(CHC.sequencedhashcode(1, 2, 3), h.GetHashCode(s));
|
475
|
}
|
476
|
|
477
|
interface IFoo<T> : ICollection<T> { void Bamse(); }
|
478
|
|
479
|
class Foo<T> : HashSet<T>, IFoo<T>
|
480
|
{
|
481
|
internal Foo() : base() { }
|
482
|
public void Bamse() { }
|
483
|
}
|
484
|
|
485
|
[Test]
|
486
|
public void UnseqequalityComparerViaBuilder3()
|
487
|
{
|
488
|
SCG.IEqualityComparer<IFoo<int>> h = EqualityComparer<IFoo<int>>.Default;
|
489
|
IFoo<int> s = new Foo<int>();
|
490
|
s.Add(1); s.Add(2); s.Add(3);
|
491
|
Assert.AreEqual(CHC.unsequencedhashcode(1, 2, 3), h.GetHashCode(s));
|
492
|
}
|
493
|
|
494
|
//Nongeneric types implementing collection types:
|
495
|
interface IBaz : ISequenced<int> { void Bamse(); }
|
496
|
|
497
|
class Baz : LinkedList<int>, IBaz
|
498
|
{
|
499
|
internal Baz() : base() { }
|
500
|
public void Bamse() { }
|
501
|
//int ISequenced<int>.GetHashCode() { return sequencedhashcode(); }
|
502
|
//bool ISequenced<int>.Equals(ISequenced<int> that) { return sequencedequals(that); }
|
503
|
}
|
504
|
|
505
|
[Test]
|
506
|
public void SeqequalityComparerViaBuilder4()
|
507
|
{
|
508
|
SCG.IEqualityComparer<IBaz> h = EqualityComparer<IBaz>.Default;
|
509
|
IBaz s = new Baz();
|
510
|
s.Add(1); s.Add(2); s.Add(3);
|
511
|
Assert.AreEqual(CHC.sequencedhashcode(1, 2, 3), h.GetHashCode(s));
|
512
|
}
|
513
|
|
514
|
interface IBar : ICollection<int>
|
515
|
{
|
516
|
void Bamse();
|
517
|
}
|
518
|
|
519
|
class Bar : HashSet<int>, IBar
|
520
|
{
|
521
|
internal Bar() : base() { }
|
522
|
public void Bamse() { }
|
523
|
|
524
|
//TODO: remove all this workaround stuff:
|
525
|
|
526
|
bool ICollection<int>.ContainsAll<U>(System.Collections.Generic.IEnumerable<U> items)
|
527
|
{
|
528
|
throw new NotImplementedException();
|
529
|
}
|
530
|
|
531
|
void ICollection<int>.RemoveAll<U>(System.Collections.Generic.IEnumerable<U> items)
|
532
|
{
|
533
|
throw new NotImplementedException();
|
534
|
}
|
535
|
|
536
|
void ICollection<int>.RetainAll<U>(System.Collections.Generic.IEnumerable<U> items)
|
537
|
{
|
538
|
throw new NotImplementedException();
|
539
|
}
|
540
|
|
541
|
void IExtensible<int>.AddAll<U>(System.Collections.Generic.IEnumerable<U> items)
|
542
|
{
|
543
|
throw new NotImplementedException();
|
544
|
}
|
545
|
|
546
|
}
|
547
|
|
548
|
[Test]
|
549
|
public void UnseqequalityComparerViaBuilder4()
|
550
|
{
|
551
|
SCG.IEqualityComparer<IBar> h = EqualityComparer<IBar>.Default;
|
552
|
IBar s = new Bar();
|
553
|
s.Add(1); s.Add(2); s.Add(3);
|
554
|
Assert.AreEqual(CHC.unsequencedhashcode(1, 2, 3), h.GetHashCode(s));
|
555
|
}
|
556
|
|
557
|
[Test]
|
558
|
public void StaticEqualityComparerWithNull()
|
559
|
{
|
560
|
ArrayList<double> arr = new ArrayList<double>();
|
561
|
SCG.IEqualityComparer<double> eqc = EqualityComparer<double>.Default;
|
562
|
Assert.IsTrue(CollectionBase<double>.StaticEquals(arr, arr, eqc));
|
563
|
Assert.IsTrue(CollectionBase<double>.StaticEquals(null, null, eqc));
|
564
|
Assert.IsFalse(CollectionBase<double>.StaticEquals(arr, null, eqc));
|
565
|
Assert.IsFalse(CollectionBase<double>.StaticEquals(null, arr, eqc));
|
566
|
}
|
567
|
}
|
568
|
}
|
569
|
}
|