public void InstantiationWithCopy () {
ISortDefinition copy = new MutableSortDefinition ("Bing!", false, false);
MutableSortDefinition def = new MutableSortDefinition (copy);
Assert.IsFalse (def.IgnoreCase);
Assert.IsFalse (def.Ascending);
Assert.IsNotNull (def.Property);
Assert.AreEqual (copy.Property, def.Property);
}
public void TestEquals () {
ISortDefinition copy = new MutableSortDefinition ("Rab", false, false);
MutableSortDefinition def = new MutableSortDefinition ("Bing!", false, false);
def.Property = "Rab";
Assert.AreEqual (copy, def);
Assert.AreEqual (copy.GetHashCode (), def.GetHashCode ());
Assert.IsFalse (def.Equals (null));
}
public void TogglesOkWhenPropertyIsSetAgain ()
{
MutableSortDefinition def = new MutableSortDefinition (true);
bool originalAscendingValue = def.Ascending;
def.Property = "Name";
def.Property = "Name"; // sort order should (must!) be reversed now...
Assert.IsFalse (def.Ascending == originalAscendingValue);
}
public void DoesNotTogglesWhenPropertyIsSetAgain ()
{
MutableSortDefinition def = new MutableSortDefinition (true);
bool originalAscendingValue = def.Ascending;
def.Property = "Name";
def.Property = "Age"; // sort order must not be toggled (different property)
Assert.IsTrue (def.Ascending == originalAscendingValue);
}
public void Compare()
{
ISortDefinition definition = new MutableSortDefinition("Age", false, true);
PropertyComparator cmp = new PropertyComparator(definition);
TestObject one = new TestObject("Rick", 19);
TestObject two = new TestObject("Balzac", 205);
int actual = cmp.Compare(one, two);
Assert.IsTrue(actual < 0); // 19 is less than 205
}
public void CompareWithNullProperty()
{
ISortDefinition definition = new MutableSortDefinition("Lawyer.Company", true, true);
PropertyComparator cmp = new PropertyComparator(definition);
TestObject one = new TestObject("Rick", 19);
one.Lawyer = new NestedTestObject("Gizajoab");
TestObject two = new TestObject("Balzac", 205);
// no Lawyer.Company property set on object two...
int actual = cmp.Compare(one, two);
Assert.IsTrue(actual > 0); // Gizajoab is greater than null
}
public void CompareNestedProperty()
{
ISortDefinition definition = new MutableSortDefinition("Lawyer.Company", true, true);
PropertyComparator cmp = new PropertyComparator(definition);
TestObject one = new TestObject("Rick", 19);
one.Lawyer = new NestedTestObject("Gizajoab");
TestObject two = new TestObject("Balzac", 205);
two.Lawyer = new NestedTestObject("Wallpaperer");
int actual = cmp.Compare(one, two);
Assert.IsTrue(actual < 0); // Gizajoab is less than Wallpaperer
}
public void CompareNestedProperty()
{
ISortDefinition definition = new MutableSortDefinition("Lawyer.Company", true, true);
PropertyComparator cmp = new PropertyComparator(definition);
TestObject one = new TestObject("Rick", 19);
one.Lawyer = new NestedTestObject("Gizajoab");
TestObject two = new TestObject("Balzac", 205);
two.Lawyer = new NestedTestObject("Wallpaperer");
int actual = cmp.Compare(one, two);
Assert.IsTrue(actual < 0); // Gizajoab is less than Wallpaperer
}
// [Ignore("Sort ordering is not preserved (unstable) with equal elements (c.f. System.Array.Sort (Array, IComparer)))")]
public void OrderingIsUnperturbedWithEqualProps()
{
ISortDefinition definition = new MutableSortDefinition("Age", false, true);
TestObject one = new TestObject("Rick", 19);
TestObject two = new TestObject("Balzac", 19);
TestObject three = new TestObject("Jenny", 19);
TestObject[] actual = new TestObject[] { one, two, three };
TestObject[] expected = new TestObject[] { one /*Rick*/, two /*Balzac*/, three /*Jenny*/ };
PropertyComparator.Sort(actual, definition);
for (int i = 0; i < actual.Length; ++i)
{
Assert.AreEqual(expected[i].Name, actual[i].Name);
}
}
public void Sort()
{
ISortDefinition definition = new MutableSortDefinition("NAmE", true, true);
TestObject one = new TestObject("Rick", 19);
TestObject two = new TestObject("Balzac", 205);
TestObject three = new TestObject("Jenny", 89);
TestObject[] actual = new TestObject[] { one, two, three };
TestObject[] expected = new TestObject[] { two /*Balzac*/, three /*Jenny*/, one /*Rick*/ };
PropertyComparator.Sort(actual, definition);
for (int i = 0; i < actual.Length; ++i)
{
Assert.AreEqual(expected[i].Name, actual[i].Name);
}
}
public void SortInDescendingOrder()
{
ISortDefinition definition = new MutableSortDefinition("NAmE", true, false);
TestObject one = new TestObject("Rick", 19);
TestObject two = new TestObject("Balzac", 205);
TestObject three = new TestObject("Jenny", 89);
TestObject[] actual = new TestObject[] { one, two, three };
// Rick comes after Jenny comes after Balzac (descending sort order)...
TestObject[] expected = new TestObject[] { one /*Rick*/, three /*Jenny*/, two /*Balzac*/ };
PropertyComparator.Sort(actual, definition);
for (int i = 0; i < actual.Length; ++i)
{
Assert.AreEqual(expected[i].Name, actual[i].Name);
}
}
public void CompareWithNonExistantProperty()
{
ISortDefinition definition = new MutableSortDefinition("Deborahs.Banjo", true, true);
PropertyComparator cmp = new PropertyComparator(definition);
TestObject one = new TestObject("Rick", 19);
TestObject two = new TestObject("Balzac", 205);
Assert.Throws<InvalidPropertyException>(() => cmp.Compare(one, two));
}
public void Sort()
{
ISortDefinition definition = new MutableSortDefinition("NAmE", true, true);
TestObject one = new TestObject("Rick", 19);
TestObject two = new TestObject("Balzac", 205);
TestObject three = new TestObject("Jenny", 89);
TestObject[] actual = new TestObject[] {one, two, three};
TestObject[] expected = new TestObject[] {two /*Balzac*/, three /*Jenny*/, one /*Rick*/};
PropertyComparator.Sort(actual, definition);
for (int i = 0; i < actual.Length; ++i)
{
Assert.AreEqual(expected[i].Name, actual[i].Name);
}
}
public void PropertySetter () {
MutableSortDefinition def = new MutableSortDefinition ();
def.Property = null;
Assert.IsNotNull (def.Property);
Assert.AreEqual (string.Empty, def.Property);
}
public void SortInDescendingOrder()
{
ISortDefinition definition = new MutableSortDefinition("NAmE", true, false);
TestObject one = new TestObject("Rick", 19);
TestObject two = new TestObject("Balzac", 205);
TestObject three = new TestObject("Jenny", 89);
TestObject[] actual = new TestObject[] {one, two, three};
// Rick comes after Jenny comes after Balzac (descending sort order)...
TestObject[] expected = new TestObject[] {one /*Rick*/, three /*Jenny*/, two /*Balzac*/};
PropertyComparator.Sort(actual, definition);
for (int i = 0; i < actual.Length; ++i)
{
Assert.AreEqual(expected[i].Name, actual[i].Name);
}
}
// [Ignore("Sort ordering is not preserved (unstable) with equal elements (c.f. System.Array.Sort (Array, IComparer)))")]
public void OrderingIsUnperturbedWithEqualProps()
{
ISortDefinition definition = new MutableSortDefinition("Age", false, true);
TestObject one = new TestObject("Rick", 19);
TestObject two = new TestObject("Balzac", 19);
TestObject three = new TestObject("Jenny", 19);
TestObject[] actual = new TestObject[] {one, two, three};
TestObject[] expected = new TestObject[] {one /*Rick*/, two /*Balzac*/, three /*Jenny*/};
PropertyComparator.Sort(actual, definition);
for (int i = 0; i < actual.Length; ++i)
{
Assert.AreEqual(expected[i].Name, actual[i].Name);
}
}
public void CompareWithNullArguments()
{
ISortDefinition definition = new MutableSortDefinition("Nails", false, true);
Funk one = new Funk(1, "long");
PropertyComparator cmp = new PropertyComparator(definition);
Assert.AreEqual(0, cmp.Compare(null, null));
// nulls are always last (i.e. greater than)
Assert.AreEqual(1, cmp.Compare(null, one));
// any non-null instance comes before null (i.e. less than).
Assert.AreEqual(-1, cmp.Compare(one, null));
}
public void Instantiation () {
MutableSortDefinition def = new MutableSortDefinition ();
Assert.IsTrue (def.IgnoreCase);
Assert.IsTrue (def.Ascending);
Assert.IsNotNull (def.Property);
}
public void CompareWithNonExistantProperty()
{
ISortDefinition definition = new MutableSortDefinition("Deborahs.Banjo", true, true);
PropertyComparator cmp = new PropertyComparator(definition);
TestObject one = new TestObject("Rick", 19);
TestObject two = new TestObject("Balzac", 205);
int actual = cmp.Compare(one, two);
Assert.IsTrue(actual == 0);
}
public void CanGetSortDefinition()
{
ISortDefinition definition = new MutableSortDefinition("Age", false, true);
PropertyComparator cmp = new PropertyComparator(definition);
ISortDefinition sortDefinition = cmp.SortDefinition;
Assert.AreSame(definition, sortDefinition);
Assert.AreEqual(definition.Property, sortDefinition.Property);
Assert.AreEqual(definition.Ascending, sortDefinition.Ascending);
Assert.AreEqual(definition.IgnoreCase, sortDefinition.IgnoreCase);
}
