cpp syntax

Supported C++ Syntax

Support of C++ language features is very limited. Here you can find test cases examples. All code snippets below were taken from this directory.

• Reference parameters
• Class as parameters
• Class as return values
• Class methods
• Operators
• Private

Reference parameters

intdouble_abs_lvalue_reference(int& a) {
if (a < 0) {
a *= -2;
}
return a;
}
intdouble_abs_const_lvalue_reference(constint& a) {
if (a < 0) {
return -2 * a;
}
return a;
}

Tests code

TEST(regression, double_abs_lvalue_reference_test_1)
{
// Construct inputint a = 0;
// Expected outputint expected = 0;
// Trigger the functionint actual = double_abs_lvalue_reference(a);
// Check resultsEXPECT_EQ(expected, actual);
// Check function parametersint expected_a = 0;
EXPECT_EQ(expected_a, a);
}
TEST(regression, double_abs_lvalue_reference_test_2)
{
// Construct inputint a = -1;
// Expected outputint expected = 2;
// Trigger the functionint actual = double_abs_lvalue_reference(a);
// Check resultsEXPECT_EQ(expected, actual);
// Check function parametersint expected_a = 2;
EXPECT_EQ(expected_a, a);
}
TEST(regression, double_abs_const_lvalue_reference_test_1)
{
// Construct inputint a = 0;
// Expected outputint expected = 0;
// Trigger the functionint actual = double_abs_const_lvalue_reference(a);
// Check resultsEXPECT_EQ(expected, actual);
}
TEST(regression, double_abs_const_lvalue_reference_test_2)
{
// Construct inputint a = -1;
// Expected outputint expected = 2;
// Trigger the functionint actual = double_abs_const_lvalue_reference(a);
// Check resultsEXPECT_EQ(expected, actual);
}

Class as parameters

For class as parameter class should be construct from initializer list of class members and has default constructor

classPoint_2d {
public:int x;
int y;
Point_2d();
Point_2d(constint& x, constint& y);
}voidset_abs_by_ref(Point_2d& point) {
if (point.x < 0) {
point.x = -1 * point.x;
}
if (point.y < 0) {
point.y *= -1;
}
}

Tests code

TEST(regression, set_abs_by_ref_test_1)
{
// Construct inputclassPoint_2d point = {-1, -1};
// Expected output// No output variable for void function// Trigger the functionset_abs_by_ref(point);
// Check results// No check results for void function// Check function parametersclassPoint_2d expected_point = {1, 1};
EXPECT_EQ(expected_point.x, point.x);
EXPECT_EQ(expected_point.y, point.y);
}
TEST(regression, set_abs_by_ref_test_2)
{
// Construct inputclassPoint_2d point = {0, -1};
// Expected output// No output variable for void function// Trigger the functionset_abs_by_ref(point);
// Check results// No check results for void function// Check function parametersclassPoint_2d expected_point = {0, 1};
EXPECT_EQ(expected_point.x, point.x);
EXPECT_EQ(expected_point.y, point.y);
}
TEST(regression, set_abs_by_ref_test_3)
{
// Construct inputclassPoint_2d point = {-1, 0};
// Expected output// No output variable for void function// Trigger the functionset_abs_by_ref(point);
// Check results// No check results for void function// Check function parametersclassPoint_2d expected_point = {1, 0};
EXPECT_EQ(expected_point.x, point.x);
EXPECT_EQ(expected_point.y, point.y);
}
TEST(regression, set_abs_by_ref_test_4)
{
// Construct inputclassPoint_2d point = {0, 0};
// Expected output// No output variable for void function// Trigger the functionset_abs_by_ref(point);
// Check results// No check results for void function// Check function parametersclassPoint_2d expected_point = {0, 0};
EXPECT_EQ(expected_point.x, point.x);
EXPECT_EQ(expected_point.y, point.y);
}

Class as return values

voidset_abs_by_ref(Point_2d& point) {
if (point.x < 0) {
point.x = -1 * point.x;
}
if (point.y < 0) {
point.y *= -1;
}
}
Point_2d abs_point(Point_2d point) {
set_abs_by_ref(point);
return point;
}

