static void Main(string[] args)
{
var treelist = new TreeList();
treelist.Add(new Tree("Luc", "Zöld", 13, "Fiú"));
treelist.Add(new Tree("Cseresznye", "Piros", 28, "Lány"));
treelist.Add(new Tree("Ezüst", "Füstös", 56, "Lány"));
treelist.Add(new Tree("Nyár", "Sárga", 12, "Fiú"));
treelist.Add(new Tree("Orchidea", "Rózsaszín", 38, "Fiú"));
TreePrint(treelist.List());
Console.Read();
}
public void TestAddChildren()
{
// ARRANGE
var treeList = new TreeList <string, Person>(_grandpa);
// ACTION
treeList.Add(_dad);
treeList.Add(_uncle);
// ASSERT
Assert.True(treeList.Count == 2);
Assert.True(treeList[0].Id == "Dad");
Assert.True(treeList[1].Id == "UncleJohn");
}
public void PosTest4()
{
TreeList <string?> listObject = new TreeList <string?>();
listObject.Add(null);
Assert.Null(listObject[0]);
}
public void TestEnumerator()
{
var list = new TreeList <int>();
var enumerator = list.GetEnumerator();
Assert.Equal(0, enumerator.Current);
Assert.False(enumerator.MoveNext());
Assert.Equal(0, enumerator.Current);
Assert.False(enumerator.MoveNext());
Assert.Equal(0, enumerator.Current);
// Adding an item to the list invalidates it, but Current is still unchecked
list.Add(1);
Assert.Throws <InvalidOperationException>(() => enumerator.MoveNext());
Assert.Equal(0, enumerator.Current);
enumerator = list.GetEnumerator();
Assert.Equal(0, enumerator.Current);
Assert.True(enumerator.MoveNext());
Assert.Equal(1, enumerator.Current);
// Reset has no effect due to boxing the value type
((IEnumerator <int>)enumerator).Reset();
Assert.Equal(1, enumerator.Current);
Assert.False(enumerator.MoveNext());
Assert.Equal(1, enumerator.Current);
}
public void TestIEnumeratorT()
{
var list = new TreeList <int>();
IEnumerator <int> enumerator = list.GetEnumerator();
Assert.Equal(0, enumerator.Current);
Assert.False(enumerator.MoveNext());
Assert.Equal(0, enumerator.Current);
// Adding an item to the list invalidates it, but Current is still unchecked
list.Add(1);
Assert.Throws <InvalidOperationException>(() => enumerator.MoveNext());
Assert.Throws <InvalidOperationException>(() => enumerator.Reset());
Assert.Equal(0, enumerator.Current);
enumerator = list.GetEnumerator();
Assert.Equal(0, enumerator.Current);
Assert.True(enumerator.MoveNext());
Assert.Equal(1, enumerator.Current);
Assert.False(enumerator.MoveNext());
Assert.Equal(1, enumerator.Current);
enumerator.Reset();
Assert.Equal(0, enumerator.Current);
Assert.True(enumerator.MoveNext());
Assert.Equal(1, enumerator.Current);
enumerator.Reset();
Assert.Equal(0, enumerator.Current);
Assert.True(enumerator.MoveNext());
Assert.Equal(1, enumerator.Current);
Assert.False(enumerator.MoveNext());
Assert.Equal(1, enumerator.Current);
}
public void PosTest2()
{
TreeList <string> myList = new TreeList <string>();
int count = 10;
string[] expectValue = new string[10];
string element = string.Empty;
for (int i = 1; i <= count; i++)
{
element = i.ToString();
myList.Add(element);
expectValue[i - 1] = element;
}
IEnumerator <string> returnValue = ((IEnumerable <string>)myList).GetEnumerator();
int j = 0;
for (IEnumerator <string> itr = returnValue; itr.MoveNext();)
{
string current = itr.Current;
Assert.Equal(expectValue[j], current);
j++;
}
}
public void PosTest3()
{
MyClass myclass1 = new MyClass();
MyClass myclass2 = new MyClass();
MyClass myclass3 = new MyClass();
TreeList <MyClass> listObject = new TreeList <MyClass>();
listObject.Add(myclass1);
listObject.Add(myclass2);
listObject.Add(myclass3);
MyClass[] mc = new MyClass[3];
((ICollection)listObject).CopyTo(mc, 0);
Assert.Equal(myclass1, mc[0]);
Assert.Equal(myclass2, mc[1]);
Assert.Equal(myclass3, mc[2]);
}
public void AddOneElement()
{
TreeList <int> list = new TreeList <int>();
list.Add(1);
Assert.AreEqual(1, list.Count);
}
public void TestBinarySearchFullList()
{
TreeList <int> list = new TreeList <int>(branchingFactor: 4);
List <int> reference = new List <int>();
for (int i = 0; i < 2 * 4 * 4; i++)
{
list.Add(i * 2);
reference.Add(i * 2);
}
// Test below start value
Assert.Equal(reference.BinarySearch(reference[0] - 1), list.BinarySearch(reference[0] - 1));
for (int i = 0; i < reference.Count; i++)
{
// Test current value
Assert.Equal(reference.BinarySearch(reference[i]), list.BinarySearch(reference[i]));
// Test above current value
Assert.Equal(reference.BinarySearch(reference[i] + 1), list.BinarySearch(reference[i] + 1));
}
// Test case where an exception is thrown by the comparer
var expected = new NotSupportedException();
var exception = Assert.Throws <InvalidOperationException>(() => list.BinarySearch(0, new ComparisonComparer <int>((x, y) => throw expected)));
Assert.Same(expected, exception.InnerException);
exception = Assert.Throws <InvalidOperationException>(() => reference.BinarySearch(0, new ComparisonComparer <int>((x, y) => throw expected)));
Assert.Same(expected, exception.InnerException);
TreeList <int> empty = new TreeList <int>();
Assert.Equal(~0, empty.BinarySearch(0));
}
public void TestStackLikeBehavior()
{
Random random = new Random();
TreeList <int> list = new TreeList <int>(branchingFactor: 4);
List <int> reference = new List <int>();
for (int i = 0; i < 2 * 4 * 4; i++)
{
int item = random.Next();
list.Add(item);
reference.Add(item);
}
while (list.Count > 0)
{
Assert.Equal(reference[reference.Count - 1], list[list.Count - 1]);
reference.RemoveAt(reference.Count - 1);
list.RemoveAt(list.Count - 1);
list.Validate(ValidationRules.None);
Assert.Equal(reference, list);
}
Assert.Empty(list);
Assert.Empty(reference);
}
public void PosTest3()
{
MyClass myClass = new MyClass();
TreeList <MyClass> listObject = new TreeList <MyClass>();
listObject.Add(myClass);
Assert.Equal(myClass, listObject[0]);
}
void AddFiles(TreeList<TestFile> tree, Folder testFolder, Folder resultFolder)
{
foreach (var name in suite.TestNames(testFolder)) {
var testFile = new TestFile {
FileName = Path.GetFileNameWithoutExtension(name), Path = tree.Value.FullName
};
var result = new TestResult(resultFolder, testFile);
testFile.TestStatus = result.Status;
tree.Add(testFile);
}
foreach (var subfolder in suite.SubFolders(testFolder)) {
var branch = new TreeList<TestFile>(new TestFile {FileName = subfolder.Name(), Path = tree.Value.FullName, IsFolder = true});
tree.Add(branch);
AddFiles(branch, subfolder, resultFolder.SubFolder(subfolder.Name()));
}
}
public void PosTest2()
{
string[] strArray = { "Hello" };
TreeList <string> listObject = new TreeList <string>(strArray);
string str1 = "World";
listObject.Add(str1);
Assert.Equal(2, listObject.Count);
Assert.Equal("World", listObject[1]);
}
public void GenerateTreeListOfTreeModel()
{
//for devexpress tree
this.TreeList = new List <TreeListModelView>();
TreeListModelView treelistNode = new TreeListModelView();
int IdSequence = 1;
int ParentId = 0;
TreeList.Add(treelistNode);
TreeTraversal(this.Tree, ParentId, IdSequence);
}
public void TestAddStaysPacked()
{
TreeList <int> list = new TreeList <int>(branchingFactor: 4);
for (int i = 0; i < 2 * 4 * 4; i++)
{
list.Add(i);
}
list.Validate(ValidationRules.RequirePacked);
}
public void TestTrueForAll()
{
var list = new TreeList <int>();
Assert.True(list.TrueForAll(i => false));
Assert.Throws <ArgumentNullException>(() => list.TrueForAll(null));
list.Add(1);
Assert.True(list.TrueForAll(i => i > 0));
Assert.False(list.TrueForAll(i => i <= 0));
}
void AddFiles(TreeList <TestFile> tree, Folder testFolder, Folder resultFolder)
{
foreach (var name in suite.TestNames(testFolder))
{
var testFile = new TestFile {
FileName = Path.GetFileNameWithoutExtension(name), Path = tree.Value.FullName
};
var result = new TestResult(resultFolder, testFile);
testFile.TestStatus = result.Status;
tree.Add(testFile);
}
foreach (var subfolder in suite.SubFolders(testFolder))
{
var branch = new TreeList <TestFile>(new TestFile {
FileName = subfolder.Name(), Path = tree.Value.FullName, IsFolder = true
});
tree.Add(branch);
AddFiles(branch, subfolder, resultFolder.SubFolder(subfolder.Name()));
}
}
public void PosTest2()
{
TreeList <string> myList = new TreeList <string>();
int count = 10;
string element = string.Empty;
for (int i = 1; i <= count; i++)
{
element = i.ToString();
myList.Add(element);
}
Assert.Equal(count, myList.Count);
}
public void TestAdd()
{
const int Value = 600;
TreeList <int> list = new TreeList <int>();
Assert.Empty(list);
list.Add(Value);
Assert.Single(list);
Assert.Equal(Value, list[0]);
int[] expected = { Value };
int[] actual = list.ToArray();
Assert.Equal(expected, actual);
}
public void PosTest1()
{
TreeList <int> myList = new TreeList <int>();
int count = 10;
int element = 0;
for (int i = 1; i <= count; i++)
{
element = i * count;
myList.Add(element);
}
Assert.Equal(count, myList.Count);
}
public void AddAndEnumerateOneThousandElementsWithNodeSizeTen()
{
TreeList<int> list = new TreeList<int>(10);
for (int k = 1; k <= 1000; k++)
list.Add(k);
Assert.AreEqual(1000, list.Count);
int j = 0;
foreach (var n in list)
Assert.AreEqual(++j, n);
Assert.AreEqual(1000, j);
}
public void AddAndEnumerateOneHundredElements()
{
TreeList<int> list = new TreeList<int>();
for (int k = 1; k <= 100; k++)
list.Add(k);
Assert.AreEqual(100, list.Count);
int j = 0;
foreach (var n in list)
Assert.AreEqual(++j, n);
Assert.AreEqual(100, j);
}
public void PosTest1()
{
byte[] byteObject = new byte[1000];
Generator.GetBytes(-55, byteObject);
TreeList <byte> listObject = new TreeList <byte>();
for (int i = 0; i < 1000; i++)
{
listObject.Add(byteObject[i]);
}
for (int i = 0; i < 1000; i++)
{
Assert.Equal(byteObject[i], listObject[i]);
}
}
/// <summary>
/// 给Treeview赋值
/// </summary>
/// <param name="listOrg">原始列表</param>
/// <param name="listNew">Own列表</param>
private void SetTree(List <PropertyNodeItem> listOrg, List <string> listNew)
{
TreeList.Clear();
for (int i = 0; i < listNew.Count; i++)
{
PropertyNodeItem node = new PropertyNodeItem()
{
ParentName = listNew[i].ToString(),
ChildrenName = listNew[i].ToString(),
Icon = @"../Icon/father.ico",
IsExpanded = false
};
ForeachPropertyNode(node, listOrg, listNew[i].ToString());
TreeList.Add(node);
}
}
public void TestAddMany()
{
int[] expected = { 600, 601, 602, 603, 700, 701, 702, 703, 800, 801, 802, 803 };
TreeList <int> list = new TreeList <int>(branchingFactor: 3);
foreach (var item in expected)
{
list.Add(item);
Assert.Equal(item, list[list.Count - 1]);
}
Assert.Equal(expected.Length, list.Count);
int[] actual = list.ToArray();
Assert.Equal(expected, actual);
}
private void TreeTraversal(TreeModel tree, int?ParentId, int Id)
{
if (tree.children != null)
{
int parentId = Id;
foreach (TreeModel child in tree.children)
{
if (child != null)
{
AttributeNodeData nodeAttribute = (AttributeNodeData)child.data;
Id++;
TreeListModelView treelistNode = new TreeListModelView(child.label, Id, parentId, nodeAttribute.TableName, nodeAttribute.ColumnName, nodeAttribute.ColumnType);
TreeList.Add(treelistNode);
TreeTraversal(child, parentId, Id);
}
}
}
}
public void PosTest2()
{
TreeList <string> myList = new TreeList <string>();
int count = 10;
string element = string.Empty;
for (int i = 1; i <= count; i++)
{
element = i.ToString();
myList.Add(element);
}
string[] actualArray = myList.ToArray();
for (int j = 0; j < myList.Count; j++)
{
string current = myList[j];
Assert.Equal(actualArray[j], current);
}
}
public void AddAndEnumerateOneHundredElements()
{
TreeList <int> list = new TreeList <int>();
for (int k = 1; k <= 100; k++)
{
list.Add(k);
}
Assert.AreEqual(100, list.Count);
int j = 0;
foreach (var n in list)
{
Assert.AreEqual(++j, n);
}
Assert.AreEqual(100, j);
}
public void AddAndEnumerateOneThousandElementsWithNodeSizeTen()
{
TreeList <int> list = new TreeList <int>(10);
for (int k = 1; k <= 1000; k++)
{
list.Add(k);
}
Assert.AreEqual(1000, list.Count);
int j = 0;
foreach (var n in list)
{
Assert.AreEqual(++j, n);
}
Assert.AreEqual(1000, j);
}
public void PosTest1()
{
TreeList <int> myList = new TreeList <int>();
int count = 10;
int element = 0;
for (int i = 1; i <= count; i++)
{
element = i * count;
myList.Add(element);
}
int[] actualArray = myList.ToArray();
for (int j = 0; j < myList.Count; j++)
{
int current = myList[j];
Assert.Equal(actualArray[j], current);
}
}
public void PosTest1()
{
TreeList <int> myList = new TreeList <int>();
int count = 10;
int[] expectValue = new int[10];
for (int i = 1; i <= count; i++)
{
myList.Add(i * count);
expectValue[i - 1] = i * count;
}
IEnumerator <int> returnValue = ((IEnumerable <int>)myList).GetEnumerator();
int j = 0;
for (IEnumerator <int> itr = returnValue; itr.MoveNext();)
{
int current = itr.Current;
Assert.Equal(expectValue[j], current);
j++;
}
}
public override void CreateTallTree()
{
TreeList.Add(new TallTree(Tree.TreeColor.Green, new Vector3(8, 0, 0)));
}
public void AddOneElement()
{
TreeList<int> list = new TreeList<int>();
list.Add(1);
Assert.AreEqual(1, list.Count);
}
public override void CreatePineTree()
{
TreeList.Add(new PineTree(Tree.TreeColor.Blue, new Vector3(0, 0, 4)));
}