public static void UniqueInListWithPoints()
{
var pt1 = new Point();
var pt2 = new Point(1, 0);
var pt3 = new Point(1, 0);
Assert.AreEqual(
new ArrayList {
pt1, pt2
},
List.UniqueItems(new ArrayList {
pt1, pt2, pt1, pt3
}));
}
public static void JoinLists()
{
Assert.AreEqual(
new ArrayList {
0, 1, 2, 3, 4
},
List.Join(new ArrayList {
0, 1
}, new ArrayList {
2
}, new ArrayList(), new ArrayList {
3, 4
}));
}
public static void TakeListSlice()
{
var list = new ArrayList(Enumerable.Range(0, 10).ToList());
Assert.AreEqual(list, List.Slice(list));
Assert.AreEqual(new ArrayList {
0, 1, 2, 3, 4
}, List.Slice(list, count: 5));
Assert.AreEqual(new ArrayList {
1, 2, 3, 4, 5
}, List.Slice(list, 1, 5));
Assert.AreEqual(new ArrayList {
0, 2, 4, 6, 8
}, List.Slice(list, step: 2));
}
public static void ListPermutations()
{
var check = List.Permutations(new ArrayList {
"A", "B", "C", "D"
}, 2);
Assert.AreEqual(
new ArrayList
{
new ArrayList {
"A", "B"
},
new ArrayList {
"A", "C"
},
new ArrayList {
"A", "D"
},
new ArrayList {
"B", "A"
},
new ArrayList {
"B", "C"
},
new ArrayList {
"B", "D"
},
new ArrayList {
"C", "A"
},
new ArrayList {
"C", "B"
},
new ArrayList {
"C", "D"
},
new ArrayList {
"D", "A"
},
new ArrayList {
"D", "B"
},
new ArrayList {
"D", "C"
}
},
check);
}
public static void PartitionList()
{
Assert.AreEqual(
new ArrayList {
new ArrayList {
0, 1
}, new ArrayList {
2, 3
}
},
List.Chop(new ArrayList {
0, 1, 2, 3
}, new ArrayList {
2
}));
}
public static void RemoveMultipleValuesFromNestedList()
{
var strings = new List <string> {
"one", "two"
};
Assert.AreEqual(
new List <object> {
0, 4
},
List.RemoveItemAtIndex(new List <object> {
0, 1, strings, new List <object> {
1, strings
}, 4
}, new[] { 1, 2, 3 }));
}
public static void DropEveryNthValueFromList()
{
var list = Enumerable.Range(1, 12).ToList();
const int n = 3;
Assert.AreEqual(new List <int> {
1, 2, 4, 5, 7, 8, 10, 11
}, List.DropEveryNthItem(list, n));
Assert.AreEqual(new List <int> {
2, 3, 5, 6, 8, 9, 11, 12
}, List.DropEveryNthItem(list, n, 1));
Assert.AreEqual(new List <int> {
1, 3, 4, 6, 7, 9, 10, 12
}, List.DropEveryNthItem(list, n, 2));
Assert.AreEqual(List.DropEveryNthItem(list, n), List.DropEveryNthItem(list, n, 3));
}
public static void TakeEveryNthValueFromList()
{
var list = Enumerable.Range(1, 12).ToList();
const int n = 3;
Assert.AreEqual(new List <int> {
3, 6, 9, 12
}, List.TakeEveryNthItem(list, n));
Assert.AreEqual(new List <int> {
1, 4, 7, 10
}, List.TakeEveryNthItem(list, n, 1));
Assert.AreEqual(new List <int> {
2, 5, 8, 11
}, List.TakeEveryNthItem(list, n, 2));
Assert.AreEqual(List.TakeEveryNthItem(list, n), List.TakeEveryNthItem(list, n, 3));
}
public static void Chop3()
{
var list = new ArrayList {
1, 2, 3, 4, 5
};
var lengths = new ArrayList {
-1, -1
};
var output = List.Chop(list, lengths);
var expected = new ArrayList {
1, 2, 3, 4, 5
};
Assert.AreEqual(expected, output);
}
public static void ReplaceItemAtIndex()
{
Assert.AreEqual(List.ReplaceItemAtIndex(new ArrayList {
5, 4, 3, 2, 1
}, 0, 20), new ArrayList {
20, 4, 3, 2, 1
});
Assert.AreEqual(List.ReplaceItemAtIndex(new ArrayList {
5, 4, 3, 2, 1
}, -1, 20), new ArrayList {
5, 4, 3, 2, 20
});
Assert.Throws <IndexOutOfRangeException>(() => List.ReplaceItemAtIndex(new ArrayList {
5, 4, 3, 2, 1
}, 12, 20));
}
public static void SortByKey6()
{
var list = new ArrayList {
1, 2, 3
};
var keys = new ArrayList {
1.21, 1.20, 1.2001
};
var result = List.SortByKey(list, keys);
var expected = new Dictionary <string, object>
{
{ "sorted list", new object[] { 2, 3, 1 } },
{ "sorted keys", new object[] { 1.20, 1.2001, 1.21 } }
};
Assert.AreEqual(expected, result);
}
public static void GroupByKey1()
{
var list = new ArrayList {
"a", "b", "c"
};
var keys = new ArrayList {
"key1", "key2", "key1"
};
var result = List.GroupByKey(list, keys);
var expected = new Dictionary <string, object>
{
{ "groups", new object[] { new object[] { "a", "c" }, new object[] { "b" } } },
{ "unique keys", new object[] { "key1", "key2" } }
};
Assert.AreEqual(expected, result);
}
public static void SortByKey1()
{
var list = new ArrayList {
"item1", "item2"
};
var keys = new ArrayList {
"key2", "key1"
};
var result = List.SortByKey(list, keys);
var expected = new Dictionary <string, object>
{
{ "sorted list", new object[] { "item2", "item1" } },
{ "sorted keys", new object[] { "key1", "key2" } }
};
Assert.AreEqual(expected, result);
}
public static void CleanNullsPreserveIndicesEdgeCases()
{
// 1D array of nulls
var input = new ArrayList {
null
};
var output = List.Clean(input);
Assert.AreEqual(null, output);
// list is null itself
input = null;
output = List.Clean(input);
Assert.AreEqual(null, output);
// nested array of nulls
input = new ArrayList {
new ArrayList {
null
}
};
output = List.Clean(input);
var expected = new ArrayList {
null
};
Assert.AreEqual(expected, output);
// empty list
input = new ArrayList();
output = List.Clean(input);
expected = new ArrayList();
Assert.AreEqual(expected, output);
// nested empty list
input = new ArrayList {
new ArrayList()
};
output = List.Clean(input);
expected = new ArrayList {
new ArrayList()
};
Assert.AreEqual(expected, output);
}
public static void SplitList()
{
var results = List.Deconstruct(new List <int> {
0, 1, 2, 3, 4, 5
});
// Explicitly test each aspect of the returned value.
Assert.IsNotNull(results);
Assert.AreEqual(2, results.Count);
Assert.AreEqual("first", results.Keys.Cast <string>().First());
Assert.AreEqual("rest", results.Keys.Cast <string>().ElementAt(1));
Assert.AreEqual(0, results["first"]);
var rest = results["rest"] as List <object>;
Assert.IsNotNull(rest);
Assert.AreEqual(new List <object> {
1, 2, 3, 4, 5
}, rest);
}
public static void Chop4()
{
var list = new ArrayList {
1, 2, 3
};
var lengths = new List <int> {
2, 5
};
var output = List.Chop(list, lengths);
var expected = new ArrayList {
new ArrayList {
1, 2
}, new ArrayList {
3
}
};
Assert.AreEqual(expected, output);
}
public static void Chop5()
{
var list = new ArrayList {
1, "a", 3
};
var lengths = new ArrayList {
2, 1
};
var output = List.Chop(list, lengths);
var expected = new ArrayList {
new ArrayList {
1, "a"
}, new ArrayList {
3
}
};
Assert.AreEqual(expected, output);
}
public static void ListDiagonalLeft()
{
Assert.AreEqual(
new List <List <int> >()
{
new List <int>()
{
0
},
new List <int>()
{
1, 5
},
new List <int>()
{
2, 6, 10,
},
new List <int>()
{
3, 7, 11, 15
},
new List <int>()
{
4, 8, 12, 16
},
new List <int>()
{
9, 13, 17
},
new List <int>()
{
14, 18
},
new List <int>()
{
19
}
},
List.DiagonalLeft(Enumerable.Range(0, 20).ToList(), 5));
}
public static void ListDiagonalRight()
{
Assert.AreEqual(
new List <List <int> >()
{
new List <int>()
{
15
},
new List <int>()
{
10, 16
},
new List <int>()
{
5, 11, 17,
},
new List <int>()
{
0, 6, 12, 18
},
new List <int>()
{
1, 7, 13, 19
},
new List <int>()
{
2, 8, 14
},
new List <int>()
{
3, 9
},
new List <int>()
{
4
}
},
List.DiagonalRight(Enumerable.Range(0, 20).ToList(), 5));
}
public static void TakeListSlice()
{
var list = new ArrayList(Enumerable.Range(0, 10).ToList());
var reversed = list.Cast <object>().Reverse().ToList();
Assert.AreEqual(list, List.Slice(list));
Assert.AreEqual(new ArrayList {
0, 1, 2, 3, 4
}, List.Slice(list, end: 5));
Assert.AreEqual(new ArrayList {
1, 2, 3, 4
}, List.Slice(list, 1, 5));
Assert.AreEqual(new ArrayList {
0, 2, 4, 6, 8
}, List.Slice(list, step: 2));
Assert.AreEqual(reversed, List.Slice(list, step: -1));
Assert.AreEqual(new ArrayList {
0, 1, 2, 3, 4
}, List.Slice(list, -11, -5));
Assert.AreEqual(reversed, List.Slice(list, -1, -11, -1));
}
public static void Chop2()
{
var list = new ArrayList {
1, 2, 3, 4, 5
};
var lengths = new ArrayList {
0, 2
};
var output = List.Chop(list, lengths);
var expected = new ArrayList {
new ArrayList {
}, new ArrayList {
1, 2
}, new ArrayList {
3, 4
}, new ArrayList {
5
}
};
Assert.AreEqual(expected, output);
}
public static void ShiftListIndices()
{
Assert.AreEqual(new List <int> {
2, 0, 1
}, List.ShiftIndices(new List <int> {
0, 1, 2
}, 1));
Assert.AreEqual(new List <int> {
1, 2, 0
}, List.ShiftIndices(new List <int> {
0, 1, 2
}, -1));
Assert.AreEqual(new List <int> {
2, 0, 1
}, List.ShiftIndices(new List <int> {
0, 1, 2
}, 4));
Assert.AreEqual(new List <int> {
1, 2, 0
}, List.ShiftIndices(new List <int> {
0, 1, 2
}, -4));
}
public static void SortByKey5()
{
var list = new ArrayList {
"Zack",
"Ian",
"Neal",
"Anna"
};
var keys = new ArrayList {
-3,
1.6,
"abc",
5
};
var result = List.SortByKey(list, keys);
var expected = new Dictionary <string, object>
{
{ "sorted list", new object[] { "Zack", "Ian", "Anna", "Neal" } },
{ "sorted keys", new object[] { -3, 1.6, 5, "abc" } }
};
Assert.AreEqual(expected, result);
}
public static void CleanNullsPreserveIndices()
{
var input = new ArrayList
{
new ArrayList {
1, null, 2, null, null
},
new ArrayList {
null, null, 3, 4, null
},
new ArrayList {
null, null
},
new ArrayList {
1, 2
}
};
var output = List.Clean(input);
var expected = new ArrayList
{
new ArrayList {
1, null, 2
},
new ArrayList {
null, null, 3, 4
},
null,
new ArrayList {
1, 2
}
};
Assert.AreEqual(expected, output);
}
public static void ListCombinations()
{
var input = new ArrayList {
"A", "B", "C", "D"
};
var check = List.Combinations(input, 2);
Assert.AreEqual(
new ArrayList
{
new ArrayList {
"A", "B"
},
new ArrayList {
"A", "C"
},
new ArrayList {
"A", "D"
},
new ArrayList {
"B", "C"
},
new ArrayList {
"B", "D"
},
new ArrayList {
"C", "D"
}
},
check);
check = List.Combinations(input, 2, true);
Assert.AreEqual(
new ArrayList
{
new ArrayList {
"A", "A"
},
new ArrayList {
"A", "B"
},
new ArrayList {
"A", "C"
},
new ArrayList {
"A", "D"
},
new ArrayList {
"B", "B"
},
new ArrayList {
"B", "C"
},
new ArrayList {
"B", "D"
},
new ArrayList {
"C", "C"
},
new ArrayList {
"C", "D"
},
new ArrayList {
"D", "D"
}
},
check);
}
public static void LastInList()
{
Assert.AreEqual(4, List.LastItem(Enumerable.Range(0, 5).ToList()));
}
public static void SortList()
{
var sorted = Enumerable.Range(1, 5).ToList();
Assert.AreEqual(sorted, List.Sort(List.Shuffle(sorted)));
}
public static void RepeatObject()
{
Assert.AreEqual(new List <object> {
1, 1, 1, 1
}, List.OfRepeatedItem(1, 4));
}
public static void FirstInList()
{
Assert.AreEqual(0, List.FirstItem(new ArrayList {
0, 1, 2, 3
}));
}
public static void GetFromList()
{
Assert.AreEqual(2, List.GetItemAtIndex(new List <int> {
0, 1, 2, 3
}, 2));
}
