public void ThenOrderingThenOrderingOrdering1_Test()
{
int[] orderNums1 = { 4, 4, 0, 4, 2 };
int[] orderNums2 = { -1, -1, 4, 3, 4 };
int[] orderNums3 = { 4, -1, -1, 2, -1 };
ObservableCollection <Item> items = getObservableCollection(orderNums1, orderNums2, orderNums3);
ThenOrdering <Item, int?> ordering3 = items.Ordering(i => i.OrderNum, ListSortDirection.Ascending).ThenOrdering(i => i.OrderNum2, ListSortDirection.Ascending).ThenOrdering(i => i.OrderNum3, ListSortDirection.Ascending);
items[3] = new Item(null, null);
ordering3.ValidateConsistency();
}
public static void TestChangeSortDirection()
{
ObservableCollection <Item> items = getObservableCollection(new[] { 0, 2, 3, 7, 5, 2, 4, 7, 5, 6, 1, 5 },
new[] { 0, 2, 3, 8, 1, 2, 4, 8, 2, 6, 1, 3 },
new[] { 0, 2, 3, 7, 5, 2, 4, 0, 5, 6, 1, 5 });
Scalar <ListSortDirection> listSortDirectionScalar = new Scalar <ListSortDirection>(ListSortDirection.Ascending);
Ordering <Item, int?> ordering = items.Ordering(i => i.OrderNum, listSortDirectionScalar);
ThenOrdering <Item, int?> ordering1 = items.Ordering(i => i.OrderNum, listSortDirectionScalar).ThenOrdering(i => i.OrderNum2, listSortDirectionScalar);
listSortDirectionScalar.Change(ListSortDirection.Descending);
ordering.ValidateConsistency();
ordering1.ValidateConsistency();
}
private void test(int[] orderNums, int[] orderNums2, int[] orderNums3, ListSortDirection listSortDirection, ListSortDirection listSortDirection2)
{
int index = 0;
int orderNum = 0;
int orderNum2 = 0;
int orderNum3 = 0;
int indexOld = 0;
int indexNew = 0;
string testNum = string.Empty;
ObservableCollection <Item> items;
Ordering <Item, int?> ordering;
try
{
//trace(testNum = "1", orderNums, orderNums2, orderNums3, listSortDirection, index, orderNum, orderNum2, indexOld, indexNew);
//items = getObservableCollection(orderNums, orderNums2, orderNums3);
//ordering = items.Ordering(i => i.OrderNum, listSortDirection);
//ordering.ValidateInternalConsistency();
for (index = 0; index < orderNums.Length; index++)
{
if (!traceThenOrderingThenOrderingOrdering(testNum = "2", orderNums, orderNums2, orderNums3, listSortDirection, listSortDirection2, index, orderNum, orderNum2, orderNum3, indexOld, indexNew))
{
continue;
}
items = getObservableCollection(orderNums, orderNums2, orderNums3);
ThenOrdering <Item, int?> ordering1 = items.Ordering(i => i.OrderNum, listSortDirection).ThenOrdering(i => i.OrderNum2, listSortDirection).ThenOrdering(i => i.OrderNum3, listSortDirection2).For(consumer);
items.RemoveAt(index);
ordering1.ValidateInternalConsistency();
consumer.Dispose();
}
for (index = 0; index <= orderNums.Length; index++)
{
for (orderNum = 0; orderNum <= orderNums.Length; orderNum++)
{
for (orderNum2 = 0; orderNum2 <= orderNums.Length; orderNum2++)
{
for (orderNum3 = 0; orderNum3 <= orderNums.Length; orderNum3++)
{
if (!traceThenOrderingThenOrderingOrdering(testNum = "8", orderNums, orderNums2, orderNums3, listSortDirection, listSortDirection2, index, orderNum, orderNum2, orderNum3, indexOld, indexNew))
{
continue;
}
items = getObservableCollection(orderNums, orderNums2, orderNums3);
ThenOrdering <Item, int?> ordering1 = items.Ordering(i => i.OrderNum, listSortDirection).ThenOrdering(i => i.OrderNum2, listSortDirection).ThenOrdering(i => i.OrderNum3, listSortDirection2).For(consumer);
items.Insert(index, new Item(orderNum == -1 ? (int?)null : orderNum, orderNum2 == -1 ? (int?)null : orderNum2, orderNum3 == -1 ? (int?)null : orderNum3));
ordering1.ValidateInternalConsistency();
consumer.Dispose();
}
}
}
}
for (index = 0; index < orderNums.Length; index++)
{
traceThenOrderingThenOrderingOrdering(testNum = "6", orderNums, orderNums2, orderNums3, listSortDirection, listSortDirection2, index, orderNum, orderNum2, orderNum3, indexOld, indexNew);
items = getObservableCollection(orderNums, orderNums2, orderNums3);
ThenOrdering <Item, int?> ordering3 = items.Ordering(i => i.OrderNum, listSortDirection).ThenOrdering(i => i.OrderNum2, listSortDirection).ThenOrdering(i => i.OrderNum3, listSortDirection2).For(consumer);
items[index] = new Item(null, null);
ordering3.ValidateInternalConsistency();
consumer.Dispose();
for (orderNum = -1; orderNum <= orderNums.Length; orderNum++)
{
for (orderNum2 = -1; orderNum2 <= orderNums.Length; orderNum2++)
{
for (orderNum3 = -1; orderNum3 <= orderNums.Length; orderNum3++)
{
if (!traceThenOrderingThenOrderingOrdering(testNum = "3", orderNums, orderNums2, orderNums3, listSortDirection, listSortDirection2, index, orderNum, orderNum2, orderNum3, indexOld, indexNew))
{
continue;
}
items = getObservableCollection(orderNums, orderNums2, orderNums3);
ThenOrdering <Item, int?> ordering2 = items.Ordering(i => i.OrderNum, listSortDirection).ThenOrdering(i => i.OrderNum2, listSortDirection).ThenOrdering(i => i.OrderNum3, listSortDirection2).For(consumer);
items[index] = new Item(orderNum == -1 ? (int?)null : orderNum, orderNum2 == -1 ? (int?)null : orderNum2, orderNum3 == -1 ? (int?)null : orderNum3);
ordering2.ValidateInternalConsistency();
consumer.Dispose();
}
}
}
}
for (index = 0; index < orderNums.Length; index++)
{
traceThenOrderingThenOrderingOrdering(testNum = "4", orderNums, orderNums2, orderNums3, listSortDirection, listSortDirection2, index, orderNum, orderNum2, orderNum3, indexOld, indexNew);
items = getObservableCollection(orderNums, orderNums2, orderNums3);
ThenOrdering <Item, int?> ordering1 = items.Ordering(i => i.OrderNum, listSortDirection).ThenOrdering(i => i.OrderNum2, listSortDirection).ThenOrdering(i => i.OrderNum3, listSortDirection2).For(consumer);
items[index].OrderNum = null;
ordering1.ValidateInternalConsistency();
consumer.Dispose();
for (orderNum = -1; orderNum <= orderNums.Length; orderNum++)
{
for (orderNum2 = -1; orderNum2 <= orderNums.Length; orderNum2++)
{
for (orderNum3 = -1; orderNum3 <= orderNums.Length; orderNum3++)
{
if (!traceThenOrderingThenOrderingOrdering(testNum = "7", orderNums, orderNums2, orderNums3, listSortDirection, listSortDirection2, index, orderNum, orderNum2, orderNum3, indexOld, indexNew))
{
continue;
}
items = getObservableCollection(orderNums, orderNums2, orderNums3);
ThenOrdering <Item, int?> ordering3 = items.Ordering(i => i.OrderNum, listSortDirection).ThenOrdering(i => i.OrderNum2, listSortDirection).ThenOrdering(i => i.OrderNum3, listSortDirection2).For(consumer);
items[index].OrderNum = orderNum == -1 ? (int?)null : orderNum;
items[index].OrderNum2 = orderNum2 == -1 ? (int?)null : orderNum2;
items[index].OrderNum3 = orderNum2 == -1 ? (int?)null : orderNum3;
ordering3.ValidateInternalConsistency();
consumer.Dispose();
}
}
traceThenOrderingThenOrderingOrdering(testNum = "5", orderNums, orderNums2, orderNums3, listSortDirection, listSortDirection2, index, orderNum, orderNum2, orderNum3, indexOld, indexNew);
items = getObservableCollection(orderNums, orderNums2, orderNums3);
ThenOrdering <Item, int?> ordering2 = items.Ordering(i => i.OrderNum, listSortDirection).ThenOrdering(i => i.OrderNum2, listSortDirection).ThenOrdering(i => i.OrderNum3, listSortDirection2).For(consumer);
items[index].OrderNum = orderNum == -1 ? (int?)null : orderNum;
ordering2.ValidateInternalConsistency();
consumer.Dispose();
if (!traceThenOrderingThenOrderingOrdering(testNum = "9", orderNums, orderNums2, orderNums3, listSortDirection, listSortDirection2, index, orderNum, orderNum2, orderNum3, indexOld, indexNew))
{
continue;
}
items = getObservableCollection(orderNums, orderNums2, orderNums3);
ThenOrdering <Item, int?> ordering4 = items.Ordering(i => i.OrderNum, listSortDirection).ThenOrdering(i => i.OrderNum2, listSortDirection).ThenOrdering(i => i.OrderNum3, listSortDirection2).For(consumer);
items[index].OrderNum2 = orderNum == -1 ? (int?)null : orderNum;
ordering4.ValidateInternalConsistency();
consumer.Dispose();
}
}
for (indexOld = 0; indexOld < orderNums.Length; indexOld++)
{
for (indexNew = 0; indexNew < orderNums.Length; indexNew++)
{
if (!traceThenOrderingThenOrderingOrdering(testNum = "6", orderNums, orderNums2, orderNums3, listSortDirection, listSortDirection2, index, orderNum, orderNum2, orderNum3, indexOld, indexNew))
{
continue;
}
items = getObservableCollection(orderNums, orderNums2, orderNums3);
ThenOrdering <Item, int?> ordering2 = items.Ordering(i => i.OrderNum, listSortDirection).ThenOrdering(i => i.OrderNum2, listSortDirection).ThenOrdering(i => i.OrderNum3, listSortDirection2).For(consumer);
items.Move(indexOld, indexNew);
ordering2.ValidateInternalConsistency();
consumer.Dispose();
}
}
}
catch (Exception e)
{
string traceString = getTraceString(testNum, orderNums, orderNums2, orderNums3, listSortDirection, listSortDirection2, index, orderNum, orderNum2, orderNum3, indexOld, indexNew);
_textFileOutputLog.AppentLine(traceString);
_textFileOutputLog.AppentLine(e.Message);
_textFileOutputLog.AppentLine(e.StackTrace);
throw new Exception(traceString, e);
}
writeUsefulTest(getTestString(orderNums, orderNums2, orderNums3, listSortDirection, listSortDirection2));
}