Tests code

TEST(regression, abs_point_test_1)
{
// Construct inputclassPoint_2d point = {-1, 0};
// Expected outputclassPoint_2d expected = {1, 0};
// Trigger the functionclassPoint_2d actual = abs_point(point);
// Check resultsEXPECT_EQ(expected.x, actual.x);
EXPECT_EQ(expected.y, actual.y);
}
TEST(regression, abs_point_test_2)
{
// Construct inputclassPoint_2d point = {-1, -1};
// Expected outputclassPoint_2d expected = {1, 1};
// Trigger the functionclassPoint_2d actual = abs_point(point);
// Check resultsEXPECT_EQ(expected.x, actual.x);
EXPECT_EQ(expected.y, actual.y);
}
TEST(regression, abs_point_test_3)
{
// Construct inputclassPoint_2d point = {0, -1};
// Expected outputclassPoint_2d expected = {0, 1};
// Trigger the functionclassPoint_2d actual = abs_point(point);
// Check resultsEXPECT_EQ(expected.x, actual.x);
EXPECT_EQ(expected.y, actual.y);
}

Class methods

For genetating method tests UTBot need default constructor of class

classPoint_2d {
public:int x;
int y;
Point_2d();
Point_2d(constint& x, constint& y);
}intPoint_2d::get_x() const {
return x;
}

Tests code

TEST(regression, Point_2d_get_x_test_1)
{
Point_2d Point_2d_obj;
// Expected outputint expected = 0;
// Trigger the functionint actual = Point_2d_obj.get_x();
// Check resultsEXPECT_EQ(expected, actual);
}

Operators

classPoint_2d {
public:int x;
int y;
Point_2d();
Point_2d(constint& x, constint& y);
Point_2d operator-=(const Point_2d& rhs);
friend Point_2d operator-(Point_2d lhs, const Point_2d& rhs);
}
Point_2d Point_2d::operator-=(const Point_2d& rhs) {
this->x -= rhs.x;
this->y -= rhs.y;
return *this;
}
Point_2d operator-(Point_2d lhs, const Point_2d& rhs) {
lhs -= rhs;
return lhs;
}

Tests code

TEST(regression, Point_2d_operator_minus_equal_test_1)
{
// Construct input
Point_2d Point_2d_obj;
classPoint_2d rhs = {0, 0};
// Expected outputclassPoint_2d expected = {0, 0};
// Trigger the functionclassPoint_2d actual = Point_2d_obj.operator-=(rhs);
// Check resultsEXPECT_EQ(expected.x, actual.x);
EXPECT_EQ(expected.y, actual.y);
}
TEST(regression, operator_minus_test_1)
{
// Construct inputclassPoint_2d lhs = {0, 0};
classPoint_2d rhs = {0, 0};
// Expected outputclassPoint_2d expected = {0, 0};
// Trigger the functionclassPoint_2d actual = operator-(lhs, rhs);
// Check resultsEXPECT_EQ(expected.x, actual.x);
EXPECT_EQ(expected.y, actual.y);
}

Private

For test private UTBot use martong/access_private.git

classPrivate {
private:int x;
public:Private();
Private(int x);
friend Private get_abs_value(Private p);
};
Private get_abs_value(Private p) {
if (p.x < 0) {
return -1 * p.x;
}
return p;
}

Tests code

TEST(regression, get_abs_value_test_1)
{
// Construct inputclassPrivate p = {-1};
// Expected outputclassPrivate expected = {1};
// Trigger the functionclassPrivate actual = get_abs_value(p);
// Check resultsEXPECT_EQ(access_private::x(expected), access_private::x(actual));
}
TEST(regression, get_abs_value_test_2)
{
// Construct inputclassPrivate p = {0};
// Expected outputclassPrivate expected = {0};
// Trigger the functionclassPrivate actual = get_abs_value(p);
// Check resultsEXPECT_EQ(access_private::x(expected), access_private::x(actual));
}