From d8e47afe139f02a2e8803b0bd1ce68460d6ab9a7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=A8=D0=B8=D1=88=D0=BE=D0=B2=20=D0=9C=D0=B0=D0=BA=D1=81?= =?UTF-8?q?=D0=B8=D0=BC=20=D0=94=D0=B5=D0=BD=D0=B8=D1=81=D0=BE=D0=B2=D0=B8?= =?UTF-8?q?=D1=87?= Date: Thu, 23 Jul 2020 17:28:10 +0300 Subject: [PATCH] matrix tests --- CMakeLists.txt | 19 +- lib/main/math/test/testpimathmatrix.cpp | 936 ++++++++++++++++++++++++ 2 files changed, 947 insertions(+), 8 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index b647673e..ee727801 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -185,7 +185,7 @@ set(PIP_MAIN_FOLDERS) foreach(F ${PIP_FOLDERS}) list(APPEND PIP_MAIN_FOLDERS "\"${PROJECT_SOURCE_DIR}/${PIP_SRC_MAIN}/${F}\"") include_directories("${PIP_SRC_MAIN}/${F}") - gather_src("${PIP_SRC_MAIN}/${F}" CPP_LIB_MAIN HDRS PHDRS) + gather_src("${PIP_SRC_MAIN}/${F}" CPP_LIB_MAIN HDRS PHDRS) endforeach(F) # Crypt lib gather_src("${PIP_SRC_CRYPT}" CPP_LIB_CRYPT HDRS PHDRS) @@ -216,6 +216,9 @@ gather_src("${PIP_SRC_CONCURRENT_TEST}" CPP_CONCURRENT_TEST HDRS PHDRS) # Cloud lib gather_src("${PIP_SRC_CLOUD}" CPP_LIB_CLOUD HDRS PHDRS) +#Math test lib +gather_src("${PIP_SRC_MATH_TEST}" CPP_MATH_TEST HDRS PHDRS) + if(PIP_FREERTOS) add_definitions(-DPIP_FREERTOS) set(ICU OFF) @@ -605,13 +608,13 @@ if (NOT CROSSTOOLS) target_link_libraries(pip_concurrent_test gtest_main gmock_main pip_concurrent) add_test(NAME pip_concurrent_test COMMAND tests) add_custom_target(pip_concurrent_test_perform ALL COMMAND pip_concurrent_test) - endif() - if(MATH_TESTS) - add_executable(pip_math_test ${CPP_MATH_TEST}) - target_link_libraries(pip_math_test gtest_main gmock_main pip_math) - add_test(NAME pip_math_test COMMAND tests) - add_custom_target(pip_math_test_perform ALL COMMAND pip_math_test) - endif() + endif() + if(MATH_TESTS) + add_executable(pip_math_test ${CPP_MATH_TEST}) + target_link_libraries(pip_math_test gtest_main gmock_main PIP) + add_test(NAME pip_math_test COMMAND tests) + #add_custom_target(pip_math_test_perform ALL COMMAND pip_math_test) + endif() # Build cloud library if crypt enabled if(sodium_FOUND) diff --git a/lib/main/math/test/testpimathmatrix.cpp b/lib/main/math/test/testpimathmatrix.cpp index e69de29b..8dbef289 100644 --- a/lib/main/math/test/testpimathmatrix.cpp +++ b/lib/main/math/test/testpimathmatrix.cpp @@ -0,0 +1,936 @@ +#include "gtest/gtest.h" +#include "pimathmatrix.h" + +using namespace std; + +PIMathMatrix origMatr; + +TEST(PIMathMatrix_Test, identity) +{ + PIMathMatrix matrix; + int i; + double d; + bool a, b; + matrix = origMatr.identity(3, 3); + d = matrix.determinant(); + for(i = 0; i < 3; i++) + { + if(matrix[i][i] == 1.0) + { + b = true; + } + else + { + b = false; + break; + } + } + if(d == 1.0) + { + a = true; + } + else + { + a = false; + } + ASSERT_TRUE(a && b); +} + +TEST(PIMathMatrix_Test, matrixRow) +{ + PIMathMatrix matrix; + PIMathVector vector; + uint i; + bool b; + vector.resize(3, 3.0); + vector.fill(5.0); + matrix = origMatr.matrixRow(vector); + for(i = 0; i < vector.size(); i++) + { + if(matrix[0][i] == 5.0) + { + b = true; + } + else + { + b = false; + break; + } + } + ASSERT_TRUE(b); +} + +TEST(PIMathMatrix_Test, matrixCol) +{ + PIMathMatrix matrix; + PIMathVector vector; + uint i; + bool b; + vector.resize(3, 3.0); + vector.fill(5.0); + matrix = origMatr.matrixCol(vector); + for(i = 0; i < vector.size(); i++) + { + if(matrix[i][0] == 5.0) + { + b = true; + } + else + { + b = false; + break; + } + } + ASSERT_TRUE(b); +} + +TEST(PIMathMatrix_Test, setCol) +{ + PIMathMatrix matrix; + PIMathVector vector; + uint i; + bool b; + vector.resize(3, 3.0); + vector.fill(5.0); + matrix = origMatr.matrixCol(vector); + vector.fill(10.0); + matrix.setCol(0, vector); + for(i = 0; i < vector.size(); i++) + { + if(matrix[i][0] == 10.0) + { + b = true; + } + else + { + b = false; + break; + } + } + ASSERT_TRUE(b); +} + +TEST(PIMathMatrix_Test, setRow) +{ + PIMathMatrix matrix; + PIMathVector vector; + uint i; + bool b; + vector.resize(3, 3.0); + vector.fill(5.0); + matrix = origMatr.matrixRow(vector); + vector.fill(10.0); + matrix.setRow(0, vector); + for(i = 0; i < vector.size(); i++) + { + if(matrix[0][i] == 10.0) + { + b = true; + } + else + { + b = false; + break; + } + } + ASSERT_TRUE(b); +} + +TEST(PIMathMatrix_Test, swapCols) +{ + PIMathMatrix matrix1; + PIMathVector vector; + uint i1 = 0; uint i2 = 1; + double a1[3], a2[3], a3[3]; + double b1[3], b2[3], b3[3]; + bool b; + vector.resize(3, 3.0); + vector.at(0) = 3.0; + vector.at(1) = 6.0; + vector.at(2) = 8.0; + matrix1 = origMatr.identity(3, 3); + matrix1.setCol(0, vector); + vector.at(0) = 2.0; + vector.at(1) = 1.0; + vector.at(2) = 4.0; + matrix1.setCol(1, vector); + vector.at(0) = 6.0; + vector.at(1) = 2.0; + vector.at(2) = 5.0; + matrix1.setCol(2, vector); + for(int i = 0; i < 3; i++) + { + a1[i] = matrix1.element(i, 0); + a2[i] = matrix1.element(i, 1); + a3[i] = matrix1.element(i, 2); + } + matrix1.swapCols(i1, i2); + for(int i = 0; i < 3; i++) + { + b1[i] = matrix1.element(i, 0); + b2[i] = matrix1.element(i, 1); + b3[i] = matrix1.element(i, 2); + } + if((memcmp(a1, b2, sizeof(b1)) == 0) && (memcmp(a2, b1, sizeof(b1)) == 0) && (memcmp(a3, b3, sizeof(b1)) == 0)) + { + b = true; + } + else + { + b = false; + } + ASSERT_TRUE(b); +} + +TEST(PIMathMatrix_Test, swapRows) +{ + PIMathMatrix matrix1; + PIMathVector vector; + uint i1 = 0; uint i2 = 1; + double a1[3], a2[3], a3[3]; + double b1[3], b2[3], b3[3]; + bool b; + vector.resize(3, 3.0); + vector.at(0) = 3.0; + vector.at(1) = 6.0; + vector.at(2) = 8.0; + matrix1 = origMatr.identity(3, 3); + matrix1.setCol(0, vector); + vector.at(0) = 2.0; + vector.at(1) = 1.0; + vector.at(2) = 4.0; + matrix1.setCol(1, vector); + vector.at(0) = 6.0; + vector.at(1) = 2.0; + vector.at(2) = 5.0; + matrix1.setCol(2, vector); + for(int i = 0; i < 3; i++) + { + a1[i] = matrix1.element(0, i); + a2[i] = matrix1.element(1, i); + a3[i] = matrix1.element(2, i); + } + matrix1.swapRows(i1, i2); + for(int i = 0; i < 3; i++) + { + b1[i] = matrix1.element(0, i); + b2[i] = matrix1.element(1, i); + b3[i] = matrix1.element(2, i); + } + if((memcmp(a1, b2, sizeof(b1)) == 0) && (memcmp(a2, b1, sizeof(b1)) == 0) && (memcmp(a3, b3, sizeof(b1)) == 0)) + { + b = true; + } + else + { + b = false; + } + ASSERT_TRUE(b); +} +TEST(PIMathMatrix_Test, fill) +{ + PIMathMatrix matrix; + int i = 0; + int j = 0; + int k = 0; + bool b; + matrix = origMatr.identity(3, 3); + matrix.fill(5.0); + while(i < 9) + { + if(k < 3) + { + if(matrix.element(j,k) == 5.0) + { + b = true; + } + else + { + b = false; + break; + } + k++; + if(k == 3) + { + j++; + k = 0; + } + } + i++; + } + ASSERT_TRUE(b); +} + +TEST(PIMathMatrix_Test, isSquare) +{ + + PIMathMatrix matrix1; + PIMathMatrix matrix2; + bool b; + matrix1 = origMatr.identity(3,3); + matrix2 = origMatr.identity(4,3); + if((matrix1.isSquare() == true) && (matrix2.isSquare() == false)) + { + b = true; + } + else + { + b = false; + } + ASSERT_TRUE(b); +} + +TEST(PIMathMatrix_Test, isIdentity) +{ + PIMathMatrix matrix1; + PIMathMatrix matrix2; + bool b; + matrix1 = origMatr.identity(3,3); + matrix2 = origMatr.identity(3,3); + matrix2.fill(3.932); + if((matrix1.isIdentity() == true) && (matrix2.isIdentity() == false)) + { + b = true; + } + else + { + b = false; + } + ASSERT_TRUE(b); +} + +TEST(PIMathMatrix_Test, isNull) +{ + PIMathMatrix matrix1; + PIMathMatrix matrix2; + bool b; + matrix1 = origMatr.identity(3,3); + matrix2 = origMatr.identity(3,3); + matrix1.fill(0.0); + matrix2.fill(3.932); + if((matrix1.isNull() == true) && (matrix2.isNull() == false)) + { + b = true; + } + else + { + b = false; + } + ASSERT_TRUE(b); +} + +TEST(PIMathMatrix_Test, isValid) +{ + PIMathMatrix matrix1; + PIMathMatrix matrix2; + bool b; + matrix1 = origMatr.identity(3,3); + if((matrix1.isValid() == true) && (matrix2.isValid() == false)) + { + b = true; + } + else + { + b = false; + } + ASSERT_TRUE(b); +} + +TEST(PIMathMatrix_Test, operator_Assignment) +{ + PIMathMatrix matrix1; + PIMathMatrix matrix2; + int i = 0; + int j = 0; + int k = 0; + bool b; + matrix1 = origMatr.identity(3,3); + matrix2 = origMatr.identity(3,3); + matrix2.fill(6.72); + matrix1 = matrix2; + while(i < 9) + { + if(k < 3) + { + if(matrix1.element(j,k) == 6.72) + { + b = true; + } + else + { + b = false; + break; + } + k++; + if(k == 3) + { + j++; + k = 0; + } + } + i++; + } + ASSERT_TRUE(b); +} + +TEST(PIMathMatrix_Test, operator_Equal) +{ + PIMathMatrix matrix1; + PIMathMatrix matrix2; + PIMathMatrix matrix3; + PIMathVector vector; + bool b; + matrix1 = origMatr.identity(3,3); + matrix2 = origMatr.identity(3,3); + matrix3 = origMatr.identity(3,3); + vector.resize(3, 3.0); + vector.at(0) = 3.0; + vector.at(1) = 6.0; + vector.at(2) = 8.0; + matrix1.setCol(0, vector); + matrix2.setCol(0, vector); + matrix3.setCol(0, vector); + vector.at(0) = 2.0; + vector.at(1) = 1.0; + vector.at(2) = 4.0; + matrix1.setCol(1, vector); + matrix2.setCol(1, vector); + matrix3.setCol(1, vector); + vector.at(0) = 6.0; + vector.at(1) = 2.0; + vector.at(2) = 5.0; + matrix1.setCol(2, vector); + matrix2.setCol(2, vector); + vector.at(0) = 566.0; + vector.at(1) = 564.0; + vector.at(2) = 543.0; + matrix3.setCol(2, vector); + if(((matrix1 == matrix2) == true) && ((matrix1 == matrix3) == false)) + { + b = true; + } + else + { + b = false; + } + ASSERT_TRUE(b); +} + +TEST(PIMathMatrix_Test, operator_Not_Equal) +{ + PIMathMatrix matrix1; + PIMathMatrix matrix2; + PIMathMatrix matrix3; + PIMathVector vector; + bool b; + matrix1 = origMatr.identity(3,3); + matrix2 = origMatr.identity(3,3); + matrix3 = origMatr.identity(3,3); + vector.resize(3, 3.0); + vector.at(0) = 3.0; + vector.at(1) = 6.0; + vector.at(2) = 8.0; + matrix1.setCol(0, vector); + matrix2.setCol(0, vector); + matrix3.setCol(0, vector); + vector.at(0) = 2.0; + vector.at(1) = 1.0; + vector.at(2) = 4.0; + matrix1.setCol(1, vector); + matrix2.setCol(1, vector); + matrix3.setCol(1, vector); + vector.at(0) = 6.0; + vector.at(1) = 2.0; + vector.at(2) = 5.0; + matrix1.setCol(2, vector); + matrix2.setCol(2, vector); + vector.at(0) = 566.0; + vector.at(1) = 564.0; + vector.at(2) = 543.0; + matrix3.setCol(2, vector); + if(((matrix1 != matrix2) == false) && ((matrix1 != matrix3) == true)) + { + b = true; + } + else + { + b = false; + } + ASSERT_TRUE(b); +} + +TEST(PIMathMatrix_Test, operator_Addition_Aassignment) +{ + PIMathMatrix matrix1; + PIMathMatrix matrix2; + bool b; + int i = 0; + int j = 0; + int k = 0; + matrix1 = origMatr.identity(3,3); + matrix2 = origMatr.identity(3,3); + matrix2.fill(6.72); + matrix1.fill(1.0); + matrix1 += matrix2; + while(i < 9) + { + if(k < 3) + { + if(matrix1.element(j,k) == 7.72) + { + b = true; + } + else + { + b = false; + break; + } + k++; + if(k == 3) + { + j++; + k = 0; + } + } + i++; + } + ASSERT_TRUE(b); +} + +TEST(PIMathMatrix_Test, operator_Subtraction_Assignment) +{ + PIMathMatrix matrix1; + PIMathMatrix matrix2; + bool b; + int i = 0; + int j = 0; + int k = 0; + matrix1 = origMatr.identity(3,3); + matrix2 = origMatr.identity(3,3); + matrix2.fill(6.72); + matrix1.fill(1.0); + matrix1 -= matrix2; + while(i < 9) + { + if(k < 3) + { + if(matrix1.element(j,k) == -5.72) + { + b = true; + } + else + { + b = false; + break; + } + k++; + if(k == 3) + { + j++; + k = 0; + } + } + i++; + } + ASSERT_TRUE(b); +} + +TEST(PIMathMatrix_Test, operator_Multiplication_Assignment) +{ + PIMathMatrix matrix1; + bool b; + int i = 0; + int j = 0; + int k = 0; + matrix1 = origMatr.identity(3,3); + matrix1.fill(6.72); + matrix1 *= 2.0; + while(i < 9) + { + if(k < 3) + { + if(matrix1.element(j,k) == 13.44) + { + b = true; + } + else + { + b = false; + break; + } + k++; + if(k == 3) + { + j++; + k = 0; + } + } + i++; + } + ASSERT_TRUE(b); +} + +TEST(PIMathMatrix_Test, operator_Division_Assignment) +{ + PIMathMatrix matrix1; + bool b; + int i = 0; + int j = 0; + int k = 0; + matrix1 = origMatr.identity(3,3); + matrix1.fill(6.72); + matrix1 /= 2.0; + while(i < 9) + { + if(k < 3) + { + if(matrix1.element(j,k) == 3.36) + { + b = true; + } + else + { + b = false; + break; + } + k++; + if(k == 3) + { + j++; + k = 0; + } + } + i++; + } + ASSERT_TRUE(b); +} + +TEST(PIMathMatrix_Test, operator_Addition) +{ + PIMathMatrix matrix1; + PIMathMatrix matrix2; + bool b; + int i = 0; + int j = 0; + int k = 0; + matrix1 = origMatr.identity(3,3); + matrix2 = origMatr.identity(3,3); + matrix1.fill(6.72); + matrix2.fill(8.28); + while(i < 9) + { + if(k < 3) + { + if((matrix1+matrix2).element(j,k) == 15.0) + { + b = true; + } + else + { + b = false; + break; + } + k++; + if(k == 3) + { + j++; + k = 0; + } + } + i++; + } + ASSERT_TRUE(b); +} + +TEST(PIMathMatrix_Test, operator_Subtraction) +{ + PIMathMatrix matrix1; + PIMathMatrix matrix2; + bool b; + matrix1 = origMatr.identity(3, 3); + matrix2 = origMatr.identity(3, 3); + origMatr.fill(8.0); + matrix1.fill(8.28); + origMatr = origMatr - matrix1; + matrix2.fill(-0.28); + if(origMatr == matrix2) + { + b = true; + } + else + { + b = false; + } + ASSERT_TRUE(b); +} + +TEST(PIMathMatrix_Test, operator_Multiplication) +{ + PIMathMatrix matrix1; + PIMathMatrix matrix2; + bool b; + int i = 0; + int j = 0; + int k = 0; + matrix1 = origMatr.identity(3,3); + matrix2 = origMatr.identity(3,3); + matrix1.fill(6.72); + matrix2 = matrix1*4.0; + while(i < 9) + { + if(k < 3) + { + if(matrix2.element(j,k) == 26.88) + { + b = true; + } + else + { + b = false; + break; + } + k++; + if(k == 3) + { + j++; + k = 0; + } + } + i++; + } + ASSERT_TRUE(b); +} +TEST(PIMathMatrix_Test, operator_Division) +{ + PIMathMatrix matrix1; + PIMathMatrix matrix2; + bool b; + int i = 0; + int j = 0; + int k = 0; + matrix1 = origMatr.identity(3,3); + matrix2 = origMatr.identity(3,3); + matrix1.fill(6.72); + matrix2 = matrix1/4.0; + while(i < 9) + { + if(k < 3) + { + if(matrix2.element(j,k) == 1.68) + { + b = true; + } + else + { + b = false; + break; + } + k++; + if(k == 3) + { + j++; + k = 0; + } + } + i++; + } + ASSERT_TRUE(b); +} + +TEST(PIMathMatrix_Test, determinant) +{ + double d; + double i = 59.0; + PIMathMatrix matrix; + PIMathVector vector; + vector.resize(3, 3.0); + vector.at(0) = 3.0; + vector.at(1) = 6.0; + vector.at(2) = 8.0; + matrix = origMatr.identity(3, 3); + matrix.setCol(0, vector); + vector.at(0) = 2.0; + vector.at(1) = 1.0; + vector.at(2) = 4.0; + matrix.setCol(1, vector); + vector.at(0) = 6.0; + vector.at(1) = 2.0; + vector.at(2) = 5.0; + matrix.setCol(2, vector); + d = matrix.determinant(); + ASSERT_DOUBLE_EQ(d, i); +} + +TEST(PIMathMatrix_Test, trace) +{ + double t; + double i = 9.0; + PIMathMatrix matrix; + PIMathVector vector; + vector.resize(3, 3.0); + vector.at(0) = 3.0; + vector.at(1) = 6.0; + vector.at(2) = 8.0; + matrix = origMatr.identity(3, 3); + matrix.setCol(0, vector); + vector.at(0) = 2.0; + vector.at(1) = 1.0; + vector.at(2) = 4.0; + matrix.setCol(1, vector); + vector.at(0) = 6.0; + vector.at(1) = 2.0; + vector.at(2) = 5.0; + matrix.setCol(2, vector); + t = matrix.trace(); + ASSERT_DOUBLE_EQ(t, i); +} + +TEST(PIMathMatrix_Test, toUpperTriangular) +{ + double d1, d2 = 1; + int i; + PIMathMatrix matrix; + PIMathVector vector; + vector.resize(3, 3.0); + vector.at(0) = 3.0; + vector.at(1) = 6.0; + vector.at(2) = 8.0; + matrix = origMatr.identity(3, 3); + matrix.setCol(0, vector); + vector.at(0) = 2.0; + vector.at(1) = 1.0; + vector.at(2) = 4.0; + matrix.setCol(1, vector); + vector.at(0) = 6.0; + vector.at(1) = 2.0; + vector.at(2) = 5.0; + matrix.setCol(2, vector); + d1 = matrix.determinant(); + matrix.toUpperTriangular(); + for(i = 0; i < 3; i++) + { + d2 = d2 * matrix.element(i, i); + } + ASSERT_DOUBLE_EQ(d1, d2); +} + +TEST(PIMathMatrix_Test, invert) +{ + double d1, d2; + bool b; + PIMathMatrix matrix1; + PIMathMatrix matrix2; + PIMathMatrix matrix3; + PIMathMatrix matrix4; + PIMathVector vector; + vector.resize(3, 3.0); + vector.at(0) = 3.0; + vector.at(1) = 6.0; + vector.at(2) = 8.0; + matrix1 = origMatr.identity(3, 3); + matrix1.setCol(0, vector); + vector.at(0) = 2.0; + vector.at(1) = 1.0; + vector.at(2) = 4.0; + matrix1.setCol(1, vector); + vector.at(0) = 6.0; + vector.at(1) = 2.0; + vector.at(2) = 5.0; + matrix1.setCol(2, vector); + d1 = matrix1.determinant(); + matrix2 = matrix1; + matrix2.invert(); + d2 = matrix2.determinant(); + matrix3 = origMatr.identity(3, 3); + matrix4 = origMatr.identity(3, 3); + matrix4.invert(); + if((matrix3 == matrix4) && (round((1/d1)*10000)/10000 == round(d2*10000)/10000)) + { + b = true; + } + else + { + b = false; + } + ASSERT_TRUE(b); +} + +TEST(PIMathMatrix_Test, inverted) +{ + double d1, d2; + bool b; + PIMathMatrix matrix1; + PIMathMatrix matrix2; + PIMathMatrix matrix3; + PIMathMatrix matrix4; + PIMathVector vector; + vector.resize(3, 3.0); + vector.at(0) = 3.0; + vector.at(1) = 6.0; + vector.at(2) = 8.0; + matrix1 = origMatr.identity(3, 3); + matrix1.setCol(0, vector); + vector.at(0) = 2.0; + vector.at(1) = 1.0; + vector.at(2) = 4.0; + matrix1.setCol(1, vector); + vector.at(0) = 6.0; + vector.at(1) = 2.0; + vector.at(2) = 5.0; + matrix1.setCol(2, vector); + d1 = matrix1.determinant(); + matrix2 = matrix1; + matrix1 = matrix2.invert(); + d2 = matrix1.determinant(); + matrix3 = origMatr.identity(3, 3); + matrix4 = origMatr.identity(3, 3); + matrix3 = matrix4.invert(); + if((matrix3 == matrix4) && (round((1/d1)*10000)/10000 == round(d2*10000)/10000)) + { + b = true; + } + else + { + b = false; + } + ASSERT_TRUE(b); +} + +TEST(PIMathMatrix_Test, transposed) +{ + double d1, d2; + bool b; + PIMathMatrix matrix1; + PIMathMatrix matrix2; + PIMathMatrix matrix3; + PIMathVector vector; + vector.resize(3, 3.0); + vector.at(0) = 3.0; + vector.at(1) = 6.0; + vector.at(2) = 8.0; + matrix1 = origMatr.identity(3, 3); + matrix1.setCol(0, vector); + vector.at(0) = 2.0; + vector.at(1) = 1.0; + vector.at(2) = 4.0; + matrix1.setCol(1, vector); + vector.at(0) = 6.0; + vector.at(1) = 2.0; + vector.at(2) = 5.0; + matrix1.setCol(2, vector); + d1 = matrix1.determinant(); + matrix2 = matrix1.transposed(); + d2 = matrix2.determinant(); + matrix3 = matrix2.transposed(); + if((d1 == d2) && (matrix1 == matrix3)) + { + b = true; + } + else + { + b = false; + } + ASSERT_TRUE(b); +} + +