tests Namespace Reference

Testcases to check Reversal of Binary Tree. More...

Functions
void	test1 ()
	< Use the BinaryTree More...
void	test2 ()
	A Test to check an edge case (NULL root element) More...
void	test3 ()
	A Test to check correct reversal of a Binary Tree. More...
void	test4 ()
	A Test to check correct functionality with duplicate values. More...
void	test5 ()
	A Test to check correct functionality with a harder test case. More...
void	test6 ()
	A Test to check correct functionality with an array sorted using std::sort. More...

Detailed Description

Testcases to check Reversal of Binary Tree.

Testcases to check Union of Two Arrays.

Function Documentation

test1()

void tests::test1

(

)

< Use the BinaryTree

A Test to check an edge case (two empty arrays)

A Test to check an edge case (single element reversal)

Returns

void

< Check for equal sizes

< Ensure that there is only one element

< Check if both elements are same

< Check if result is empty

< Should only print newline

< Check if result is empty

< Should only print newline

             {
    BinaryTree bst;
    std::vector<int64_t> pre_reversal, post_reversal;
    std::cout << "TEST CASE 1\n";
    std::cout << "Initializing tree with a single element (5)\n";
    bst.add(5);
    pre_reversal = bst.get_level_order();
    std::cout << "Before reversal: ";
    bst.print();
    std::cout << "After reversal: ";
    bst.reverse();
    post_reversal = bst.get_level_order();
    assert(pre_reversal.size() ==
           post_reversal.size());  ///< Check for equal sizes
    assert(pre_reversal.size() ==
           1);  ///< Ensure that there is only one element
    assert(pre_reversal[0] ==
           post_reversal[0]);  ///< Check if both elements are same
    bst.print();
    std::cout << "TEST PASSED!\n\n";
}

Here is the call graph for this function:

test2()

void tests::test2

(

)

A Test to check an edge case (NULL root element)

A Test to check an edge case (one empty array)

Returns

void

< Check for equal sizes

< Ensure that there is only one element

< Check if result is equal to b

< Should print 2 3

< Check if result is equal to b

< Should print 2 3

             {
    BinaryTree bst;
    std::vector<int64_t> pre_reversal, post_reversal;
    std::cout << "TEST CASE 2\n";
    std::cout << "Creating empty tree (root points to NULL)\n";
    pre_reversal = bst.get_level_order();
    std::cout << "Before reversal: ";
    bst.print();
    std::cout << "After reversal: ";
    bst.reverse();
    post_reversal = bst.get_level_order();
    assert(pre_reversal.size() ==
           post_reversal.size());  ///< Check for equal sizes
    assert(pre_reversal.size() ==
           0);  ///< Ensure that there is only one element
    bst.print();
    std::cout << "TEST PASSED!\n\n";
}

Here is the call graph for this function:

test3()

void tests::test3

(

)

A Test to check correct reversal of a Binary Tree.

A Test to check correct functionality with a simple test case.

Returns

void

< Check for equality

< Check for equality

< Check if result is correct

< Should print 2 3 4 6

< Check if result is correct

< Should print 2 3 4 6

             {
    BinaryTree bst;
    std::vector<int64_t> pre_reversal, post_reversal;
    std::vector<int64_t> pre_res = {4, 3, 6, 2, 5, 7, 1};
    std::vector<int64_t> post_res = {4, 6, 3, 7, 5, 2, 1};
    std::cout << "TEST CASE 3\n";
    std::cout << "Creating tree with elements (4, 6, 3, 2, 5, 7, 1)\n";
    bst.add(4);
    bst.add(6);
    bst.add(3);
    bst.add(2);
    bst.add(5);
    bst.add(7);
    bst.add(1);
    pre_reversal = bst.get_level_order();
    assert(pre_reversal == pre_res);  ///< Check for equality
    std::cout << "Before reversal: ";
    bst.print();
    std::cout << "After reversal: ";
    bst.reverse();
    post_reversal = bst.get_level_order();
    assert(post_reversal == post_res);  ///< Check for equality
    bst.print();
    std::cout << "TEST PASSED!\n\n";
}

test4()

void tests::test4

(

)

A Test to check correct functionality with duplicate values.

Returns

void

< Check if result is correct

< Should print 2 3 4 6 7

             {
    std::cout << "TEST CASE 4\n";
    std::cout << "Intialized a = {4, 6, 6, 7} b = {2, 3, 4}\n";
    std::cout << "Expected result: {2, 3, 4, 6, 7}\n";
    std::vector<int32_t> a = {4, 6, 6, 7};
    std::vector<int32_t> b = {2, 3, 4};
    std::vector<int32_t> result = get_union(a, b);
    std::vector<int32_t> expected = {2, 3, 4, 6, 7};
    assert(result == expected);  ///< Check if result is correct
    print(result);               ///< Should print 2 3 4 6 7
    std::cout << "TEST PASSED!\n\n";
}

Here is the call graph for this function:

test5()

void tests::test5

(

)

A Test to check correct functionality with a harder test case.

Returns

void

< Check if result is correct

< Should print 1 2 3 4 5 6 7 9

             {
    std::cout << "TEST CASE 5\n";
    std::cout << "Intialized a = {1, 4, 6, 7, 9} b = {2, 3, 5}\n";
    std::cout << "Expected result: {1, 2, 3, 4, 5, 6, 7, 9}\n";
    std::vector<int32_t> a = {1, 4, 6, 7, 9};
    std::vector<int32_t> b = {2, 3, 5};
    std::vector<int32_t> result = get_union(a, b);
    std::vector<int32_t> expected = {1, 2, 3, 4, 5, 6, 7, 9};
    assert(result == expected);  ///< Check if result is correct
    print(result);               ///< Should print 1 2 3 4 5 6 7 9
    std::cout << "TEST PASSED!\n\n";
}

Here is the call graph for this function:

test6()

void tests::test6

(

)

A Test to check correct functionality with an array sorted using std::sort.

Returns

void

< Sort vector a

< Sort vector b

< Check if result is correct

< Should print 1 2 3 4 5 6 7 8 9 11

             {
    std::cout << "TEST CASE 6\n";
    std::cout << "Intialized a = {1, 3, 3, 2, 5, 9, 4, 3, 2} ";
    std::cout << "b = {11, 3, 7, 8, 6}\n";
    std::cout << "Expected result: {1, 2, 3, 4, 5, 6, 7, 8, 9, 11}\n";
    std::vector<int32_t> a = {1, 3, 3, 2, 5, 9, 4, 3, 2};
    std::vector<int32_t> b = {11, 3, 7, 8, 6};
    std::sort(a.begin(), a.end());  ///< Sort vector a
    std::sort(b.begin(), b.end());  ///< Sort vector b
    std::vector<int32_t> result = get_union(a, b);
    std::vector<int32_t> expected = {1, 2, 3, 4, 5, 6, 7, 8, 9, 11};
    assert(result == expected);  ///< Check if result is correct
    print(result);               ///< Should print 1 2 3 4 5 6 7 8 9 11
    std::cout << "TEST PASSED!\n\n";
}

Here is the call graph for this function: