public void CreateNewDynamicList_EmptyCollection()
{
var dynamicList = new DynamicList<int>();
var lenght = dynamicList.Count;
Assert.AreEqual(0, lenght, "Collection lenght should be 0!");
}
public void Index_SetValidIndex_ShouldChangeElement()
{
var list = new DynamicList<int>();
list.Add(1);
list[0] = 3;
Assert.AreEqual(3, list[0]);
}
public void Index_GetValidIndex_ShouldReturnProperElement()
{
var list = new DynamicList<int>();
list.Add(1);
var element = list[0];
Assert.AreEqual(1, element);
}
public void TestObject_OnExistingIndex_ShouldReturnCorrectObject()
{
DynamicList<int> arr = new DynamicList<int>();
arr.Add(1);
Assert.AreEqual(1, arr[0],"The index is not correct!");
}
public void TestAddOneElementToList()
{
DynamicList<int> list = new DynamicList<int>();
list.Add(15);
int value = list[0];
Assert.AreEqual(15, value, "The value at index 0 should be equal to the value entered.");
}
public void TestRemoveAtMethod_WithNegativeIndex_ShouldThrow()
{
DynamicList<int> arr = new DynamicList<int>();
arr.Add(1);
arr.RemoveAt(-1);
}
public void TestCount_ValidCountOnNewListCreation_ExpectSuccess()
{
DynamicList<int> list = new DynamicList<int>();
int actual = list.Count;
int expected = 0;
Assert.AreEqual(expected, actual, "List count should be 0.");
}
public void TestAddNodeWithValueOfOneMustCreatCorrectNode()
{
var list = new DynamicList<int>();
list.Add(1);
Assert.AreEqual(1, list[0]);
}
public void TestContains_NExistingElement_ShouldReturnPositive()
{
var list = new DynamicList<int>();
list.Add(5);
var isContains = list.Contains(5);
Assert.IsTrue(isContains);
}
public void TestList_SetIndex_ShouldThrowException()
{
DynamicList<int> list = new DynamicList<int>();
int setterIndexTest = 9;
list[3] = setterIndexTest;
}
public void TestIndexOf_ExistingElement_ShouldReturnProperIndex()
{
var list = new DynamicList<int>();
list.Add(5);
var index = list.IndexOf(5);
Assert.AreEqual(0, index);
}
public void Test_ValueOfTheOneElementAdded()
{
var list = new DynamicList<int>();
list.Add(15);
var value = list[0];
Assert.AreEqual(15, value, "The value at index 0 should be equal to the value entered.");
}
public void TestAddingNewNodeOnTailPositionEmptyList()
{
var list = new DynamicList<int>();
list.Add(1);
Assert.AreEqual(1, list[0]);
}
public void Test_ListCountAfterAddOneElementToList()
{
var list = new DynamicList<int>();
list.Add(1);
var count = list.Count;
Assert.AreEqual(1, count, "List count should be 1 after adding one element.");
}
public void Count_AddToList_ShouldBeProperCount()
{
var list = new DynamicList<int>();
list.Add(1);
var count = list.Count;
Assert.AreEqual(1, count);
}
public void AddTests()
{
var list = new DynamicList<int>();
list.Add(1);
Assert.AreEqual(1, list.Count);
Assert.AreEqual(1, list.ItemAtIndex(0));
}
public void TestRemove_NotExistingElement_ShouldNeutralIndex()
{
var list = new DynamicList<int>();
var index = list.Remove(1);
Assert.AreEqual(-1, index);
}
public void DynamicListTest()
{
var testValue = new DynamicList<string>();
int expected = 0;
Assert.AreEqual(expected, testValue.Count, string.Format("The expected count of {0} did not match the actual value of {1}", expected,testValue.Count));
}
public void Test_IndexGetReturnsThirdElementOneHundread()
{
var dynList = new DynamicList<int>();
dynList.Add(10);
dynList.Add(50);
dynList.Add(100);
Assert.AreEqual(100, dynList[2], "Index do not returns the correct value of an element at specified index.");
}
public void RemovingElementAtIndexShouldReturnElement()
{
var numList = new DynamicList<int>();
numList.Add(7);
int number = numList.RemoveAt(0);
Assert.AreEqual(7, number, "The elements is found and it's equal to what is expected.");
}
public void FoundingElementInListShouldReturnIndexOfElement()
{
var numList = new DynamicList<int>();
numList.Add(13);
numList.Add(-6);
int index = numList.IndexOf(-6);
Assert.AreEqual(1, index, "Invalid index.");
}
public void TestCountAfterAddTwoElementsToList()
{
DynamicList<int> list = new DynamicList<int>();
list.Add(1);
list.Add(2);
int count = list.Count;
Assert.AreEqual(2, count, "List count should be 2 after adding two elements.");
}
public void DeleteTests()
{
var list = new DynamicList<int>(new []{1,2,3,4,5,6});
Assert.AreEqual(6, list.Count);
list.Delete(0);
Assert.AreEqual(5, list.Count);
Assert.AreEqual(2, list.ItemAtIndex(0));
}
public void TestList_GetIndex_ShouldThrowException()
{
DynamicList<int> list = new DynamicList<int>();
int getterIndexTest = 9;
list.Add(getterIndexTest);
int value = list[5];
}
public void Add_ToEmptyList_ShouldAddItem()
{
var list = new DynamicList<string>();
list.Add("Pesho");
Assert.AreEqual(1, list.Count, "The count of the list must be increased after adding a new item.");
}
public void TestCountAfterTwoElementsAdded()
{
var list = new DynamicList<int>();
list.Add(1);
list.Add(2);
var count = list.Count;
Assert.AreEqual(2, count, "List count should be 2 after adding two elements.");
}
public void TestRemoveAt_ValidIndex_ShouldReturnProperElement()
{
var list = new DynamicList<int>();
list.Add(5);
list.Add(15);
var element = list.RemoveAt(1);
Assert.AreEqual(15, element);
}
public void RemoveShouldThrowExceptionIfIndexIsNotPresent()
{
DynamicList<int> list = new DynamicList<int>();
list.Add(2);
list.Add(3);
list.Add(4);
list.RemoveAt(4);
}
public void Contains_ToEmptyList_ShouldReturnFalse()
{
var list = new DynamicList<double>();
var doesContain = list.Contains(2.532);
Assert.IsFalse(doesContain, "Must return false when the list is empty.");
}
public void TestRemoveAtForExceptionWhenCountIsZeroOrNegative()
{
var dynamicList = new DynamicList<int>();
var elementForRemove = 1;
// Act
dynamicList.RemoveAt(elementForRemove);
}
public void RemoveAt_WorksCorrectly(int index)
{
var list = new DynamicList <int>();
for (int i = 0; i < 10; i++)
{
list.Add(i);
}
int expectedResult = index;
int actualResult = list.RemoveAt(index);
Assert.That(actualResult, Is.EqualTo(expectedResult), "Incorrect number returned.");
for (int i = 0; i < list.Count; i++)
{
Assert.That(list[i], Is.EqualTo(i + (i >= index ? 1 : 0)), "Other elements of list are incorrect after removing an element.");
}
}
public void DynamicListShouldContainTakeMethod()
{
var list =
new DynamicList(
new List <Address>
{
new Address {
Street = "Street1"
},
new Address {
Street = "Street2"
},
new Address {
Street = "Street3"
}
});
Assert.Equal(2, list.Take(2).Count());
}
public void TestForeachMyClass()
{
DynamicList <MyClass> expected = new DynamicList <MyClass>()
{
new MyClass()
{
variable = 0
}, new MyClass()
{
variable = 1
}
};
int i;
for (i = 0; i < expected.Count; i++)
{
Assert.AreEqual(i, expected[i].variable);
}
}
public void ChekingForContainsNoneExistingElementInNoneEmptyDynamicListOfIntsShouldReturnTrue()
{
var dynamicListOfInts = new DynamicList <int>();
dynamicListOfInts.Add(1);
dynamicListOfInts.Add(2);
dynamicListOfInts.Add(3);
int startingCount = dynamicListOfInts.Count;
bool isContainedCorrectly =
dynamicListOfInts[0] == 1 &&
dynamicListOfInts[1] == 2 &&
dynamicListOfInts[2] == 3 &&
dynamicListOfInts.Count == startingCount &&
dynamicListOfInts.Contains(8);
Assert.AreEqual(false, isContainedCorrectly,
string.Format("The method \"Contains\" does not work correctly!" +
string.Format("\n should return {0} it returns {1}", false, isContainedCorrectly)));
}
public void AddOneElementShouldWorkCorrectly()
{
string[] initialElements = new string[] { "Dahaka" };
Type dynamicListType = typeof(DynamicList <string>);
DynamicList <string> classInstance = (DynamicList <string>)Activator.CreateInstance(dynamicListType);
MethodInfo addMethod = dynamicListType.GetMethod("Add", BindingFlags.Instance | BindingFlags.Public);
FieldInfo head = dynamicListType.GetField("head", BindingFlags.Instance | BindingFlags.NonPublic);
foreach (var element in initialElements)
{
addMethod.Invoke(classInstance, new object[] { element });
}
string expectedElement = initialElements[0];
string actualElement = classInstance[0];
Assert.That(actualElement, Is.EqualTo(expectedElement));
}
public void RemoveAtInvalidIndexShouldThrowException()
{
string[] initialElements = new string[] { "Dahaka", "The two thrones", "Babylon" };
Type dynamicListType = typeof(DynamicList <string>);
DynamicList <string> classInstance = (DynamicList <string>)Activator.CreateInstance(dynamicListType);
MethodInfo removeMethod = dynamicListType.GetMethod("RemoveAt", BindingFlags.Instance | BindingFlags.Public);
MethodInfo addMethod = dynamicListType.GetMethod("Add", BindingFlags.Instance | BindingFlags.Public);
foreach (var element in initialElements)
{
addMethod.Invoke(classInstance, new object[] { element });
}
Assert.Throws <ArgumentOutOfRangeException>(() => classInstance.RemoveAt(LowerRemoveIndex), "Invalid index: " + LowerRemoveIndex);
Assert.Throws <ArgumentOutOfRangeException>(() => classInstance.RemoveAt(HigherRemoveIndex), "Invalid index: " + HigherRemoveIndex);
}
public JArray SearchByApplicationRole([FromBody] SystemRoleSearch data)
{
Dictionary <string, object> commandParams = data.GetParams();
if (data.ApplicationRoleID.HasValue)
{
commandParams.Add("@p_ApplicationRoleID", data.ApplicationRoleID.Value);
}
DynamicList lst = DynamicList.GetData("spCFM_SystemRole_ByApplicationRole", commandParams);
if (lst.Count > 0)
{
return((JArray)lst[0].GetValue("Data"));
}
return(null);
}
public void TestForeach()
{
DynamicList <int> expected = new DynamicList <int>()
{
1, 4, 9, 16
};
DynamicList <int> temp = new DynamicList <int>()
{
1, 2, 3, 4
};
DynamicList <int> actual = new DynamicList <int>()
{
};
foreach (int el in temp)
{
actual.Add(el * el);
}
Assert.IsTrue(expected.Equals(actual));
}
protected override ViewModel EnrichModel(ViewModel sourceModel)
{
DynamicList model = base.EnrichModel(sourceModel) as DynamicList;
if (model == null || model.QueryResults.Any())
{
return(model);
}
//we need to run a query to populate the list
if (model.Id == Request.Params["id"])
{
//we only take the start from the query string if there is also an id parameter matching the model entity id
//this means that we are sure that the paging is coming from the right entity (if there is more than one paged list on the page)
model.Start = GetRequestParameter <int>("start");
}
ContentProvider.PopulateDynamicList(model, WebRequestContext.Localization);
return(model);
}
public void ContainsValidElementShouldReturnTrue()
{
string[] initialElements = new string[] { "Dahaka", "The two thrones", "Babylon" };
Type dynamicListType = typeof(DynamicList <string>);
DynamicList <string> classInstance = (DynamicList <string>)Activator.CreateInstance(dynamicListType);
MethodInfo contains = dynamicListType.GetMethod("Contains", BindingFlags.Instance | BindingFlags.Public);
MethodInfo addMethod = dynamicListType.GetMethod("Add", BindingFlags.Instance | BindingFlags.Public);
foreach (var element in initialElements)
{
addMethod.Invoke(classInstance, new object[] { element });
}
bool nonValidElement = (bool)contains.Invoke(classInstance, new object[] { initialElements[0] });
bool expectedReturn = true;
Assert.That(nonValidElement, Is.EqualTo(expectedReturn));
}
public JArray Search([FromBody] CFMData.ApplicationRoleSearch data)
{
Dictionary <string, object> commandParams = data.GetParams();
if (data.ApplicationRoleID.HasValue)
{
commandParams.Add("@p_ApplicationRoleID", data.ApplicationRoleID.Value);
}
commandParams.Add("@p_Search", data.Name);
commandParams.Add("@p_ShowInactive", data.ShowInactive);
DynamicList lst = DynamicList.GetData("spCFM_ApplicationRole_SelectForGrid", commandParams);
if (lst.Count > 0)
{
return((JArray)lst[0].GetValue("Data"));
}
return(null);
}
public void RemoveSpecificNonExistingElementShouldReturnMinusOne()
{
string[] initialElements = new string[] { "Dahaka", "The two thrones", "Babylon" };
Type dynamicListType = typeof(DynamicList <string>);
DynamicList <string> classInstance = (DynamicList <string>)Activator.CreateInstance(dynamicListType);
MethodInfo removeMethod = dynamicListType.GetMethod("Remove", BindingFlags.Instance | BindingFlags.Public);
MethodInfo addMethod = dynamicListType.GetMethod("Add", BindingFlags.Instance | BindingFlags.Public);
foreach (var element in initialElements)
{
addMethod.Invoke(classInstance, new object[] { element });
}
int nonValidElement = (int)removeMethod.Invoke(classInstance, new object[] { "NonExistingElementHere" });
int expectedReturn = -1;
Assert.That(nonValidElement, Is.EqualTo(expectedReturn));
}
public JArray Search([FromBody] ApplicationRoleSearch data)
{
Dictionary <string, object> commandParams = new Dictionary <string, object>();
commandParams.Add("@p_ApplicationRoleID", data.ApplicationRoleID);
commandParams.Add("@p_SortColumn", data.SortColumn);
commandParams.Add("@p_SortOrder", data.SortOrder);
commandParams.Add("@p_PageSize", data.PageSize);
commandParams.Add("@p_PageStart", data.PageStart);
DynamicList lst = DynamicList.GetData("[dbo].[spCFM_ApplicationRoleDataAccess_SelectForGrid]", commandParams);
if (lst.Count > 0)
{
var data1 = (JArray)lst[0].GetValue("Data");
return(data1);
}
return(null);
}
public void IndexOfValidElementShouldReturnCorrectIndex()
{
string[] initialElements = new string[] { "Dahaka", "The two thrones", "Babylon" };
Type dynamicListType = typeof(DynamicList <string>);
DynamicList <string> classInstance = (DynamicList <string>)Activator.CreateInstance(dynamicListType);
MethodInfo indexOf = dynamicListType.GetMethod("IndexOf", BindingFlags.Instance | BindingFlags.Public);
MethodInfo addMethod = dynamicListType.GetMethod("Add", BindingFlags.Instance | BindingFlags.Public);
foreach (var element in initialElements)
{
addMethod.Invoke(classInstance, new object[] { element });
}
int nonValidElement = (int)indexOf.Invoke(classInstance, new object[] { initialElements[2] });
int expectedReturn = 2;
Assert.That(nonValidElement, Is.EqualTo(expectedReturn));
}
public JArray Get(int homeID, int?budgetID)
{
Dictionary <string, object> commandParams = new Dictionary <string, object>();
commandParams.Add("p_HomeID", homeID);
if (budgetID.HasValue)
{
commandParams.Add("p_BudgetID", budgetID.Value);
}
DynamicList lst = DynamicList.GetData("spCFM_BudgetDetails_Home", commandParams);
if (lst.Count > 0)
{
return((JArray)lst[0].GetValue("Data"));
}
return(null);
}
public void Indexer_IterateTroughElements_Successful()
{
//Arrange
var numberOfElements = 10;
var list = new DynamicList <string>();
var elements = new List <string>();
//Act
for (var i = 0; i < numberOfElements; i++)
{
var currentElement = $"String{i}";
list.Add(currentElement);
elements.Add(currentElement);
}
//Assert
for (var i = 0; i < list.Count; i++)
{
Assert.That(list[i], Is.SameAs(elements[i]));
}
}
public void AddThreeElementsShouldWorkCorrectly()
{
string[] initialElements = new string[] { "Dahaka", "The two thrones", "Babylon" };
Type dynamicListType = typeof(DynamicList <string>);
DynamicList <string> classInstance = (DynamicList <string>)Activator.CreateInstance(dynamicListType);
MethodInfo addMethod = dynamicListType.GetMethod("Add", BindingFlags.Instance | BindingFlags.Public);
foreach (var element in initialElements)
{
addMethod.Invoke(classInstance, new object[] { element });
}
for (int index = 0; index < initialElements.Length; index++)
{
string actualElement = classInstance[index];
string expectedElement = initialElements[index];
Assert.That(actualElement, Is.EqualTo(expectedElement));
}
}
public void OverloadShouldSetIndexedElement()
{
DynamicList <int> list = new DynamicList <int>();
int a = 2;
int b = 3;
int c = 4;
list.Add(a);
list.Add(b);
list.Add(c);
int toSet = 666;
int toSet2 = 99;
list[0] = toSet;
list[2] = toSet2;
Assert.That(list[0], Is.EqualTo(toSet),
"Overload does not properly set");
Assert.That(list[2], Is.EqualTo(toSet2),
"Overload does not properly set");
}
/// <summary>
/// Draw a dynamic list.
/// <param name="rect">The position to draw the variable.</param>
/// <param name="dynamicList">The dynamic list to be drawn.</param>
/// </summary>
static void DrawDynamicList(Rect rect, DynamicList dynamicList)
{
rect.yMin += 3f;
rect.yMax -= 2f;
rect.xMin += 6f;
rect.xMax -= 6f;
DrawName(new Rect(rect.x, rect.y, c_LargeNameWidth, rect.height), dynamicList);
rect.xMin += c_LargeNameWidth + c_Space;
rect.xMax -= c_MinusButtonWidth + c_RightPadding;
EditorGUI.LabelField(rect, "[" + dynamicList.Count.ToString() + "]");
rect.x += rect.width + 2f;
rect.width = c_MinusButtonWidth;
rect.yMin -= 2f;
rect.yMax += 2f;
if (GUI.Button(rect, s_Styles.iconToolbarMinus, s_Styles.invisbleButton))
{
s_VariableToRemove = dynamicList;
}
}
static void Main(string[] args)
{
DynamicList singlyLinkedList = new DynamicList();
singlyLinkedList.AddFront(1);
singlyLinkedList.AddLast(4);
singlyLinkedList.AddAfter(singlyLinkedList[0], 2);
singlyLinkedList.AddBefore(singlyLinkedList[2], 3);
singlyLinkedList.Print();
//Remove first element
//singlyLinkedList.Remove(singlyLinkedList[0]);
//singlyLinkedList.Print();
//Remove second element
//singlyLinkedList.Remove(singlyLinkedList[1]);
//singlyLinkedList.Print();
//Remove third element
//singlyLinkedList.Remove(singlyLinkedList[2]);
//singlyLinkedList.Print();
//Remove fourth element
//singlyLinkedList.Remove(singlyLinkedList[3]);
//singlyLinkedList.Print();
}
public void RemoveElementShouldRemoveTheElement()
{
var list = new DynamicList <int>();
list.Add(2);
list.Add(6);
list.Add(3);
list.Add(8);
list.Add(4);
list.Remove(3);
bool contains = false;
for (int i = 0; i < list.Count; i++)
{
if (list[i] == 3)
{
contains = true;
}
}
Assert.IsFalse(contains, "The element was not removed");
}
public void IndexOf_IndexOFGivenElement_ReturnIndexOfGivenElement()
{
//Arrange
var list = new DynamicList <string>();
var numberOfElements = 10;
var elementAtIndex = 5;
var givenElement = $"String{elementAtIndex}";
var elements = new List <string>();
//Act
for (var i = 0; i < numberOfElements; i++)
{
var currentElement = $"String{i}";
list.Add(currentElement);
elements.Add(currentElement);
}
var result = list.IndexOf(givenElement);
//Arrange
Assert.That(elements[result], Is.EqualTo(givenElement));
Assert.That(result == elementAtIndex);
}
public void Remove_RemoveGivenElement_SuccessfulAndReturnIndexOfRemovedElement()
{
//Arrange
var list = new DynamicList <string>();
var numberOfElements = 10;
var removeGivenElementAtIndex = 5;
var removeGivenElement = $"String{removeGivenElementAtIndex}";
var elements = new List <string>();
//Act
for (var i = 0; i < numberOfElements; i++)
{
var currentElement = $"String{i}";
list.Add(currentElement);
elements.Add(currentElement);
}
var result = list.Remove(removeGivenElement);
//Arrange
Assert.That(elements[result], Is.EqualTo(removeGivenElement));
Assert.That(result == removeGivenElementAtIndex);
}
public JArray SearchAccountStatementSummary([FromBody] AccountStatementSearch data)
{
Dictionary <string, object> commandParams = new Dictionary <string, object>();
if (data.AccountID.HasValue)
{
commandParams.Add("@p_AccountID", data.AccountID.Value);
}
if (data.AdministratorID.HasValue)
{
commandParams.Add("@p_AdministratorID", data.AdministratorID.Value);
}
commandParams.Add("@p_AccountStatementType", data.AccountStatementType);
commandParams.Add("@p_StatementmentPeriodDate", data.StatementPeriodDate);
if (data.StatementPeriodID.HasValue)
{
commandParams.Add("@p_StatementPeriodID", data.StatementPeriodID.Value);
}
if (data.ClientID.HasValue)
{
commandParams.Add("@p_ClientID", data.ClientID.Value);
}
DynamicList lst = DynamicList.GetData("[dbo].[spCCR_AccountStatementSummary_SelectForGrid]", commandParams);
if (lst.Count > 0)
{
return(lst.GetJson());
}
return(null);
}
public static List MakeCentroidNet(this PlainShape self, Allocator allocator, IntGeom intGeom, float maxEdge, float maxArea = 0, float minArea = 0, bool onlyConvex = false)
{
long iEdge = intGeom.Int(maxEdge);
var delaunay = self.Delaunay(iEdge, Allocator.Temp);
float aMaxArea;
if (maxArea > 0)
{
aMaxArea = maxArea;
}
else
{
aMaxArea = 0.4f * maxEdge * maxEdge;
}
delaunay.Tessellate(intGeom, aMaxArea);
var iMinArea = intGeom.SqrInt(minArea);
var shape = delaunay.MakeCentroidNet(Allocator.Temp, iMinArea, onlyConvex);
delaunay.Dispose();
int n = shape.layouts.Length;
var dynamicList = new DynamicList(8 * n, n, allocator);
for (int i = 0; i < n; ++i)
{
var iPath = shape.Get(i);
var path = intGeom.Float(iPath, Allocator.Temp);
var polygon = new Polygon(path, Allocator.Temp);
dynamicList.Add(polygon);
}
shape.Dispose();
return(dynamicList.Convert());
}
public void Add_AddElements_ElementsAreSameNumber()
{
//Arrange
var numberOfGeneratedStrings = 10;
var elements = new List <string>();
for (var i = 0; i < numberOfGeneratedStrings; i++)
{
var currentString = $"Generated String {i}";
elements.Add(currentString);
}
var dynamicList = new DynamicList <string>();
//Act
for (var i = 0; i < elements.Count; i++)
{
dynamicList.Add(elements[i]);
Assert.That(dynamicList[i], Is.SameAs(elements[i]));
}
//Assert
Assert.That(dynamicList.Count, Is.EqualTo(numberOfGeneratedStrings));
}
// Update is called once per frame
public override Status Update()
{
if (other.isNone)
{
return(Status.Error);
}
if (varToAdd.isNone)
{
return(Status.Error);
}
if (other.Value == null)
{
return(Status.Error);
}
DynamicList otherListVar = other.Value.GetComponent <InternalBlackboard>().GetDynamicList(otherListVarName);
if (otherListVar == null)
{
return(Status.Error);
}
otherListVar.Add(varToAdd.genericValue);
return(Status.Success);
}
public void RemoveAtIndex(int index, params int[] numbersToAdd)
{
List <int> expectedList = numbersToAdd.ToList();
expectedList.RemoveAt(index);
DynamicList <int> dl = new DynamicList <int>();
for (int i = 0; i < numbersToAdd.Length; i++)
{
dl.Add(numbersToAdd[i]);
}
dl.RemoveAt(index);
bool IsSame = true;
for (int i = 0; i < expectedList.Count; i++)
{
if (expectedList.Count != dl.Count || expectedList[i] != dl[i])
{
IsSame = false;
break;
}
}
Assert.True(IsSame);
}
public void InitializeList()
{
dl = new DynamicList <int>();
}
public void SetUp()
{
dynamicList = new DynamicList <string>();
dynamicList.Add("Pesho");
dynamicList.Add("Gosho");
}
