212 lines
7.0 KiB
C++
212 lines
7.0 KiB
C++
// unit tests for public member functions of the Error class
|
|
|
|
#include "error.h"
|
|
#include "info.h"
|
|
#include "lammps.h"
|
|
#include "output.h"
|
|
#include "thermo.h"
|
|
|
|
#include "../testing/core.h"
|
|
#include "gmock/gmock.h"
|
|
#include "gtest/gtest.h"
|
|
|
|
#include <string>
|
|
|
|
// whether to print verbose output (i.e. not capturing LAMMPS screen output).
|
|
bool verbose = false;
|
|
|
|
namespace LAMMPS_NS {
|
|
using ::testing::ContainsRegex;
|
|
using ::testing::StrEq;
|
|
|
|
class ErrorTest : public LAMMPSTest {
|
|
protected:
|
|
Error *error;
|
|
Thermo *thermo;
|
|
|
|
void SetUp() override
|
|
{
|
|
testbinary = "ErrorClass";
|
|
LAMMPSTest::SetUp();
|
|
error = lmp->error;
|
|
thermo = lmp->output->thermo;
|
|
}
|
|
};
|
|
|
|
TEST_F(ErrorTest, warning)
|
|
{
|
|
// standard warning
|
|
auto output = CAPTURE_OUTPUT([&] {
|
|
error->warning(FLERR, "one warning");
|
|
});
|
|
ASSERT_THAT(output, ContainsRegex("WARNING: one warning .*test_error_class.cpp:.*"));
|
|
ASSERT_THAT(error->get_maxwarn(), 100);
|
|
|
|
// warnings disabled
|
|
HIDE_OUTPUT([&] {
|
|
command("thermo_modify warn ignore");
|
|
});
|
|
output = CAPTURE_OUTPUT([&] {
|
|
error->warning(FLERR, "one warning");
|
|
});
|
|
ASSERT_THAT(error->get_maxwarn(), -1);
|
|
|
|
BEGIN_HIDE_OUTPUT();
|
|
command("thermo_modify warn 2");
|
|
error->warning(FLERR, "one warning");
|
|
error->warning(FLERR, "one warning");
|
|
error->warning(FLERR, "one warning");
|
|
END_HIDE_OUTPUT();
|
|
ASSERT_THAT(error->get_maxwarn(), 2);
|
|
ASSERT_THAT(error->get_numwarn(), 5);
|
|
|
|
output = CAPTURE_OUTPUT([&] {
|
|
thermo->lost_check();
|
|
});
|
|
ASSERT_THAT(output, ContainsRegex("WARNING: Too many warnings: 5 vs 2. All future.*"));
|
|
|
|
output = CAPTURE_OUTPUT([&] {
|
|
error->warning(FLERR, "one warning");
|
|
});
|
|
|
|
ASSERT_EQ(output, "");
|
|
|
|
BEGIN_HIDE_OUTPUT();
|
|
command("thermo_modify warn reset");
|
|
thermo->lost_check();
|
|
error->warning(FLERR, "one warning");
|
|
END_HIDE_OUTPUT();
|
|
ASSERT_THAT(error->get_maxwarn(), 2);
|
|
ASSERT_THAT(error->get_numwarn(), 1);
|
|
|
|
output = CAPTURE_OUTPUT([&] {
|
|
error->warning(FLERR, "one warning");
|
|
});
|
|
ASSERT_THAT(output, ContainsRegex("WARNING: one warning.*"));
|
|
|
|
BEGIN_HIDE_OUTPUT();
|
|
command("thermo_modify warn default");
|
|
thermo->lost_check();
|
|
error->warning(FLERR, "one warning");
|
|
END_HIDE_OUTPUT();
|
|
ASSERT_THAT(error->get_maxwarn(), 100);
|
|
ASSERT_THAT(error->get_numwarn(), 1);
|
|
|
|
BEGIN_HIDE_OUTPUT();
|
|
command("thermo_modify warn always");
|
|
thermo->lost_check();
|
|
error->warning(FLERR, "one warning");
|
|
END_HIDE_OUTPUT();
|
|
ASSERT_THAT(error->get_maxwarn(), 0);
|
|
ASSERT_THAT(error->get_numwarn(), 2);
|
|
};
|
|
|
|
TEST_F(ErrorTest, one)
|
|
{
|
|
bool caught = false;
|
|
try {
|
|
BEGIN_HIDE_OUTPUT();
|
|
error->one(FLERR, "one error");
|
|
} catch (LAMMPSAbortException &e) {
|
|
END_HIDE_OUTPUT();
|
|
EXPECT_THAT(e.what(), ContainsRegex("ERROR on proc 0: one error.*test_error_class.cpp"));
|
|
caught = true;
|
|
} catch (std::exception &e) {
|
|
END_HIDE_OUTPUT();
|
|
GTEST_FAIL() << "Incorrect exception\n";
|
|
}
|
|
ASSERT_TRUE(caught);
|
|
};
|
|
|
|
TEST_F(ErrorTest, all)
|
|
{
|
|
bool caught = false;
|
|
try {
|
|
BEGIN_HIDE_OUTPUT();
|
|
error->all(FLERR, "one error");
|
|
} catch (LAMMPSException &e) {
|
|
END_HIDE_OUTPUT();
|
|
EXPECT_THAT(e.what(), ContainsRegex("ERROR: one error.*test_error_class.cpp"));
|
|
caught = true;
|
|
} catch (std::exception &e) {
|
|
END_HIDE_OUTPUT();
|
|
GTEST_FAIL() << "Incorrect exception\n";
|
|
}
|
|
ASSERT_TRUE(caught);
|
|
};
|
|
|
|
TEST_F(ErrorTest, errorpointer)
|
|
{
|
|
lmp->input->line = utils::strdup("some command line with no blanks");
|
|
lmp->input->parse();
|
|
EXPECT_THAT(utils::point_to_error(lmp->input, Error::NOPOINTER),
|
|
StrEq("Last input line: some command line with no blanks\n"));
|
|
EXPECT_THAT(utils::point_to_error(lmp->input, -1),
|
|
StrEq("Last input line: some command line with no blanks \n"
|
|
" ^^^^\n"));
|
|
EXPECT_THAT(utils::point_to_error(lmp->input, 0),
|
|
StrEq("Last input line: some command line with no blanks \n"
|
|
" ^^^^^^^\n"));
|
|
EXPECT_THAT(utils::point_to_error(lmp->input, 1),
|
|
StrEq("Last input line: some command line with no blanks \n"
|
|
" ^^^^\n"));
|
|
EXPECT_THAT(utils::point_to_error(lmp->input, 2),
|
|
StrEq("Last input line: some command line with no blanks \n"
|
|
" ^^^^\n"));
|
|
EXPECT_THAT(utils::point_to_error(lmp->input, 3),
|
|
StrEq("Last input line: some command line with no blanks \n"
|
|
" ^^\n"));
|
|
EXPECT_THAT(utils::point_to_error(lmp->input, 4),
|
|
StrEq("Last input line: some command line with no blanks \n"
|
|
" ^^^^^^\n"));
|
|
|
|
delete[] lmp->input->line;
|
|
lmp->input->line = utils::strdup("some command line 'with some blanks'");
|
|
lmp->input->parse();
|
|
EXPECT_THAT(utils::point_to_error(nullptr,0), StrEq(""));
|
|
EXPECT_THAT(utils::point_to_error(lmp->input, Error::NOPOINTER),
|
|
StrEq("Last input line: some command line 'with some blanks'\n"));
|
|
EXPECT_THAT(utils::point_to_error(lmp->input, -1),
|
|
StrEq("Last input line: some command line 'with some blanks'\n"
|
|
"--> parsed line: some command line \"with some blanks\" \n"
|
|
" ^^^^\n"));
|
|
EXPECT_THAT(utils::point_to_error(lmp->input, 0),
|
|
StrEq("Last input line: some command line 'with some blanks'\n"
|
|
"--> parsed line: some command line \"with some blanks\" \n"
|
|
" ^^^^^^^\n"));
|
|
EXPECT_THAT(utils::point_to_error(lmp->input, 1),
|
|
StrEq("Last input line: some command line 'with some blanks'\n"
|
|
"--> parsed line: some command line \"with some blanks\" \n"
|
|
" ^^^^\n"));
|
|
EXPECT_THAT(utils::point_to_error(lmp->input, 2),
|
|
StrEq("Last input line: some command line 'with some blanks'\n"
|
|
"--> parsed line: some command line \"with some blanks\" \n"
|
|
" ^^^^^^^^^^^^^^^^^^\n"));
|
|
delete[] lmp->input->line;
|
|
lmp->input->line = nullptr;
|
|
};
|
|
|
|
} // namespace LAMMPS_NS
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
MPI_Init(&argc, &argv);
|
|
::testing::InitGoogleMock(&argc, argv);
|
|
|
|
// handle arguments passed via environment variable
|
|
if (const char *var = getenv("TEST_ARGS")) {
|
|
std::vector<std::string> env = LAMMPS_NS::utils::split_words(var);
|
|
for (auto arg : env) {
|
|
if (arg == "-v") {
|
|
verbose = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ((argc > 1) && (strcmp(argv[1], "-v") == 0)) verbose = true;
|
|
|
|
int rv = RUN_ALL_TESTS();
|
|
MPI_Finalize();
|
|
return rv;
|
|
}
|