Princeec13/mql5
Watch
0
0
Fork
You've already forked mql5
 1
Code Issues Pull requests 1 Projects Releases Packages Wiki Activity Actions
mql5/Scripts/UnitTests/Generic/TestArrayList.mq5

1069 lines
32 KiB
MQL5
RawPermalinkNormal ViewHistory

new files added
2025-08-05 01:57:33 -04:00
//+------------------------------------------------------------------+
//| TestArrayList.mq5 |
//| Copyright 2000-2025, MetaQuotes Ltd. |
//| https://www.mql5.com |
//+------------------------------------------------------------------+
#include <Generic\ArrayList.mqh>
#include <Generic\HashSet.mqh>
//+------------------------------------------------------------------+
//| TestAddRange_AsArrayList. |
//+------------------------------------------------------------------+
bool TestAddRange_AsArrayList(const int count,const int add_length)
{
//--- create source list
CArrayList<int>list_test(count);
for(int i=0; i<count; i++)
list_test.Add(MathRand());
//--- create clone for source list
CArrayList<int>list_clone(GetPointer(list_test));
//--- crete added list
CArrayList<int>list_added(add_length);
for(int i=0; i<add_length; i++)
list_added.Add(MathRand());
//--- add range
list_test.AddRange(GetPointer(list_added));
//--- check first path
for(int i=0; i<count; i++)
{
int value_test;
int value_clone;
list_test.TryGetValue(i,value_test);
list_clone.TryGetValue(i,value_clone);
if(value_test!=value_clone)
return(false);
}
//--- check second path
for(int i=0; i<add_length; i++)
{
int value_test;
int value_added;
list_test.TryGetValue(i+count,value_test);
list_added.TryGetValue(i,value_added);
if(value_test!=value_added)
return(false);
}
//--- successful
return(true);
}
//+------------------------------------------------------------------+
//| TestAddRange_AsArray. |
//+------------------------------------------------------------------+
bool TestAddRange_AsArray(const int count,const int add_length)
{
//--- create source list
CArrayList<int>list_test(count);
for(int i=0; i<count; i++)
list_test.Add(MathRand());
//--- create clone for source list
CArrayList<int>list_clone(GetPointer(list_test));
//--- crete added array
int array_added[];
ArrayResize(array_added,add_length);
for(int i=0; i<add_length; i++)
array_added[i]=MathRand();
//--- add range
list_test.AddRange(array_added);
//--- check first path
for(int i=0; i<count; i++)
{
int value_test;
int value_clone;
list_test.TryGetValue(i,value_test);
list_clone.TryGetValue(i,value_clone);
if(value_test!=value_clone)
return(false);
}
//--- check second path
for(int i=0; i<add_length; i++)
{
int value_test;
list_test.TryGetValue(i+count,value_test);
if(value_test!=array_added[i])
return(false);
}
//--- successful
return(true);
}
//+------------------------------------------------------------------+
//| TestAddRange_AsNULL. |
//+------------------------------------------------------------------+
bool TestAddRange_AsNULL(const int count)
{
//--- create source list
CArrayList<int>list_test(count);
for(int i=0; i<count; i++)
list_test.Add(MathRand());
//--- create clone for source list
CArrayList<int>list_clone(GetPointer(list_test));
//--- crete added collection
ICollection<int>*null=NULL;
//--- add range
list_test.AddRange(null);
//--- check first path
for(int i=0; i<count; i++)
{
int value_test;
int value_clone;
list_test.TryGetValue(i,value_test);
list_clone.TryGetValue(i,value_clone);
if(value_test!=value_clone)
return(false);
}
//--- check count
if(count!=list_test.Count())
return(false);
//--- successful
return(true);
}
//+------------------------------------------------------------------+
//| TestAddRange. |
//+------------------------------------------------------------------+
bool TestAddRange(const string test_name)
{
PrintFormat("%s started",test_name);
//--- test 1
PrintFormat("%s: Test 1: Adds the elements of the first list to the end of the second list.",test_name);
if(!TestAddRange_AsArrayList(10,7))
return(false);
//--- test 2
PrintFormat("%s: Test 2: Adds the elements of the array to the end of the list.",test_name);
if(!TestAddRange_AsArray(10,7))
return(false);
//--- test 3
PrintFormat("%s: Test 3: Adds NULL object as ICollection to the end of the list.",test_name);
if(!TestAddRange_AsNULL(10))
return(false);
//--- successful
PrintFormat("%s passed",test_name);
return(true);
}
//+------------------------------------------------------------------+
//| TestBinarySearch_Validations. |
//+------------------------------------------------------------------+
bool TestBinarySearch_Validations(const int count)
{
//--- create source list
CArrayList<int>list_test(count);
for(int i=0; i<count; i++)
list_test.Add(MathRand());
//--- sort list
list_test.Sort();
//--- copy list to array
int array[];
if(list_test.CopyTo(array)!=count)
return(false);
//--- create random element
int element=MathRand();
//--- find element in array
int index1=ArrayBsearch(array,element);
//--- find element in list
int index2= list_test.BinarySearch(0,count,element,NULL);
if(index1!=index2)
return(false);
if(list_test.BinarySearch(0,count+1,element,NULL)!=-1)
return(false);
if(list_test.BinarySearch(-1,count,element,NULL)!=-1)
return(false);
if(list_test.BinarySearch(0,-1,element,NULL)!=-1)
return(false);
if(list_test.BinarySearch(count+1,count,element,NULL)!=-1)
return(false);
//--- successful
return(true);
}
//+------------------------------------------------------------------+
//| TestBinarySearch_WithoutDuplicates. |
//+------------------------------------------------------------------+
bool TestBinarySearch_WithoutDuplicates(const int count)
{
//--- create set
CHashSet<int>set();
for(int i=0; i<count; i++)
set.Add(MathRand());
//--- create source list
CArrayList<int>list_test(GetPointer(set));
//--- sort list
list_test.Sort();
//--- find all elements
for(int i=0; i<list_test.Count(); i++)
{
int value;
list_test.TryGetValue(i,value);
if(i!=list_test.BinarySearch(value))
return(false);
}
//--- successful
return(true);
}
//+------------------------------------------------------------------+
//| TestBinarySearch_WithDuplicates. |
//+------------------------------------------------------------------+
bool TestBinarySearch_WithDuplicates(const int count)
{
//--- create source list
CArrayList<int>list_test(count);
for(int i=0; i<count; i++)
list_test.Add(MathRand());
//--- add duplicate
int value0;
list_test.TryGetValue(0, value0);
list_test.Add(value0);
//--- sort list
list_test.Sort();
//--- find all elements
for(int i=0; i<list_test.Count(); i++)
{
int value;
list_test.TryGetValue(i,value);
if(list_test.BinarySearch(value)<0)
return(false);
}
//--- successful
return(true);
}
//+------------------------------------------------------------------+
//| TestBinarySearch. |
//+------------------------------------------------------------------+
bool TestBinarySearch(const string test_name)
{
PrintFormat("%s started",test_name);
//--- test 1
PrintFormat("%s: Test 1: Validation of incorrect input parameters for BinarySearch method.",test_name);
if(!TestBinarySearch_Validations(10))
return(false);
//--- test 2
PrintFormat("%s: Test 2: Validation of BinarySearch method on sorted list without duplicate values.",test_name);
if(!TestBinarySearch_WithoutDuplicates(10))
return(false);
//--- test 3
PrintFormat("%s: Test 3: Validation of BinarySearch method on sorted list with duplicate values.",test_name);
if(!TestBinarySearch_WithDuplicates(10))
return(false);
//--- successful
PrintFormat("%s passed",test_name);
return(true);
}
//+------------------------------------------------------------------+
//| TestIndexOf_NonExistingValues. |
//+------------------------------------------------------------------+
bool TestIndexOf_NonExistingValues(const int count)
{
//--- create source list
CArrayList<int>list_test(count);
for(int i=0; i<count; i++)
list_test.Add(MathRand());
//--- create value
int value=-1;
//--- try find index of value
if(list_test.IndexOf(value)>=0)
return(false);
if(list_test.LastIndexOf(value)>=0)
return(false);
//--- successful
return(true);
}
//+------------------------------------------------------------------+
//| TestIndexOf_OrderIsCorrect. |
//+------------------------------------------------------------------+
bool TestIndexOf_OrderIsCorrect(const int count)
{
//--- create source list
CArrayList<int>list_test(count);
for(int i=0; i<count; i++)
list_test.Add(MathRand());
//--- create clone
CArrayList<int>list_clone(GetPointer(list_test));
//--- add duplicates
list_test.AddRange(GetPointer(list_test));
list_test.AddRange(GetPointer(list_test));
list_test.AddRange(GetPointer(list_test));
//--- find values
for(int i=0; i<count; i++)
{
for(int j=0; j<4; j++)
{
int index=(j *count)+i;
int value;
list_clone.TryGetValue(i,value);
if(index!=list_test.IndexOf(value,(count*j)))
return(false);
if(index!=list_test.IndexOf(value,(count*j),count))
return(false);
}
}
//--- successful
return(true);
}
//+------------------------------------------------------------------+
//| TestIndexOf_Common. |
//+------------------------------------------------------------------+
bool TestIndexOf_Common(const int count)
{
//--- create source list
CArrayList<int>list_test(count);
for(int i=0; i<count; i++)
list_test.Add(i);
//--- get item from middle of array
int item = count/2;
//--- find value with method IndexOf
if(item != list_test.IndexOf(item))
return (false);
if(item != list_test.IndexOf(item, 0))
return (false);
if(item != list_test.IndexOf(item, 0, item+1))
return (false);
if(item != list_test.IndexOf(item, 0, count))
return (false);
if(item != list_test.IndexOf(item, 0, count+1))
return (false);
//--- find value with method LastIndexOf
if(item != list_test.LastIndexOf(item))
return (false);
if(item != list_test.LastIndexOf(item, count-1))
return (false);
if(item != list_test.LastIndexOf(item, count-1, count-item))
return (false);
if(item != list_test.LastIndexOf(item, count-1, count))
return (false);
if(item != list_test.LastIndexOf(item, count-1, count+1))
return (false);
//--- successful
return(true);
}
//+------------------------------------------------------------------+
//| TestIndexOf_OutOfRange. |
//+------------------------------------------------------------------+
bool TestIndexOf_OutOfRange(const int count)
{
//--- create source list
CArrayList<int>list_test(count);
for(int i=0; i<count; i++)
list_test.Add(MathRand());
//--- crete some element
int element=MathRand();
//--- try to find index of element
if(list_test.IndexOf(element,count+1)!=-1 ||
list_test.IndexOf(element,count+10)!=-1 ||
list_test.IndexOf(element, count-1)!=-1 ||
list_test.IndexOf(element,INT_MIN)!=-1 ||
list_test.IndexOf(element,count,1)!=-1 ||
list_test.IndexOf(element,count+1,1)!=-1 ||
list_test.IndexOf(element,count/2,count/2+2)!=-1 ||
list_test.IndexOf(element, 0, -1)!=-1 ||
list_test.IndexOf(element, -1, 1)!=-1)
return(false);
//--- successful
return(true);
}
//+------------------------------------------------------------------+
//| TestIndexOf. |
//+------------------------------------------------------------------+
bool TestIndexOf(const string test_name)
{
PrintFormat("%s started",test_name);
//--- test 1
PrintFormat("%s: Test 1: Validation of IndexOf and LastIndexOf methods for value in the list which does not contains it.",test_name);
if(!TestIndexOf_NonExistingValues(10))
return(false);
//--- test 2
PrintFormat("%s: Test 2: Validation of IndexOf method on the list with duplicate values and correct input parameters.",test_name);
if(!TestIndexOf_OrderIsCorrect(10))
return(false);
//--- test 3
PrintFormat("%s: Test 3: Validation of IndexOf method on the list with duplicate values and incorrect input parameters.",test_name);
if(!TestIndexOf_OutOfRange(10))
return(false);
//--- test 4
PrintFormat("%s: Test 3: Validation of IndexOf method on the list with duplicate values and differents input parameters.",test_name);
if(!TestIndexOf_Common(10))
return(false);
//--- successful
PrintFormat("%s passed",test_name);
return(true);
}
//+------------------------------------------------------------------+
//| TestMisc_BasicInsert. |
//+------------------------------------------------------------------+
bool TestMisc_BasicInsert(const int count)
{
//--- create source list
CArrayList<int>list_test(count);
for(int i=0; i<count; i++)
list_test.Add(MathRand());
//--- create clone
CArrayList<int>list_clone(GetPointer(list_test));
//--- create random array
int element=MathRand();
//--- insert
int index=count/2;
for(int i=0; i<count; i++)
list_test.Insert(index,element);
//--- check
if(!list_test.Contains(element))
return(false);
if(list_test.Count()!=2*count)
return(false);
for(int i=0; i<index; i++)
{
int value_test;
int value_clone;
list_test.TryGetValue(i,value_test);
list_clone.TryGetValue(i,value_clone);
if(value_test!=value_clone)
return(false);
}
for(int i=index; i<index+count; i++)
{
int value;
list_test.TryGetValue(i,value);
if(value!=element)
return(false);
}
for(int i=index+count; i<2*count; i++)
{
int value_test;
int value_clone;
list_test.TryGetValue(i,value_test);
list_clone.TryGetValue(i-count,value_clone);
if(value_test!=value_clone)
return(false);
}
//--- create bad indexes
int bad[6];
bad[0] = list_test.Count()+1;
bad[1] = list_test.Count()+2;
bad[2] = INT_MAX;
bad[3] = -1;
bad[4] = -2;
bad[5] = INT_MIN;
//--- try insert by bad indexes
for(int i=0; i<ArraySize(bad); i++)
if(list_test.Insert(bad[i],MathRand()))
return(false);
//--- successful
return(true);
}
//+------------------------------------------------------------------+
//| TestMisc_InsertRange. |
//+------------------------------------------------------------------+
bool TestMisc_InsertRange(const int count)
{
//--- create x list
CArrayList<int>list_x(count);
for(int i=0; i<count; i++)
list_x.Add(MathRand());
//--- create y list
CArrayList<int>list_y(count);
for(int i=0; i<count; i++)
list_y.Add(MathRand());
//--- insert y to x
int index=count/2;
list_x.InsertRange(index,GetPointer(list_y));
//--- check elements
for(int i=index; i<index+count; i++)
{
int value_x;
int value_y;
list_x.TryGetValue(i,value_x);
list_y.TryGetValue(i-index,value_y);
if(value_x!=value_y)
return(false);
}
//--- insert range into itself
CArrayList<int>list(GetPointer(list_y));
list.InsertRange(index,GetPointer(list));
//--- check elements
for(int i=0; i<index; i++)
{
int value1;
int value2;
list.TryGetValue(i,value1);
list.TryGetValue(i+index,value2);
if(value1!=value2)
return(false);
}
//--- test arrays
int array_x[];
int array_y[];
ArrayResize(array_x,count);
ArrayResize(array_y,count);
for(int i=0; i<count; i++)
{
array_x[i]=MathRand();
array_y[i]=MathRand();
}
CArrayList<int>list_new_x(array_x);
//--- insert array
list_new_x.InsertRange(index,array_y);
//--- check elements
for(int i=0; i<index; i++)
{
int value;
list_new_x.TryGetValue(i,value);
if(value!=array_x[i])
return(false);
}
for(int i=index; i<index+count; i++)
{
int value;
list_new_x.TryGetValue(i,value);
if(value!=array_y[i-index])
return(false);
}
for(int i=index+count; i<2*count; i++)
{
int value;
list_new_x.TryGetValue(i,value);
if(value!=array_x[i-count])
return(false);
}
//--- successful
return(true);
}
//+------------------------------------------------------------------+
//| TestMisc_Contains. |
//+------------------------------------------------------------------+
bool TestMisc_Contains(const int count)
{
//--- create source array
int array[];
ArrayResize(array,count);
for(int i=0; i<count; i++)
array[i]=MathRand();
//--- create source list
CArrayList<int>list_test(array);
//--- check elements
for(int i=0; i<count; i++)
if(!list_test.Contains(array[i]))
return(false);
//--- successful
return(true);
}
//+------------------------------------------------------------------+
//| TestMisc_Remove. |
//+------------------------------------------------------------------+
bool TestMisc_Remove(const int count)
{
//--- create source array
int array[];
ArrayResize(array,count);
for(int i=0; i<count; i++)
array[i]=MathRand();
//--- create source list
CArrayList<int>list_test(array);
list_test.Sort();
//--- remove elements
for(int i=0; i<count; i++)
if(!list_test.Remove(array[i]))
return(false);
//--- check count
if(list_test.Count()>0)
return(false);
//--- successful
return(true);
}
//+------------------------------------------------------------------+
//| TestMisc_Clear. |
//+------------------------------------------------------------------+
bool TestMisc_Clear(const int count)
{
//--- create source list
CArrayList<int>list_test(count);
//--- check
if(list_test.Count()!=0)
return(false);
if(list_test.Capacity()!=count)
return(false);
//--- fill list
for(int i=0; i<count; i++)
list_test.Add(MathRand());
//--- check
if(list_test.Count()!=count)
return(false);
//--- clear list
list_test.Clear();
//--- check
if(list_test.Count()!=0)
return(false);
//--- successful
return(true);
}
//+------------------------------------------------------------------+
//| TestMisc. |
//+------------------------------------------------------------------+
bool TestMisc(const string test_name)
{
PrintFormat("%s started",test_name);
//--- test 1
PrintFormat("%s: Test 1: Complex validation of Insert method with correct and incorrect input parameters.",test_name);
if(!TestMisc_BasicInsert(10))
return(false);
//--- test 2
PrintFormat("%s: Test 2: Inserts the array and ICollection object into the list at the specified index.",test_name);
if(!TestMisc_InsertRange(10))
return(false);
//--- test 3
PrintFormat("%s: Test 3: Testing Contains method for each element of the list.",test_name);
if(!TestMisc_Contains(10))
return(false);
//--- test 4
PrintFormat("%s: Test 4: Remove all element the list and check count after.",test_name);
if(!TestMisc_Remove(10))
return(false);
//--- test 5
PrintFormat("%s: Test 5: Clear the list and check count after.",test_name);
if(!TestMisc_Clear(10))
return(false);
//--- successful
PrintFormat("%s passed",test_name);
return(true);
}
//+------------------------------------------------------------------+
//| TestRemove_Range. |
//+------------------------------------------------------------------+
bool TestRemove_Range(const int count)
{
//--- create source list
CArrayList<int>list_test(count);
for(int i=0; i<count; i++)
list_test.Add(MathRand());
//--- create clone
CArrayList<int>list_clone(GetPointer(list_test));
//--- create paremeters
int values[9][2]=
{
{3, 3},
{0, 10},
{10, 0},
{5, 5},
{0, 5},
{1, 9},
{9, 1},
{2, 8},
{8, 2}
};
//--- remove range
for(int j=0; j<9; j++)
{
CArrayList<int>list_actual(GetPointer(list_test));
int rindex = values[j][0];
int rcount = values[j][1];
if(!list_actual.RemoveRange(rindex,rcount))
return(false);
if(list_actual.Count()!=count-rcount)
return(false);
for(int i=0; i<rindex; i++)
{
int value_actual;
int value_clone;
list_actual.TryGetValue(i,value_actual);
list_clone.TryGetValue(i,value_clone);
if(value_actual!=value_clone)
return(false);
}
for(int i=rindex; i<count-rcount; i++)
{
int value_actual;
int value_clone;
list_actual.TryGetValue(i,value_actual);
list_clone.TryGetValue(i+rcount,value_clone);
if(value_actual!=value_clone)
return(false);
}
}
//--- successful
return(true);
}
//+------------------------------------------------------------------+
//| TestRemove_Invalid. |
//+------------------------------------------------------------------+
bool TestRemove_Invalid(const int count)
{
//--- create source list
CArrayList<int>list_test(count);
for(int i=0; i<count; i++)
list_test.Add(MathRand());
//--- create invalid paremeters
int values[21][2];
values[0][0]=count;
values[0][1]=1;
values[1][0]=count+1;
values[1][1]=0;
values[2][0]=count+1;
values[2][1]=1;
values[3][0]=count;
values[3][1]=2;
values[4][0]=count/2;
values[4][1]=count/2+1;
values[5][0]=count-1;
values[5][1]=2;
values[6][0]=count-2;
values[6][1]=3;
values[7][0]=1;
values[7][1]=count;
values[8][0]=0;
values[8][1]=count+1;
values[9][0]=1;
values[9][1]=count+1;
values[10][0]=2;
values[10][1]=count;
values[11][0]=count/2+1;
values[11][1]=count/2;
values[12][0]=2;
values[12][1]=count-1;
values[13][0]=3;
values[13][1]=count-2;
values[14][0]=-1;
values[14][1]=-1;
values[15][0]=-1;
values[15][1]=0;
values[16][0]=-1;
values[16][1]=1;
values[17][0]=-1;
values[17][1]=2;
values[18][0]=0;
values[18][1]=-1;
values[19][0]=1;
values[19][1]=-1;
values[20][0]=2;
values[20][1]=-1;
//--- remove range
for(int j=0; j<21; j++)
{
int rindex = values[j][0];
int rcount = values[j][1];
if(list_test.RemoveRange(rindex,rcount))
return(false);
}
//--- check count
if(list_test.Count()!=count)
return(false);
//--- successful
return(true);
}
//+------------------------------------------------------------------+
//| TestRemove. |
//+------------------------------------------------------------------+
bool TestRemove(const string test_name)
{
PrintFormat("%s started",test_name);
//--- test 1
PrintFormat("%s: Test 1: Testing RemoveRange method on the list with correct input parameters.",test_name);
if(!TestRemove_Range(10))
return(false);
//--- test 2
PrintFormat("%s: Test 2: Testing RemoveRange method on the list with incorrect input parameters.",test_name);
if(!TestRemove_Invalid(10))
return(false);
//--- successful
PrintFormat("%s passed",test_name);
return(true);
}
//+------------------------------------------------------------------+
//| TestReverse_Range. |
//+------------------------------------------------------------------+
bool TestReverse_Range(const int count)
{
//--- create source list
CArrayList<int>list_test(count);
for(int i=0; i<count; i++)
list_test.Add(MathRand());
//--- create clone
CArrayList<int>list_clone(GetPointer(list_test));
//--- create paremeters
int values[9][2]=
{
{3, 3},
{0, 10},
{10, 0},
{5, 5},
{0, 5},
{1, 9},
{9, 1},
{2, 8},
{8, 2}
};
//--- reverse list
for(int j=0; j<9; j++)
{
int rindex = values[j][0];
int rcount = values[j][1];
CArrayList<int>list_actual(GetPointer(list_test));
list_actual.Reverse(rindex,rcount);
for(int i=0; i<rindex; i++)
{
int value_actual;
int value_clone;
list_actual.TryGetValue(i,value_actual);
list_clone.TryGetValue(i,value_clone);
if(value_actual!=value_clone)
return(false);
}
int k=0;
for(int i=rindex; i<rindex+rcount; i++)
{
int value_actual;
int value_clone;
list_actual.TryGetValue(i,value_actual);
list_clone.TryGetValue(rindex+rcount-(k+1),value_clone);
if(value_actual!=value_clone)
return(false);
k++;
}
for(int i=rindex+rcount; i<list_clone.Count(); i++)
{
int value_actual;
int value_clone;
list_actual.TryGetValue(i,value_actual);
list_clone.TryGetValue(i,value_clone);
if(value_actual!=value_clone)
return(false);
}
}
//--- successful
return(true);
}
//+------------------------------------------------------------------+
//| TestReverse_Invalid. |
//+------------------------------------------------------------------+
bool TestReverse_Invalid(const int count)
{
//--- create source list
CArrayList<int>list_test(count);
for(int i=0; i<count; i++)
list_test.Add(MathRand());
//--- create invalid paremeters
int values[21][2];
values[0][0]=count;
values[0][1]=1;
values[1][0]=count+1;
values[1][1]=0;
values[2][0]=count+1;
values[2][1]=1;
values[3][0]=count;
values[3][1]=2;
values[4][0]=count/2;
values[4][1]=count/2+1;
values[5][0]=count-1;
values[5][1]=2;
values[6][0]=count-2;
values[6][1]=3;
values[7][0]=1;
values[7][1]=count;
values[8][0]=0;
values[8][1]=count+1;
values[9][0]=1;
values[9][1]=count+1;
values[10][0]=2;
values[10][1]=count;
values[11][0]=count/2+1;
values[11][1]=count/2;
values[12][0]=2;
values[12][1]=count-1;
values[13][0]=3;
values[13][1]=count-2;
values[14][0]=-1;
values[14][1]=-1;
values[15][0]=-1;
values[15][1]=0;
values[16][0]=-1;
values[16][1]=1;
values[17][0]=-1;
values[17][1]=2;
values[18][0]=0;
values[18][1]=-1;
values[19][0]=1;
values[19][1]=-1;
values[20][0]=2;
values[20][1]=-1;
//--- remove range
for(int j=0; j<21; j++)
{
int rindex = values[j][0];
int rcount = values[j][1];
if(list_test.Reverse(rindex,rcount))
return(false);
}
//--- successful
return(true);
}
//+------------------------------------------------------------------+
//| TestReverse. |
//+------------------------------------------------------------------+
bool TestReverse(const string test_name)
{
PrintFormat("%s started",test_name);
//--- test 1
PrintFormat("%s: Test 1: Testing Reverse method on the list with correct input parameters.",test_name);
if(!TestReverse_Range(10))
return(false);
//--- test 2
PrintFormat("%s: Test 2: Testing Reverse method on the list with correct input parameters.",test_name);
if(!TestReverse_Invalid(10))
return(false);
//--- successful
PrintFormat("%s passed",test_name);
return(true);
}
//+------------------------------------------------------------------+
//| TestSort_WithDuplicates. |
//+------------------------------------------------------------------+
bool TestSort_WithDuplicates(const int count)
{
//--- create source list
CArrayList<int>list_test(count);
for(int i=0; i<count; i++)
list_test.Add(MathRand());
//--- add duplicates
int value0;
list_test.TryGetValue(0, value0);
list_test.Add(value0);
//--- create comparer
CDefaultComparer<int>comaprer;
//--- sort list
list_test.Sort();
//--- check
for(int i=0; i<count-1; i++)
{
int value1;
int value2;
list_test.TryGetValue(i, value1);
list_test.TryGetValue(i+1, value2);
if(comaprer.Compare(value1,value2)>0)
return(false);
}
//--- successful
return(true);
}
//+------------------------------------------------------------------+
//| TestSort_Invalid. |
//+------------------------------------------------------------------+
bool TestSort_Invalid(const int count)
{
//--- create source list
CArrayList<int>list_test(count);
for(int i=0; i<count; i++)
list_test.Add(MathRand());
//--- create invalid paremeters
int values[11][2]=
{
{-1,-1},
{-1,0},
{-1,1},
{-1,2},
{-2,0},
{INT_MIN, 0},
{0,-1},
{0,-2},
{0,INT_MIN},
{1,-1},
{2,-1},
};
//--- reverse list
for(int j=0; j<11; j++)
{
int rindex = values[j][0];
int rcount = values[j][1];
if(list_test.Reverse(rindex,rcount))
return(false);
}
//--- successful
return(true);
}
//+------------------------------------------------------------------+
//| TestSort. |
//+------------------------------------------------------------------+
bool TestSort(const string test_name)
{
PrintFormat("%s started",test_name);
//--- test 1
PrintFormat("%s: Test 1: Testing Sort method on the list with correct input parameters.",test_name);
if(!TestSort_WithDuplicates(10))
return(false);
//--- test 2
PrintFormat("%s: Test 2: Testing Sort method on the list with incorrect input parameters.",test_name);
if(!TestSort_Invalid(10))
return(false);
//--- successful
PrintFormat("%s passed",test_name);
return(true);
}
//+------------------------------------------------------------------+
//| TestArrayList. |
//+------------------------------------------------------------------+
void TestArrayList(int &tests_performed,int &tests_passed)
{
string test_name="";
//--- AddRange functions
tests_performed++;
test_name="AddRange functions test";
if(TestAddRange(test_name))
tests_passed++;
else
PrintFormat("%s failed",test_name);
//--- BinarySearch functions
tests_performed++;
test_name="BinarySearch functions test";
if(TestBinarySearch(test_name))
tests_passed++;
else
PrintFormat("%s failed",test_name);
//--- IndexOf functions
tests_performed++;
test_name="IndexOf functions test";
if(TestIndexOf(test_name))
tests_passed++;
else
PrintFormat("%s failed",test_name);
//--- Misc functions
tests_performed++;
test_name="Misc functions test";
if(TestMisc(test_name))
tests_passed++;
else
PrintFormat("%s failed",test_name);
//--- Remove functions
tests_performed++;
test_name="Remove functions test";
if(TestRemove(test_name))
tests_passed++;
else
PrintFormat("%s failed",test_name);
//--- Reverse functions
tests_performed++;
test_name="Reverse functions test";
if(TestReverse(test_name))
tests_passed++;
else
PrintFormat("%s failed",test_name);
//--- Sort functions
tests_performed++;
test_name="Sort functions test";
if(TestSort(test_name))
tests_passed++;
else
PrintFormat("%s failed",test_name);
}
//+------------------------------------------------------------------+
//| Script program start function |
//+------------------------------------------------------------------+
void OnStart()
{
MathSrand(0);
string package_name="Generic";
PrintFormat("Unit tests for Package %s\n",package_name);
//--- initial values
int tests_performed=0;
int tests_passed=0;
//--- test distributions
TestArrayList(tests_performed,tests_passed);
//--- print statistics
PrintFormat("\n%d of %d passed",tests_passed,tests_performed);
}
//+------------------------------------------------------------------+
Reference in a new issueCopy permalink