| //+------------------------------------------------------------------+
|
| //| 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);
|
| }
|
| //+------------------------------------------------------------------+
|
