This page shows a variation of the Calculator project called AdvancedCalculator.This is a more extensive version of the same design. Contains new functionality in operation.cpp and therefore has more test cases.

1. 1. Division and Division Errors - Testing Exceptions

This section is basically the same in terms of test suites as in the Calculator project, but was not covered on the previous page.

The following test suites can be found in the tst directory in test_operation.cpp:

TEST(DivideOperation, PositiveInput) {
    // Integer arguments
    ASSERT_EQ(divide(10, 5), 2);
    ASSERT_FLOAT_EQ(divide(5, 10), 0.5);
    // Floating-point arguments
    ASSERT_FLOAT_EQ(divide(10.0f, 5.0f), 2.0f);
    ASSERT_FLOAT_EQ(divide(5.0f, 10.0f), 0.5f);
}

This is a very simple check that verifies that an input is producing the desired result. However, the division function itself has two forms, one for integer input data and one for floating point data. In such a situation, both cases should be checked.

TEST(DivideOperation, NegitiveInput) {
    ASSERT_EQ(divide(-10, -5), 2);
    ASSERT_FLOAT_EQ(divide(-5, -10), 0.5);
    // Floating-point arguments
    ASSERT_FLOAT_EQ(divide(-10.0f, -5.0f), 2.0f);
    ASSERT_FLOAT_EQ(divide(-5.0f, -10.0f), 0.5f);
}

Next (above) is the negative input verification, which has exactly the same operating logic as the previous test suite, but with negative signed arguments.

And last but not least in this section, below is the zero division error check:

TEST(DivideOperation, ZerioInput) {
    EXPECT_THROW(divide(10, 0), std::overflow_error);
    EXPECT_THROW(divide(10.0f, 0.0f), std::overflow_error);
}

It is important to note that the assertion used is EXPECT_THROW, which has been specifically designed to catch and inspect a specific exception. It is also important to test for both types of input arguments.

The divide function itself has a very simple body:

float divide(int numerator, int denominator){
    if(denominator == 0){
        throw std::overflow_error("Divide by zero exception!!! Verify the denominator value!");
    }
    return float(numerator) / float(denominator);
}

The return type of this function is floating point because even if both of the arguments supplied are integers, the result need not be an integer. Basically the function takes two arguments and checks that the denominator is not zero in any case, otherwise an overflow_error exception will be thrown with the custom message.

2. 2. Testing whether the result is within range

Checking whether the obtained result is within the expected range, it will be presented in two ways. This will be shown in the example get_pi() function, which task is to return only Pi with high decimal precision of 36 digits. The get_pi() function body:

double get_pi(){
    return 3.141592653589793238462643383279502884L;
}

The EXPECT_NEAR assertion will be presented first. It is very elegant because it allows the determination of the expected absolute error between the values. It was mentioned earlier that the function returns a number with high decimal precision. However, a precision of up to 7 digits is expected. It is enough to provide the expected value and the maximum absolute error. 

TEST(GetPiOperation, AbsoluteError) {
    EXPECT_NEAR(get_pi(), 3.14159265, 1e-8);
    //EXPECT_NEAR(get_pi(), 3.14159265, 1e-9);  // Should FAIL
}

If a given absolute error is not selected correctly, as in the commented line above, the assertion will fail with the message shown below:

The difference between get_pi() and 3.14159265 is 3.5897929073769319e-09, which exceeds 1e-9, where
get_pi() evaluates to 3.1415926535897931,
3.14159265 evaluates to 3.1415926500000002, and
1e-9 evaluates to 1.0000000000000001e-09.
[  FAILED  ] GetPiOperation.AbsoluteError (0 ms)

The second way is to simply place two comparison value assertions as shown below:

TEST(GetPiOperation, InRange) {
    EXPECT_LE(get_pi(), 3.1416);
    EXPECT_GE(get_pi(), 3.1415);
}

3. 3. Testing boundary conditions

This section presents several test suites for different boundary conditions. This section introduces several test suites for different boundary conditions based on the get_triangle_area() function. It takes two filenames as a parameter, one for the length of the base of the triangle and one for its height. It reads each line and calculates the correct area of the triangle for each line.

• CheckType 
  
  At first, it would be appropriate to check that the return type is correct. In a given project, the function returns a vector of floats, and each of its elements is a calculated area. Test suite below:

  TEST(GetTriangleArea, CheckType)

  TEST(GetTriangleArea, CheckType) {
      std::string height_file = "triangle_height.txt";
      std::string base_file = "triangle_base.txt";
      EXPECT_EQ(typeid(std::vector<float>), typeid(get_triangle_area(base_file, height_file)));
  }

  The function under test is quite complex and takes up a lot of lines, so there's no room for it here, but it's worth learning how it works. In this test suite, it is important to provide valid file names, use typeid() to determine the argument type, and use the EXPECT_EQ assertion to verify that it is the same as vector<float>.