void insertElements(vector<int> &num, int low, int high, TreeNode *root) {
if (low > high)
return;
int mid = (low + high) >> 1;
insertToBST(root, num[mid]);
insertElements(num, low, mid - 1, root);
insertElements(num, mid + 1, high, root);
}
void test_areEqual_returns_1_for_two_equal_ArrayUtils_with_elements (){
ArrayUtil list = create(4, 5);
int array[] = {1,2,3,4,5};
insertElements(&list, array);
ArrayUtil list1 = create(4, 5);
insertElements(&list1, array);
assert(areEqual(list, list1)==1);
dispose(list);
dispose(list1);
}
void test_filter_gives_the_addresses_of_matched_elements_to_destination_for_isDivisible (){
int array[] = {1,2,3,4,8,6};
int expected_array[] = {2,4,8,6};
int a = 2;
ArrayUtil util = create(4,6);
ArrayUtil result = create(4,4);
ArrayUtil dest = create(4, 3);
insertElements(&result, &expected_array);
insertElements(&util, array);
filter(util, isDivisible, &a, &dest, dest.length);
assert(areEqual(result, dest)==0);
dispose(util);
}
void test_forEach_does_given_operation_on_all_elements_of_array (){
ArrayUtil source = create(4,5);
ArrayUtil expected = create(4,5);
int source_array[] = {1,2,3,4,5};
insertElements(&source, source_array);
int expected_array[] = {2,3,4,5,6};
insertElements(&expected, expected_array);
forEach(source, addOneForEach, NULL);
assert(areEqual(source, expected)==1);
}
void test_map_does_function_on_all_elements_of_array_and_stores_in_destination (){
ArrayUtil source = create(4,5);
ArrayUtil dest = create(4,5);
ArrayUtil expected = create(4,5);
int source_array[] = {1,2,3,4,5};
insertElements(&source, source_array);
int expected_array[] = {2,3,4,5,6};
insertElements(&expected, expected_array);
int *a = dest.base;
map(source, dest, addOne, NULL);
assert(areEqual(dest, expected)==1);
}
int main()
{
// Initialize the root
Node *root = NULL;
int insertElements(Node **root,int data);
int printElements(Node *root);
int getMaxDepth(Node *root,int parentLevel);
int getNodeCount(Node *root);
int hasPathSum(Node *root,int sumValue,int parentSumVal);
int printPath(Node *root);
int numElements;
printf("Please enter the number of elements to be inserted\n");
scanf("%d",&numElements);
if (numElements > MAXELEMENTS)
{
printf("Exceeded total num of elements allowed\n");
return 0;
}
// Input elements into BST
for (int i=1;i<=numElements;i++)
{
int data;
printf("Enter node data \n");
scanf("%d",&data);
if (!insertElements(&root,data))
{
printf("Unable to insert element\n");
return 0;
}
}
// print BST elements
if (!printElements(root))
{
printf("Unable to print elements\n");
return 0;
}
printf("The max depth of the tree %d \n",getMaxDepth(root,100));
printf("Number of nodes in the tree %d \n",getNodeCount(root));
int sumVal;
printf("Enter the sum value \n");
scanf("%d",&sumVal);
if (hasPathSum(root,sumVal,100))
{
printf("sum of at least one of the path is %d\n",sumVal);
} else
{
printf("There is no path with sum %d\n",sumVal);
}
return 1;
}
void test_findIndex_returns_index_if_the_element_is_found_once_more() {
int array[] = {1,2,3,4,5};
int a = 5;
ArrayUtil list = create(4, 5);
insertElements(&list, array);
assert(findIndex(list, &a)==4);
dispose(list);
}
void test_findIndex_returns_minus_1_if_the_element_is_not_found() {
int array[] = {1,2,3,4,5};
int a = 6;
ArrayUtil list = create(4, 5);
insertElements(&list, array);
assert(findIndex(list, &a)==-1);
dispose(list);
}
void test_findFirst_returns_NULL_if_none_of_the_elements_matches_criteria () {
int array[] = {1,7,3,9,5};
int *element;
ArrayUtil util = create(4, 5);
insertElements(&util, array);
element = findFirst(util, &isEven, NULL);
assert(element==NULL);
dispose(util);
}
void test_count_returns_ZERO_if_none_of_the_elements_matches_given_criteria() {
int array[] = {1,3,5,7,9};
int element;
ArrayUtil util = create(4, 5);
insertElements(&util, array);
element = count(util, isEven, NULL);
assert(element==0);
dispose(util);
}
void test_count_returns_count_of_the_number_of_elements_that_matches_given_criteria() {
int array[] = {1,2,3,4,5};
int element;
ArrayUtil util = create(4, 5);
insertElements(&util, array);
element = count(util, isEven, NULL);
assert(element==2);
dispose(util);
}
void test_findFirst_returns_pointer_of_the_first_element_matches_criteria () {
int array[] = {1,2,3,4,5};
int a = 5;
int *element;
ArrayUtil util = create(4, 5);
insertElements(&util, array);
element = findFirst(util, &isEven, NULL);
assert(*element==2);
dispose(util);
}
void test_findLast_returns_pointer_of_the_first_element_from_last_that_matches_criteria_for_isDivisible() {
int array[] = {1,2,3,4,5};
int a = 5;
int *element;
ArrayUtil util = create(4, 5);
insertElements(&util, array);
element = findLast(util, isDivisible, &a);
assert(*element==5);
dispose(util);
}
void test_filter_stopes_when_max_size_of_destination_reaches (){
int array[] = {2,2,6,4,5,6};
void *dest[3];
int count=0;
ArrayUtil util = create(4,6);
insertElements(&util, array);
count = filter(util, isEven, NULL, *dest, 3);
assert(count==3);
dispose(util);
}
void test_findLast_returns_NULL_if_none_of_the_elements_matches_criteria_for_isDivisible () {
int array[] = {1,2,3,4,5};
int *element;
int a = 7;
ArrayUtil util = create(4, 5);
insertElements(&util, array);
element = findLast(util, isDivisible, &a);
assert(element==NULL);
dispose(util);
}
void test_filter_returns_number_of_matches_found (){
int array[] = {1,2,3,4,5,6};
void *dest[3];
int count=0;
ArrayUtil util = create(4,6);
insertElements(&util, array);
count = filter(util, isEven, NULL, *dest, 3);
assert(count==3);
dispose(util);
}
void test_reduce_does_given_operation_on_all_the_elements_and_returns_final_value_with_sumOfMultiples (){
ArrayUtil source = create(4,2);
int source_array[] = {1,2};
insertElements(&source, source_array);
int inital_value = 0;
int multiple = 2;
void *result = reduce(source, sumOfMultiples, &multiple, &inital_value);
assert(*((int *)result)==5);
}
void test_reduce_does_given_operation_on_all_the_elements_and_returns_final_value (){
ArrayUtil source = create(4,5);
int source_array[] = {1,2,3,4,5};
insertElements(&source, source_array);
int inital_value = 0;
void *result = reduce(source, totalReducer, NULL, &inital_value);
assert(*((int *)result)==15);
}
void test_filter_gives_the_addresses_of_matched_elements_to_destination (){
int array[] = {1,2,3,4,5,6};
ArrayUtil util = create(4,6);
int expected_array[] = {2,4,6};
insertElements(&util, array);
void *dest = (void *)calloc(3,8);
int **adr = dest;
filter(util, isEven, NULL, dest, 3);
for (int i = 0; i < 3; ++i,adr++){
assert(**adr==expected_array[i]);
}
}
