public void TryParse_AllowCustomQualifiedComparison_ForDomainSpecificSorting()
{
string languages = "text/*, text/plain";
Predicate <Qualified> isSubtype = q => q.Value.EndsWith("*");
Comparison <Qualified> subtypesComeLater = (q1, q2) =>
{
var quality = q1.Quality.CompareTo(q2.Quality);
if (quality == 0)
{
if (isSubtype(q1) && !isSubtype(q2))
{
return(-1);
}
if (!isSubtype(q1) && isSubtype(q2))
{
return(1);
}
return(StringComparer.Ordinal.Compare(q1.Value, q2.Value));
}
return(quality);
};
var subject = QualifiedCollection.TryParse(languages, Cmp <Qualified> .By(subtypesComeLater));
Assert.That(subject, Is.EqualTo(new[]
{
new Qualified("text/plain", Quality.Default),
new Qualified("text/*", Quality.Default)
}).Using(_equalizer));
}
public void MaxBy_AlternativeComparer_MinimumValueAccordingToSelectorAndComparer()
{
var twoMinusTwo = new OrderSubject(2, -2);
var collection = new[] { new OrderSubject(2, -1), twoMinusTwo };
IComparer <int> absComparer = Cmp <int>
.By((one, other) => Math.Abs(one).CompareTo(Math.Abs(other)));
Assert.That(collection.MaxBy(s => s.I2, absComparer), Is.EqualTo(twoMinusTwo));
}
public void MinBy_AlternativeComparer_MinimumValueAccordingToSelectorAndComparer()
{
var twoOne = new OrderSubject(2, 1);
var collection = new[] { new OrderSubject(2, -2), twoOne };
IComparer <int> absComparer = Cmp <int>
.By((one, other) => Math.Abs(one).CompareTo(Math.Abs(other)));
Assert.That(collection.MinBy(s => s.I2, absComparer), Is.SameAs(twoOne));
}
public void ChainableComparer_By3Then2_FactoredWithSelectors()
{
_subjects.Sort(Cmp <ComparisonSubject> .By(c => c.Property3)
.Then(c => c.Property2, Direction.Ascending));
Assert.That(_subjects, Must.Be.RepresentableAs("B, D, E, C, A"));
_subjects.Sort(Cmp <ComparisonSubject> .By(c => c.Property3)
.Then(c => c.Property2, Direction.Descending));
Assert.That(_subjects, Must.Be.RepresentableAs("B, D, E, C, A"));
}
public void ChaineableComparer_CanBeUsedWithLinq()
{
Assert.That(_subjects.OrderBy(s => s, Cmp <ComparisonSubject>
.By(s => s.Property3)
.Then(s => s.Property2)),
Must.Be.RepresentableAs("B, D, E, C, A"));
Assert.That(_subjects.OrderBy(s => s, Cmp <ComparisonSubject>
.By(s => s.Property3)
.Then(s => s.Property2, Direction.Descending)),
Must.Be.RepresentableAs("B, D, E, C, A"));
}
public void Explore()
{
IComparer <ComparisonSubject> subject = new SelectorComparer <ComparisonSubject, int>(s => s.Property2, Direction.Descending);
Assert.That(subject.Compare(ComparisonSubject.One, ComparisonSubject.Two), Is.GreaterThan(0));
IComparer <ComparisonSubject> by3Then2Desc = new SelectorComparer <ComparisonSubject, decimal>(s => s.Property3)
.Then(s => s.Property2, Direction.Descending);
by3Then2Desc = Cmp <ComparisonSubject> .By(s => s.Property3)
.Then(s => s.Property2, Direction.Descending);
}
public void Explore()
{
Comparison <ComparisonSubject> compare2 = (x, y) => x.Property2.CompareTo(y.Property2);
var subject = new ComparisonComparer <ComparisonSubject>(compare2, Direction.Ascending);
Assert.That(subject.Compare(ComparisonSubject.One, ComparisonSubject.Two), Is.LessThan(0));
Assert.That(subject, Is.InstanceOf <IComparer <ComparisonSubject> >());
Assert.That(subject.Comparison, Is.InstanceOf <Comparison <ComparisonSubject> >());
IComparer <ComparisonSubject> by3Then2Desc = new ComparisonComparer <ComparisonSubject>((x, y) => x.Property3.CompareTo(y.Property3))
.Then(new ComparisonComparer <ComparisonSubject>((x, y) => x.Property2.CompareTo(y.Property2), Direction.Descending));
by3Then2Desc = new ComparisonComparer <ComparisonSubject>((x, y) => x.Property3.CompareTo(y.Property3))
.Then((x, y) => x.Property2.CompareTo(y.Property2), Direction.Descending);
by3Then2Desc = Cmp <ComparisonSubject> .By((x, y) => x.Property3.CompareTo(y.Property3))
.Then((x, y) => x.Property2.CompareTo(y.Property2), Direction.Descending);
}
public void Explore()
{
Func <EqualitySubject, EqualitySubject, bool> compareI = (x, y) => x.I.Equals(y.I);
var subject = new DelegatedEqualizer <EqualitySubject>(compareI, s => s.I.GetHashCode());
var x1 = new EqualitySubject("x", 1, 1m);
Assert.That(subject.Equals(x1, new EqualitySubject("y", 1, 2m)), Is.True);
var custom = new DelegatedEqualizer <EqualitySubject>((x, y) => x.I.Equals(y.I), s => s.I.GetHashCode());
Assert.That(custom.GetHashCode(x1), Is.EqualTo(x1.I.GetHashCode()));
custom = new DelegatedEqualizer <EqualitySubject>((x, y) => x.I.Equals(y.I), s => Hasher.Default(s.I));
Assert.That(custom.GetHashCode(x1), Is.EqualTo(x1.I.GetHashCode()));
var @default = new DelegatedEqualizer <EqualitySubject>((x, y) => x.I.Equals(y.I), Hasher.Default);
Assert.That(@default.GetHashCode(x1), Is.EqualTo(x1.GetHashCode()));
var zero = new DelegatedEqualizer <EqualitySubject>((x, y) => x.I.Equals(y.I), Hasher.Zero);
Assert.That(zero.GetHashCode(x1), Is.EqualTo(0));
IEqualityComparer <EqualitySubject> bySAndI = new DelegatedEqualizer <EqualitySubject>((x, y) => x.S.Equals(y.S), Hasher.Zero)
.Then(new DelegatedEqualizer <EqualitySubject>((x, y) => x.I.Equals(y.I), Hasher.Default));
bySAndI = new DelegatedEqualizer <EqualitySubject>((x, y) => x.S.Equals(y.S), Hasher.Zero)
.Then((x, y) => x.I == y.I, Hasher.Default);
bySAndI = Eq <EqualitySubject> .By((x, y) => x.S.Equals(y.S), Hasher.Zero)
.Then((x, y) => x == y, Hasher.Default);
IComparer <EqualitySubject> comparer = Cmp <EqualitySubject> .By(x => x.I);
IEqualityComparer <EqualitySubject> eq = new DelegatedEqualizer <EqualitySubject>(comparer, Hasher.Zero);
Comparison <EqualitySubject> comparison = (x, y) => x.D.CompareTo(y.D);
eq = new DelegatedEqualizer <EqualitySubject>(comparison, Hasher.Zero);
}
