ICODE-ADC/lammps
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

reformat unittest sources with clang-format

Browse Source
This commit is contained in:
Axel Kohlmeyer
2020-11-18 18:27:20 -05:00
committed by Richard Berger
parent a8b60848c3
commit 569a000e6b
32 changed files with 2022 additions and 2071 deletions
Download Patch File Download Diff File Expand all files Collapse all files

338
unittest/commands/test_reset_ids.cpp
View File

@ -480,182 +480,182 @@ TEST_F(ResetIDsTest, TopologyData)
ASSERT_EQ(lmp->atom->natoms, 23); ASSERT_EQ(lmp->atom->natoms, 23);
ASSERT_EQ(lmp->atom->map_tag_max, 26); ASSERT_EQ(lmp->atom->map_tag_max, 26);
auto num_bond = lmp->atom->num_bond; auto num_bond = lmp->atom->num_bond;
auto num_angle = lmp->atom->num_angle; auto num_angle = lmp->atom->num_angle;
auto num_dihedral = lmp->atom->num_dihedral; auto num_dihedral = lmp->atom->num_dihedral;
auto num_improper = lmp->atom->num_improper; auto num_improper = lmp->atom->num_improper;
auto bond_atom = lmp->atom->bond_atom; auto bond_atom = lmp->atom->bond_atom;
auto angle_atom1 = lmp->atom->angle_atom1; auto angle_atom1 = lmp->atom->angle_atom1;
auto angle_atom2 = lmp->atom->angle_atom2; auto angle_atom2 = lmp->atom->angle_atom2;
auto angle_atom3 = lmp->atom->angle_atom3; auto angle_atom3 = lmp->atom->angle_atom3;
ASSERT_EQ(num_bond[GETIDX(1)],2); ASSERT_EQ(num_bond[GETIDX(1)], 2);
ASSERT_EQ(bond_atom[GETIDX(1)][0],2); ASSERT_EQ(bond_atom[GETIDX(1)][0], 2);
ASSERT_EQ(bond_atom[GETIDX(1)][1],3); ASSERT_EQ(bond_atom[GETIDX(1)][1], 3);
ASSERT_EQ(num_bond[GETIDX(2)],0); ASSERT_EQ(num_bond[GETIDX(2)], 0);
ASSERT_EQ(num_bond[GETIDX(3)],3); ASSERT_EQ(num_bond[GETIDX(3)], 3);
ASSERT_EQ(bond_atom[GETIDX(3)][0],4); ASSERT_EQ(bond_atom[GETIDX(3)][0], 4);
ASSERT_EQ(bond_atom[GETIDX(3)][1],5); ASSERT_EQ(bond_atom[GETIDX(3)][1], 5);
ASSERT_EQ(bond_atom[GETIDX(3)][2],6); ASSERT_EQ(bond_atom[GETIDX(3)][2], 6);
ASSERT_EQ(num_bond[GETIDX(4)],0); ASSERT_EQ(num_bond[GETIDX(4)], 0);
ASSERT_EQ(num_bond[GETIDX(5)],0); ASSERT_EQ(num_bond[GETIDX(5)], 0);
ASSERT_EQ(num_bond[GETIDX(6)],2); ASSERT_EQ(num_bond[GETIDX(6)], 2);
ASSERT_EQ(bond_atom[GETIDX(6)][0],8); ASSERT_EQ(bond_atom[GETIDX(6)][0], 8);
ASSERT_EQ(bond_atom[GETIDX(6)][1],7); ASSERT_EQ(bond_atom[GETIDX(6)][1], 7);
ASSERT_EQ(num_bond[GETIDX(7)],0); ASSERT_EQ(num_bond[GETIDX(7)], 0);
ASSERT_EQ(num_bond[GETIDX(8)],2); ASSERT_EQ(num_bond[GETIDX(8)], 2);
ASSERT_EQ(bond_atom[GETIDX(8)][0],9); ASSERT_EQ(bond_atom[GETIDX(8)][0], 9);
ASSERT_EQ(bond_atom[GETIDX(8)][1],10); ASSERT_EQ(bond_atom[GETIDX(8)][1], 10);
ASSERT_EQ(num_bond[GETIDX(9)],0); ASSERT_EQ(num_bond[GETIDX(9)], 0);
ASSERT_EQ(num_bond[GETIDX(10)],3); ASSERT_EQ(num_bond[GETIDX(10)], 3);
ASSERT_EQ(bond_atom[GETIDX(10)][0],11); ASSERT_EQ(bond_atom[GETIDX(10)][0], 11);
ASSERT_EQ(bond_atom[GETIDX(10)][1],12); ASSERT_EQ(bond_atom[GETIDX(10)][1], 12);
ASSERT_EQ(bond_atom[GETIDX(10)][2],16); ASSERT_EQ(bond_atom[GETIDX(10)][2], 16);
ASSERT_EQ(num_bond[GETIDX(11)],0); ASSERT_EQ(num_bond[GETIDX(11)], 0);
ASSERT_EQ(num_bond[GETIDX(12)],3); ASSERT_EQ(num_bond[GETIDX(12)], 3);
ASSERT_EQ(bond_atom[GETIDX(12)][0],13); ASSERT_EQ(bond_atom[GETIDX(12)][0], 13);
ASSERT_EQ(bond_atom[GETIDX(12)][1],14); ASSERT_EQ(bond_atom[GETIDX(12)][1], 14);
ASSERT_EQ(bond_atom[GETIDX(12)][2],15); ASSERT_EQ(bond_atom[GETIDX(12)][2], 15);
ASSERT_EQ(num_bond[GETIDX(13)],0); ASSERT_EQ(num_bond[GETIDX(13)], 0);
ASSERT_EQ(num_bond[GETIDX(14)],0); ASSERT_EQ(num_bond[GETIDX(14)], 0);
ASSERT_EQ(num_bond[GETIDX(15)],0); ASSERT_EQ(num_bond[GETIDX(15)], 0);
ASSERT_EQ(num_bond[GETIDX(16)],1); ASSERT_EQ(num_bond[GETIDX(16)], 1);
ASSERT_EQ(bond_atom[GETIDX(16)][0],17); ASSERT_EQ(bond_atom[GETIDX(16)][0], 17);
ASSERT_EQ(num_bond[GETIDX(17)],0); ASSERT_EQ(num_bond[GETIDX(17)], 0);
ASSERT_EQ(num_bond[GETIDX(18)],2); ASSERT_EQ(num_bond[GETIDX(18)], 2);
ASSERT_EQ(bond_atom[GETIDX(18)][0],19); ASSERT_EQ(bond_atom[GETIDX(18)][0], 19);
ASSERT_EQ(bond_atom[GETIDX(18)][1],20); ASSERT_EQ(bond_atom[GETIDX(18)][1], 20);
ASSERT_EQ(num_bond[GETIDX(19)],0); ASSERT_EQ(num_bond[GETIDX(19)], 0);
ASSERT_EQ(num_bond[GETIDX(20)],0); ASSERT_EQ(num_bond[GETIDX(20)], 0);
ASSERT_EQ(num_bond[GETIDX(24)],2); ASSERT_EQ(num_bond[GETIDX(24)], 2);
ASSERT_EQ(bond_atom[GETIDX(24)][0],25); ASSERT_EQ(bond_atom[GETIDX(24)][0], 25);
ASSERT_EQ(bond_atom[GETIDX(24)][1],26); ASSERT_EQ(bond_atom[GETIDX(24)][1], 26);
ASSERT_EQ(num_bond[GETIDX(25)],0); ASSERT_EQ(num_bond[GETIDX(25)], 0);
ASSERT_EQ(num_bond[GETIDX(26)],0); ASSERT_EQ(num_bond[GETIDX(26)], 0);
ASSERT_EQ(num_angle[GETIDX(1)],1); ASSERT_EQ(num_angle[GETIDX(1)], 1);
ASSERT_EQ(angle_atom1[GETIDX(1)][0],2); ASSERT_EQ(angle_atom1[GETIDX(1)][0], 2);
ASSERT_EQ(angle_atom2[GETIDX(1)][0],1); ASSERT_EQ(angle_atom2[GETIDX(1)][0], 1);
ASSERT_EQ(angle_atom3[GETIDX(1)][0],3); ASSERT_EQ(angle_atom3[GETIDX(1)][0], 3);
ASSERT_EQ(num_angle[GETIDX(2)],0); ASSERT_EQ(num_angle[GETIDX(2)], 0);
ASSERT_EQ(num_angle[GETIDX(3)],6); ASSERT_EQ(num_angle[GETIDX(3)], 6);
ASSERT_EQ(angle_atom1[GETIDX(3)][0],1); ASSERT_EQ(angle_atom1[GETIDX(3)][0], 1);
ASSERT_EQ(angle_atom2[GETIDX(3)][0],3); ASSERT_EQ(angle_atom2[GETIDX(3)][0], 3);
ASSERT_EQ(angle_atom3[GETIDX(3)][0],5); ASSERT_EQ(angle_atom3[GETIDX(3)][0], 5);
ASSERT_EQ(angle_atom1[GETIDX(3)][1],1); ASSERT_EQ(angle_atom1[GETIDX(3)][1], 1);
ASSERT_EQ(angle_atom2[GETIDX(3)][1],3); ASSERT_EQ(angle_atom2[GETIDX(3)][1], 3);
ASSERT_EQ(angle_atom3[GETIDX(3)][1],4); ASSERT_EQ(angle_atom3[GETIDX(3)][1], 4);
ASSERT_EQ(angle_atom1[GETIDX(3)][2],1); ASSERT_EQ(angle_atom1[GETIDX(3)][2], 1);
ASSERT_EQ(angle_atom2[GETIDX(3)][2],3); ASSERT_EQ(angle_atom2[GETIDX(3)][2], 3);
ASSERT_EQ(angle_atom3[GETIDX(3)][2],6); ASSERT_EQ(angle_atom3[GETIDX(3)][2], 6);
ASSERT_EQ(angle_atom1[GETIDX(3)][3],4); ASSERT_EQ(angle_atom1[GETIDX(3)][3], 4);
ASSERT_EQ(angle_atom2[GETIDX(3)][3],3); ASSERT_EQ(angle_atom2[GETIDX(3)][3], 3);
ASSERT_EQ(angle_atom3[GETIDX(3)][3],5); ASSERT_EQ(angle_atom3[GETIDX(3)][3], 5);
ASSERT_EQ(angle_atom1[GETIDX(3)][4],5); ASSERT_EQ(angle_atom1[GETIDX(3)][4], 5);
ASSERT_EQ(angle_atom2[GETIDX(3)][4],3); ASSERT_EQ(angle_atom2[GETIDX(3)][4], 3);
ASSERT_EQ(angle_atom3[GETIDX(3)][4],6); ASSERT_EQ(angle_atom3[GETIDX(3)][4], 6);
ASSERT_EQ(num_angle[GETIDX(18)],1); ASSERT_EQ(num_angle[GETIDX(18)], 1);
ASSERT_EQ(angle_atom1[GETIDX(18)][0],19); ASSERT_EQ(angle_atom1[GETIDX(18)][0], 19);
ASSERT_EQ(angle_atom2[GETIDX(18)][0],18); ASSERT_EQ(angle_atom2[GETIDX(18)][0], 18);
ASSERT_EQ(angle_atom3[GETIDX(18)][0],20); ASSERT_EQ(angle_atom3[GETIDX(18)][0], 20);
ASSERT_EQ(num_angle[GETIDX(24)],1); ASSERT_EQ(num_angle[GETIDX(24)], 1);
ASSERT_EQ(angle_atom1[GETIDX(24)][0],25); ASSERT_EQ(angle_atom1[GETIDX(24)][0], 25);
ASSERT_EQ(angle_atom2[GETIDX(24)][0],24); ASSERT_EQ(angle_atom2[GETIDX(24)][0], 24);
ASSERT_EQ(angle_atom3[GETIDX(24)][0],26); ASSERT_EQ(angle_atom3[GETIDX(24)][0], 26);
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
lmp->input->one("reset_atom_ids sort yes"); lmp->input->one("reset_atom_ids sort yes");
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
num_bond = lmp->atom->num_bond; num_bond = lmp->atom->num_bond;
num_angle = lmp->atom->num_angle; num_angle = lmp->atom->num_angle;
num_dihedral = lmp->atom->num_dihedral; num_dihedral = lmp->atom->num_dihedral;
num_improper = lmp->atom->num_improper; num_improper = lmp->atom->num_improper;
bond_atom = lmp->atom->bond_atom; bond_atom = lmp->atom->bond_atom;
angle_atom1 = lmp->atom->angle_atom1; angle_atom1 = lmp->atom->angle_atom1;
angle_atom2 = lmp->atom->angle_atom2; angle_atom2 = lmp->atom->angle_atom2;
angle_atom3 = lmp->atom->angle_atom3; angle_atom3 = lmp->atom->angle_atom3;
ASSERT_EQ(num_bond[GETIDX(1)],2); ASSERT_EQ(num_bond[GETIDX(1)], 2);
ASSERT_EQ(bond_atom[GETIDX(1)][0],3); ASSERT_EQ(bond_atom[GETIDX(1)][0], 3);
ASSERT_EQ(bond_atom[GETIDX(1)][1],2); ASSERT_EQ(bond_atom[GETIDX(1)][1], 2);
ASSERT_EQ(num_bond[GETIDX(2)],0); ASSERT_EQ(num_bond[GETIDX(2)], 0);
ASSERT_EQ(num_bond[GETIDX(3)],2); ASSERT_EQ(num_bond[GETIDX(3)], 2);
ASSERT_EQ(bond_atom[GETIDX(3)][0],16); ASSERT_EQ(bond_atom[GETIDX(3)][0], 16);
ASSERT_EQ(bond_atom[GETIDX(3)][1],5); ASSERT_EQ(bond_atom[GETIDX(3)][1], 5);
ASSERT_EQ(num_bond[GETIDX(4)],0); ASSERT_EQ(num_bond[GETIDX(4)], 0);
ASSERT_EQ(num_bond[GETIDX(5)],3); ASSERT_EQ(num_bond[GETIDX(5)], 3);
ASSERT_EQ(bond_atom[GETIDX(5)][0],4); ASSERT_EQ(bond_atom[GETIDX(5)][0], 4);
ASSERT_EQ(bond_atom[GETIDX(5)][1],8); ASSERT_EQ(bond_atom[GETIDX(5)][1], 8);
ASSERT_EQ(bond_atom[GETIDX(5)][2],18); ASSERT_EQ(bond_atom[GETIDX(5)][2], 18);
ASSERT_EQ(num_bond[GETIDX(6)],0); ASSERT_EQ(num_bond[GETIDX(6)], 0);
ASSERT_EQ(num_bond[GETIDX(7)],0); ASSERT_EQ(num_bond[GETIDX(7)], 0);
ASSERT_EQ(num_bond[GETIDX(8)],3); ASSERT_EQ(num_bond[GETIDX(8)], 3);
ASSERT_EQ(bond_atom[GETIDX(8)][0],9); ASSERT_EQ(bond_atom[GETIDX(8)][0], 9);
ASSERT_EQ(bond_atom[GETIDX(8)][1],6); ASSERT_EQ(bond_atom[GETIDX(8)][1], 6);
ASSERT_EQ(bond_atom[GETIDX(8)][2],7); ASSERT_EQ(bond_atom[GETIDX(8)][2], 7);
ASSERT_EQ(num_bond[GETIDX(9)],0); ASSERT_EQ(num_bond[GETIDX(9)], 0);
ASSERT_EQ(num_bond[GETIDX(10)],0); ASSERT_EQ(num_bond[GETIDX(10)], 0);
ASSERT_EQ(num_bond[GETIDX(11)],3); ASSERT_EQ(num_bond[GETIDX(11)], 3);
ASSERT_EQ(bond_atom[GETIDX(11)][0],10); ASSERT_EQ(bond_atom[GETIDX(11)][0], 10);
ASSERT_EQ(bond_atom[GETIDX(11)][1],19); ASSERT_EQ(bond_atom[GETIDX(11)][1], 19);
ASSERT_EQ(bond_atom[GETIDX(11)][2],1); ASSERT_EQ(bond_atom[GETIDX(11)][2], 1);
ASSERT_EQ(num_bond[GETIDX(12)],0); ASSERT_EQ(num_bond[GETIDX(12)], 0);
ASSERT_EQ(num_bond[GETIDX(13)],0); ASSERT_EQ(num_bond[GETIDX(13)], 0);
ASSERT_EQ(num_bond[GETIDX(14)],2); ASSERT_EQ(num_bond[GETIDX(14)], 2);
ASSERT_EQ(bond_atom[GETIDX(14)][0],13); ASSERT_EQ(bond_atom[GETIDX(14)][0], 13);
ASSERT_EQ(bond_atom[GETIDX(14)][1],15); ASSERT_EQ(bond_atom[GETIDX(14)][1], 15);
ASSERT_EQ(num_bond[GETIDX(15)],0); ASSERT_EQ(num_bond[GETIDX(15)], 0);
ASSERT_EQ(num_bond[GETIDX(16)],0); ASSERT_EQ(num_bond[GETIDX(16)], 0);
ASSERT_EQ(num_bond[GETIDX(17)],0); ASSERT_EQ(num_bond[GETIDX(17)], 0);
ASSERT_EQ(num_bond[GETIDX(18)],1); ASSERT_EQ(num_bond[GETIDX(18)], 1);
ASSERT_EQ(bond_atom[GETIDX(18)][0],17); ASSERT_EQ(bond_atom[GETIDX(18)][0], 17);
ASSERT_EQ(num_bond[GETIDX(19)],0); ASSERT_EQ(num_bond[GETIDX(19)], 0);
ASSERT_EQ(num_bond[GETIDX(20)],2); ASSERT_EQ(num_bond[GETIDX(20)], 2);
ASSERT_EQ(bond_atom[GETIDX(20)][0],12); ASSERT_EQ(bond_atom[GETIDX(20)][0], 12);
ASSERT_EQ(bond_atom[GETIDX(20)][1],11); ASSERT_EQ(bond_atom[GETIDX(20)][1], 11);
ASSERT_EQ(num_bond[GETIDX(21)],0); ASSERT_EQ(num_bond[GETIDX(21)], 0);
ASSERT_EQ(num_bond[GETIDX(22)],2); ASSERT_EQ(num_bond[GETIDX(22)], 2);
ASSERT_EQ(bond_atom[GETIDX(22)][0],21); ASSERT_EQ(bond_atom[GETIDX(22)][0], 21);
ASSERT_EQ(bond_atom[GETIDX(22)][1],23); ASSERT_EQ(bond_atom[GETIDX(22)][1], 23);
ASSERT_EQ(num_bond[GETIDX(23)],0); ASSERT_EQ(num_bond[GETIDX(23)], 0);
ASSERT_EQ(num_angle[GETIDX(1)],3); ASSERT_EQ(num_angle[GETIDX(1)], 3);
ASSERT_EQ(angle_atom1[GETIDX(1)][0],11); ASSERT_EQ(angle_atom1[GETIDX(1)][0], 11);
ASSERT_EQ(angle_atom2[GETIDX(1)][0],1); ASSERT_EQ(angle_atom2[GETIDX(1)][0], 1);
ASSERT_EQ(angle_atom3[GETIDX(1)][0],2); ASSERT_EQ(angle_atom3[GETIDX(1)][0], 2);
ASSERT_EQ(angle_atom1[GETIDX(1)][1],11); ASSERT_EQ(angle_atom1[GETIDX(1)][1], 11);
ASSERT_EQ(angle_atom2[GETIDX(1)][1],1); ASSERT_EQ(angle_atom2[GETIDX(1)][1], 1);
ASSERT_EQ(angle_atom3[GETIDX(1)][1],3); ASSERT_EQ(angle_atom3[GETIDX(1)][1], 3);
ASSERT_EQ(angle_atom1[GETIDX(1)][2],2); ASSERT_EQ(angle_atom1[GETIDX(1)][2], 2);
ASSERT_EQ(angle_atom2[GETIDX(1)][2],1); ASSERT_EQ(angle_atom2[GETIDX(1)][2], 1);
ASSERT_EQ(angle_atom3[GETIDX(1)][2],3); ASSERT_EQ(angle_atom3[GETIDX(1)][2], 3);
ASSERT_EQ(num_angle[GETIDX(2)],0); ASSERT_EQ(num_angle[GETIDX(2)], 0);
ASSERT_EQ(num_angle[GETIDX(5)],6); ASSERT_EQ(num_angle[GETIDX(5)], 6);
ASSERT_EQ(angle_atom1[GETIDX(5)][0],3); ASSERT_EQ(angle_atom1[GETIDX(5)][0], 3);
ASSERT_EQ(angle_atom2[GETIDX(5)][0],5); ASSERT_EQ(angle_atom2[GETIDX(5)][0], 5);
ASSERT_EQ(angle_atom3[GETIDX(5)][0],4); ASSERT_EQ(angle_atom3[GETIDX(5)][0], 4);
ASSERT_EQ(angle_atom1[GETIDX(5)][1],3); ASSERT_EQ(angle_atom1[GETIDX(5)][1], 3);
ASSERT_EQ(angle_atom2[GETIDX(5)][1],5); ASSERT_EQ(angle_atom2[GETIDX(5)][1], 5);
ASSERT_EQ(angle_atom3[GETIDX(5)][1],18); ASSERT_EQ(angle_atom3[GETIDX(5)][1], 18);
ASSERT_EQ(angle_atom1[GETIDX(5)][2],4); ASSERT_EQ(angle_atom1[GETIDX(5)][2], 4);
ASSERT_EQ(angle_atom2[GETIDX(5)][2],5); ASSERT_EQ(angle_atom2[GETIDX(5)][2], 5);
ASSERT_EQ(angle_atom3[GETIDX(5)][2],8); ASSERT_EQ(angle_atom3[GETIDX(5)][2], 8);
ASSERT_EQ(angle_atom1[GETIDX(5)][3],8); ASSERT_EQ(angle_atom1[GETIDX(5)][3], 8);
ASSERT_EQ(angle_atom2[GETIDX(5)][3],5); ASSERT_EQ(angle_atom2[GETIDX(5)][3], 5);
ASSERT_EQ(angle_atom3[GETIDX(5)][3],18); ASSERT_EQ(angle_atom3[GETIDX(5)][3], 18);
ASSERT_EQ(angle_atom1[GETIDX(5)][4],3); ASSERT_EQ(angle_atom1[GETIDX(5)][4], 3);
ASSERT_EQ(angle_atom2[GETIDX(5)][4],5); ASSERT_EQ(angle_atom2[GETIDX(5)][4], 5);
ASSERT_EQ(angle_atom3[GETIDX(5)][4],8); ASSERT_EQ(angle_atom3[GETIDX(5)][4], 8);
ASSERT_EQ(angle_atom1[GETIDX(5)][5],4); ASSERT_EQ(angle_atom1[GETIDX(5)][5], 4);
ASSERT_EQ(angle_atom2[GETIDX(5)][5],5); ASSERT_EQ(angle_atom2[GETIDX(5)][5], 5);
ASSERT_EQ(angle_atom3[GETIDX(5)][5],18); ASSERT_EQ(angle_atom3[GETIDX(5)][5], 18);
ASSERT_EQ(num_angle[GETIDX(20)],1); ASSERT_EQ(num_angle[GETIDX(20)], 1);
ASSERT_EQ(angle_atom1[GETIDX(20)][0],12); ASSERT_EQ(angle_atom1[GETIDX(20)][0], 12);
ASSERT_EQ(angle_atom2[GETIDX(20)][0],20); ASSERT_EQ(angle_atom2[GETIDX(20)][0], 20);
ASSERT_EQ(angle_atom3[GETIDX(20)][0],11); ASSERT_EQ(angle_atom3[GETIDX(20)][0], 11);
ASSERT_EQ(num_angle[GETIDX(22)],1); ASSERT_EQ(num_angle[GETIDX(22)], 1);
ASSERT_EQ(angle_atom1[GETIDX(22)][0],21); ASSERT_EQ(angle_atom1[GETIDX(22)][0], 21);
ASSERT_EQ(angle_atom2[GETIDX(22)][0],22); ASSERT_EQ(angle_atom2[GETIDX(22)][0], 22);
ASSERT_EQ(angle_atom3[GETIDX(22)][0],23); ASSERT_EQ(angle_atom3[GETIDX(22)][0], 23);
} }
TEST_F(ResetIDsTest, DeathTests) TEST_F(ResetIDsTest, DeathTests)

6
unittest/commands/test_simple_commands.cpp
View File

@ -319,7 +319,7 @@ TEST_F(SimpleCommandsTest, Shell)
lmp->input->one("shell putenv TEST_VARIABLE=simpletest"); lmp->input->one("shell putenv TEST_VARIABLE=simpletest");
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
char * test_var = getenv("TEST_VARIABLE"); char *test_var = getenv("TEST_VARIABLE");
ASSERT_NE(test_var, nullptr); ASSERT_NE(test_var, nullptr);
ASSERT_THAT(test_var, StrEq("simpletest")); ASSERT_THAT(test_var, StrEq("simpletest"));
@ -328,8 +328,8 @@ TEST_F(SimpleCommandsTest, Shell)
lmp->input->one("shell putenv TEST_VARIABLE2=simpletest2 OTHER_VARIABLE=2"); lmp->input->one("shell putenv TEST_VARIABLE2=simpletest2 OTHER_VARIABLE=2");
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
char * test_var2 = getenv("TEST_VARIABLE2"); char *test_var2 = getenv("TEST_VARIABLE2");
char * other_var = getenv("OTHER_VARIABLE"); char *other_var = getenv("OTHER_VARIABLE");
ASSERT_NE(test_var2, nullptr); ASSERT_NE(test_var2, nullptr);
ASSERT_THAT(test_var2, StrEq("simpletest2")); ASSERT_THAT(test_var2, StrEq("simpletest2"));

178
unittest/cplusplus/test_input_class.cpp
View File

@ -1,114 +1,110 @@
// unit tests for issuing command to a LAMMPS instance through the Input class // unit tests for issuing command to a LAMMPS instance through the Input class
#include "lammps.h"
#include "input.h"
#include "atom.h" #include "atom.h"
#include "input.h"
#include "lammps.h"
#include "memory.h" #include "memory.h"
#include <cstring>
#include <mpi.h> #include <mpi.h>
#include <string> #include <string>
#include <cstring>
#include "gtest/gtest.h" #include "gtest/gtest.h"
const char *demo_input[] = { const char *demo_input[] = {"region box block 0 $x 0 2 0 2", "create_box 1 box",
"region box block 0 $x 0 2 0 2", "create_atoms 1 single 1.0 1.0 ${zpos}"};
"create_box 1 box", const char *cont_input[] = {"create_atoms 1 single &", "0.2 0.1 0.1"};
"create_atoms 1 single 1.0 1.0 ${zpos}" };
const char *cont_input[] = {
"create_atoms 1 single &",
"0.2 0.1 0.1" };
namespace LAMMPS_NS namespace LAMMPS_NS {
{
class Input_commands : public ::testing::Test class Input_commands : public ::testing::Test {
protected:
LAMMPS *lmp;
Input_commands()
{ {
protected: const char *args[] = {"LAMMPS_test"};
LAMMPS *lmp; char **argv = (char **)args;
Input_commands() { int argc = sizeof(args) / sizeof(char *);
const char *args[] = {"LAMMPS_test"};
char **argv = (char **)args;
int argc = sizeof(args)/sizeof(char *);
int flag; int flag;
MPI_Initialized(&flag); MPI_Initialized(&flag);
if (!flag) MPI_Init(&argc,&argv); if (!flag) MPI_Init(&argc, &argv);
} }
~Input_commands() override {} ~Input_commands() override {}
void SetUp() override { void SetUp() override
const char *args[] = {"LAMMPS_test", {
"-log", "none", const char *args[] = {"LAMMPS_test", "-log", "none", "-echo", "screen", "-nocite",
"-echo", "screen", "-var", "zpos", "1.5", "-var", "x", "2"};
"-nocite", char **argv = (char **)args;
"-var", "zpos", "1.5", int argc = sizeof(args) / sizeof(char *);
"-var","x","2"};
char **argv = (char **)args;
int argc = sizeof(args)/sizeof(char *);
::testing::internal::CaptureStdout(); ::testing::internal::CaptureStdout();
lmp = new LAMMPS(argc, argv, MPI_COMM_WORLD); lmp = new LAMMPS(argc, argv, MPI_COMM_WORLD);
std::string output = ::testing::internal::GetCapturedStdout(); std::string output = ::testing::internal::GetCapturedStdout();
EXPECT_STREQ(output.substr(0,8).c_str(), "LAMMPS ("); EXPECT_STREQ(output.substr(0, 8).c_str(), "LAMMPS (");
} }
void TearDown() override { void TearDown() override
::testing::internal::CaptureStdout(); {
delete lmp; ::testing::internal::CaptureStdout();
std::string output = ::testing::internal::GetCapturedStdout(); delete lmp;
EXPECT_STREQ(output.substr(0,16).c_str(), "Total wall time:"); std::string output = ::testing::internal::GetCapturedStdout();
lmp = nullptr; EXPECT_STREQ(output.substr(0, 16).c_str(), "Total wall time:");
} lmp = nullptr;
}; }
};
TEST_F(Input_commands, from_file) { TEST_F(Input_commands, from_file)
FILE *fp; {
const char demo_file[] = "in.test"; FILE *fp;
const char cont_file[] = "in.cont"; const char demo_file[] = "in.test";
const char cont_file[] = "in.cont";
fp = fopen(demo_file,"w"); fp = fopen(demo_file, "w");
for (unsigned int i=0; i < sizeof(demo_input)/sizeof(char *); ++i) { for (unsigned int i = 0; i < sizeof(demo_input) / sizeof(char *); ++i) {
fputs(demo_input[i],fp); fputs(demo_input[i], fp);
fputc('\n',fp); fputc('\n', fp);
} }
fclose(fp); fclose(fp);
fp = fopen(cont_file,"w"); fp = fopen(cont_file, "w");
for (unsigned int i=0; i < sizeof(cont_input)/sizeof(char *); ++i) { for (unsigned int i = 0; i < sizeof(cont_input) / sizeof(char *); ++i) {
fputs(cont_input[i],fp); fputs(cont_input[i], fp);
fputc('\n',fp); fputc('\n', fp);
} }
fclose(fp); fclose(fp);
EXPECT_EQ(lmp->atom->natoms,0); EXPECT_EQ(lmp->atom->natoms, 0);
lmp->input->file(demo_file); lmp->input->file(demo_file);
lmp->input->file(cont_file); lmp->input->file(cont_file);
EXPECT_EQ(lmp->atom->natoms,2); EXPECT_EQ(lmp->atom->natoms, 2);
unlink(demo_file); unlink(demo_file);
unlink(cont_file); unlink(cont_file);
}; };
TEST_F(Input_commands, from_line) { TEST_F(Input_commands, from_line)
EXPECT_EQ(lmp->atom->natoms,0); {
for (unsigned int i=0; i < sizeof(demo_input)/sizeof(char *); ++i) { EXPECT_EQ(lmp->atom->natoms, 0);
lmp->input->one(demo_input[i]); for (unsigned int i = 0; i < sizeof(demo_input) / sizeof(char *); ++i) {
} lmp->input->one(demo_input[i]);
EXPECT_EQ(lmp->atom->natoms,1); }
}; EXPECT_EQ(lmp->atom->natoms, 1);
};
TEST_F(Input_commands, substitute) { TEST_F(Input_commands, substitute)
char *string,*scratch; {
int nstring=100,nscratch=100; char *string, *scratch;
int nstring = 100, nscratch = 100;
lmp->memory->create(string,nstring,"test:string"); lmp->memory->create(string, nstring, "test:string");
lmp->memory->create(scratch,nscratch,"test:scratch"); lmp->memory->create(scratch, nscratch, "test:scratch");
strcpy(string,demo_input[0]); strcpy(string, demo_input[0]);
lmp->input->substitute(string,scratch,nstring,nscratch,0); lmp->input->substitute(string, scratch, nstring, nscratch, 0);
EXPECT_STREQ(string,"region box block 0 2 0 2 0 2"); EXPECT_STREQ(string, "region box block 0 2 0 2 0 2");
strcpy(string,demo_input[2]); strcpy(string, demo_input[2]);
lmp->input->substitute(string,scratch,nstring,nscratch,0); lmp->input->substitute(string, scratch, nstring, nscratch, 0);
EXPECT_STREQ(string,"create_atoms 1 single 1.0 1.0 1.5"); EXPECT_STREQ(string, "create_atoms 1 single 1.0 1.0 1.5");
lmp->memory->destroy(string); lmp->memory->destroy(string);
lmp->memory->destroy(scratch); lmp->memory->destroy(scratch);
}; };
} } // namespace LAMMPS_NS

642
unittest/cplusplus/test_lammps_class.cpp
View File

@ -1,8 +1,8 @@
// unit tests for the LAMMPS base class // unit tests for the LAMMPS base class
#include "lammps.h" #include "lammps.h"
#include <cstdio> // for stdin, stdout
#include <mpi.h> #include <mpi.h>
#include <cstdio> // for stdin, stdout
#include <string> #include <string>
#include "gmock/gmock.h" #include "gmock/gmock.h"
@ -10,342 +10,326 @@
using ::testing::StartsWith; using ::testing::StartsWith;
namespace LAMMPS_NS namespace LAMMPS_NS {
{ // test fixture for regular tests
// test fixture for regular tests class LAMMPS_plain : public ::testing::Test {
class LAMMPS_plain : public ::testing::Test { protected:
protected: LAMMPS *lmp;
LAMMPS *lmp; LAMMPS_plain() : lmp(nullptr)
LAMMPS_plain() : lmp(nullptr) {
const char *args[] = {"LAMMPS_test"};
char **argv = (char **)args;
int argc = sizeof(args)/sizeof(char *);
int flag;
MPI_Initialized(&flag);
if (!flag) MPI_Init(&argc,&argv);
}
~LAMMPS_plain() override {
lmp = nullptr;
}
void SetUp() override {
const char *args[] = {"LAMMPS_test",
"-log", "none",
"-echo", "both",
"-nocite"};
char **argv = (char **)args;
int argc = sizeof(args)/sizeof(char *);
::testing::internal::CaptureStdout();
lmp = new LAMMPS(argc, argv, MPI_COMM_WORLD);
std::string output = ::testing::internal::GetCapturedStdout();
EXPECT_THAT(output, StartsWith("LAMMPS ("));
}
void TearDown() override {
::testing::internal::CaptureStdout();
delete lmp;
std::string output = ::testing::internal::GetCapturedStdout();
EXPECT_THAT(output, StartsWith("Total wall time:"));
}
};
TEST_F(LAMMPS_plain, InitMembers)
{ {
EXPECT_NE(lmp->memory, nullptr); const char *args[] = {"LAMMPS_test"};
EXPECT_NE(lmp->error, nullptr); char **argv = (char **)args;
EXPECT_NE(lmp->universe, nullptr); int argc = sizeof(args) / sizeof(char *);
EXPECT_NE(lmp->input, nullptr);
EXPECT_NE(lmp->atom, nullptr); int flag;
EXPECT_NE(lmp->update, nullptr); MPI_Initialized(&flag);
EXPECT_NE(lmp->neighbor, nullptr); if (!flag) MPI_Init(&argc, &argv);
EXPECT_NE(lmp->comm, nullptr);
EXPECT_NE(lmp->domain, nullptr);
EXPECT_NE(lmp->force, nullptr);
EXPECT_NE(lmp->modify, nullptr);
EXPECT_NE(lmp->group, nullptr);
EXPECT_NE(lmp->output, nullptr);
EXPECT_NE(lmp->timer, nullptr);
EXPECT_EQ(lmp->world, MPI_COMM_WORLD);
EXPECT_EQ(lmp->infile, stdin);
EXPECT_EQ(lmp->screen, stdout);
EXPECT_EQ(lmp->logfile, nullptr);
EXPECT_GE(lmp->initclock, 0.0);
EXPECT_EQ(lmp->suffix_enable, 0);
EXPECT_EQ(lmp->suffix, nullptr);
EXPECT_EQ(lmp->suffix2, nullptr);
EXPECT_STREQ(lmp->exename, "LAMMPS_test");
EXPECT_EQ(lmp->num_package, 0);
EXPECT_EQ(lmp->clientserver, 0);
EXPECT_EQ(lmp->kokkos, nullptr);
EXPECT_EQ(lmp->atomKK, nullptr);
EXPECT_EQ(lmp->memoryKK, nullptr);
EXPECT_NE(lmp->python, nullptr);
EXPECT_EQ(lmp->citeme, nullptr);
if (LAMMPS::has_git_info) {
EXPECT_STRNE(LAMMPS::git_commit,"");
EXPECT_STRNE(LAMMPS::git_branch,"");
EXPECT_STRNE(LAMMPS::git_descriptor,"");
} else {
EXPECT_STREQ(LAMMPS::git_commit,"(unknown)");
EXPECT_STREQ(LAMMPS::git_branch,"(unknown)");
EXPECT_STREQ(LAMMPS::git_descriptor,"(unknown)");
}
} }
TEST_F(LAMMPS_plain, TestStyles) ~LAMMPS_plain() override { lmp = nullptr; }
void SetUp() override
{ {
// skip tests if base class is not available const char *args[] = {"LAMMPS_test", "-log", "none", "-echo", "both", "-nocite"};
if (lmp == nullptr) return; char **argv = (char **)args;
const char *found; int argc = sizeof(args) / sizeof(char *);
const char *atom_styles[] = {
"atomic", "body", "charge", "ellipsoid", "hybrid",
"line", "sphere", "tri", NULL };
for (int i = 0; atom_styles[i] != NULL; ++i) {
found = lmp->match_style("atom",atom_styles[i]);
EXPECT_STREQ(found, NULL);
}
const char *molecule_atom_styles[] = {
"angle", "bond", "full", "molecular", "template", NULL };
for (int i = 0; molecule_atom_styles[i] != NULL; ++i) {
found = lmp->match_style("atom",molecule_atom_styles[i]);
EXPECT_STREQ(found, "MOLECULE");
}
const char *kokkos_atom_styles[] = {
"angle/kk", "bond/kk", "full/kk", "molecular/kk", "hybrid/kk", NULL };
for (int i = 0; kokkos_atom_styles[i] != NULL; ++i) {
found = lmp->match_style("atom",kokkos_atom_styles[i]);
EXPECT_STREQ(found, "KOKKOS");
}
found = lmp->match_style("atom","dipole");
EXPECT_STREQ(found,"DIPOLE");
found = lmp->match_style("atom","peri");
EXPECT_STREQ(found,"PERI");
found = lmp->match_style("atom","spin");
EXPECT_STREQ(found,"SPIN");
found = lmp->match_style("atom","wavepacket");
EXPECT_STREQ(found,"USER-AWPMD");
found = lmp->match_style("atom","dpd");
EXPECT_STREQ(found,"USER-DPD");
found = lmp->match_style("atom","edpd");
EXPECT_STREQ(found,"USER-MESODPD");
found = lmp->match_style("atom","mdpd");
EXPECT_STREQ(found,"USER-MESODPD");
found = lmp->match_style("atom","tdpd");
EXPECT_STREQ(found,"USER-MESODPD");
found = lmp->match_style("atom","spin");
EXPECT_STREQ(found,"SPIN");
found = lmp->match_style("atom","smd");
EXPECT_STREQ(found,"USER-SMD");
found = lmp->match_style("atom","sph");
EXPECT_STREQ(found,"USER-SPH");
found = lmp->match_style("atom","i_don't_exist");
EXPECT_STREQ(found,NULL);
}
// test fixture for OpenMP with 2 threads
class LAMMPS_omp : public ::testing::Test {
protected:
LAMMPS *lmp;
LAMMPS_omp() : lmp(nullptr) {
const char *args[] = {"LAMMPS_test"};
char **argv = (char **)args;
int argc = sizeof(args)/sizeof(char *);
int flag;
MPI_Initialized(&flag);
if (!flag) MPI_Init(&argc,&argv);
}
~LAMMPS_omp() override {
lmp = nullptr;
}
void SetUp() override {
const char *args[] = {"LAMMPS_test",
"-log", "none",
"-screen", "none",
"-echo", "screen",
"-pk", "omp","2", "neigh", "yes",
"-sf", "omp"
};
char **argv = (char **)args;
int argc = sizeof(args)/sizeof(char *);
// only run this test fixture with omp suffix if USER-OMP package is installed
if (LAMMPS::is_installed_pkg("USER-OMP"))
lmp = new LAMMPS(argc, argv, MPI_COMM_WORLD);
else GTEST_SKIP();
}
void TearDown() override {
delete lmp;
}
};
TEST_F(LAMMPS_omp, InitMembers)
{
EXPECT_NE(lmp->memory, nullptr);
EXPECT_NE(lmp->error, nullptr);
EXPECT_NE(lmp->universe, nullptr);
EXPECT_NE(lmp->input, nullptr);
EXPECT_NE(lmp->atom, nullptr);
EXPECT_NE(lmp->update, nullptr);
EXPECT_NE(lmp->neighbor, nullptr);
EXPECT_NE(lmp->comm, nullptr);
EXPECT_NE(lmp->domain, nullptr);
EXPECT_NE(lmp->force, nullptr);
EXPECT_NE(lmp->modify, nullptr);
EXPECT_NE(lmp->group, nullptr);
EXPECT_NE(lmp->output, nullptr);
EXPECT_NE(lmp->timer, nullptr);
EXPECT_EQ(lmp->world, MPI_COMM_WORLD);
EXPECT_EQ(lmp->infile, stdin);
EXPECT_EQ(lmp->screen, nullptr);
EXPECT_EQ(lmp->logfile, nullptr);
EXPECT_GE(lmp->initclock, 0.0);
EXPECT_EQ(lmp->suffix_enable, 1);
EXPECT_STREQ(lmp->suffix, "omp");
EXPECT_EQ(lmp->suffix2, nullptr);
EXPECT_STREQ(lmp->exename, "LAMMPS_test");
EXPECT_EQ(lmp->num_package, 1);
EXPECT_EQ(lmp->clientserver, 0);
EXPECT_EQ(lmp->kokkos, nullptr);
EXPECT_EQ(lmp->atomKK, nullptr);
EXPECT_EQ(lmp->memoryKK, nullptr);
EXPECT_NE(lmp->python, nullptr);
EXPECT_NE(lmp->citeme, nullptr);
if (LAMMPS::has_git_info) {
EXPECT_STRNE(LAMMPS::git_commit,"");
EXPECT_STRNE(LAMMPS::git_branch,"");
EXPECT_STRNE(LAMMPS::git_descriptor,"");
} else {
EXPECT_STREQ(LAMMPS::git_commit,"(unknown)");
EXPECT_STREQ(LAMMPS::git_branch,"(unknown)");
EXPECT_STREQ(LAMMPS::git_descriptor,"(unknown)");
}
}
// test fixture for Kokkos tests
class LAMMPS_kokkos : public ::testing::Test {
protected:
LAMMPS *lmp;
LAMMPS_kokkos() : lmp(nullptr) {
const char *args[] = {"LAMMPS_test"};
char **argv = (char **)args;
int argc = sizeof(args)/sizeof(char *);
int flag;
MPI_Initialized(&flag);
if (!flag) MPI_Init(&argc,&argv);
}
~LAMMPS_kokkos() override {
lmp = nullptr;
}
void SetUp() override {
const char *args[] = {"LAMMPS_test",
"-log", "none",
"-echo", "none",
"-screen", "none",
"-k", "on","t", "2",
"-sf", "kk"
};
char **argv = (char **)args;
int argc = sizeof(args)/sizeof(char *);
// only run this test fixture with kk suffix if KOKKOS package is installed
// also need to figure out a way to find which parallelizations are enabled
if (LAMMPS::is_installed_pkg("KOKKOS")) {
::testing::internal::CaptureStdout();
lmp = new LAMMPS(argc, argv, MPI_COMM_WORLD);
std::string output = ::testing::internal::GetCapturedStdout();
EXPECT_THAT(output, StartsWith("Kokkos::OpenMP::"));
} else GTEST_SKIP();
}
void TearDown() override {
delete lmp;
}
};
TEST_F(LAMMPS_kokkos, InitMembers)
{
EXPECT_NE(lmp->memory, nullptr);
EXPECT_NE(lmp->error, nullptr);
EXPECT_NE(lmp->universe, nullptr);
EXPECT_NE(lmp->input, nullptr);
EXPECT_NE(lmp->atom, nullptr);
EXPECT_NE(lmp->update, nullptr);
EXPECT_NE(lmp->neighbor, nullptr);
EXPECT_NE(lmp->comm, nullptr);
EXPECT_NE(lmp->domain, nullptr);
EXPECT_NE(lmp->force, nullptr);
EXPECT_NE(lmp->modify, nullptr);
EXPECT_NE(lmp->group, nullptr);
EXPECT_NE(lmp->output, nullptr);
EXPECT_NE(lmp->timer, nullptr);
EXPECT_EQ(lmp->world, MPI_COMM_WORLD);
EXPECT_EQ(lmp->infile, stdin);
EXPECT_EQ(lmp->screen, nullptr);
EXPECT_EQ(lmp->logfile, nullptr);
EXPECT_GE(lmp->initclock, 0.0);
EXPECT_EQ(lmp->suffix_enable, 1);
EXPECT_STREQ(lmp->suffix, "kk");
EXPECT_EQ(lmp->suffix2, nullptr);
EXPECT_STREQ(lmp->exename, "LAMMPS_test");
EXPECT_EQ(lmp->num_package, 0);
EXPECT_EQ(lmp->clientserver, 0);
EXPECT_NE(lmp->kokkos, nullptr);
EXPECT_NE(lmp->atomKK, nullptr);
EXPECT_NE(lmp->memoryKK, nullptr);
EXPECT_NE(lmp->python, nullptr);
EXPECT_NE(lmp->citeme, nullptr);
if (LAMMPS::has_git_info) {
EXPECT_STRNE(LAMMPS::git_commit,"");
EXPECT_STRNE(LAMMPS::git_branch,"");
EXPECT_STRNE(LAMMPS::git_descriptor,"");
} else {
EXPECT_STREQ(LAMMPS::git_commit,"(unknown)");
EXPECT_STREQ(LAMMPS::git_branch,"(unknown)");
EXPECT_STREQ(LAMMPS::git_descriptor,"(unknown)");
}
}
// check help message printing
TEST(LAMMPS_help, HelpMessage) {
const char *args[] = {"LAMMPS_test", "-h"};
char **argv = (char **)args;
int argc = sizeof(args)/sizeof(char *);
::testing::internal::CaptureStdout(); ::testing::internal::CaptureStdout();
LAMMPS *lmp = new LAMMPS(argc, argv, MPI_COMM_WORLD); lmp = new LAMMPS(argc, argv, MPI_COMM_WORLD);
std::string output = ::testing::internal::GetCapturedStdout(); std::string output = ::testing::internal::GetCapturedStdout();
EXPECT_THAT(output, EXPECT_THAT(output, StartsWith("LAMMPS ("));
StartsWith("\nLarge-scale Atomic/Molecular Massively Parallel Simulator -")); }
void TearDown() override
{
::testing::internal::CaptureStdout();
delete lmp; delete lmp;
std::string output = ::testing::internal::GetCapturedStdout();
EXPECT_THAT(output, StartsWith("Total wall time:"));
}
};
TEST_F(LAMMPS_plain, InitMembers)
{
EXPECT_NE(lmp->memory, nullptr);
EXPECT_NE(lmp->error, nullptr);
EXPECT_NE(lmp->universe, nullptr);
EXPECT_NE(lmp->input, nullptr);
EXPECT_NE(lmp->atom, nullptr);
EXPECT_NE(lmp->update, nullptr);
EXPECT_NE(lmp->neighbor, nullptr);
EXPECT_NE(lmp->comm, nullptr);
EXPECT_NE(lmp->domain, nullptr);
EXPECT_NE(lmp->force, nullptr);
EXPECT_NE(lmp->modify, nullptr);
EXPECT_NE(lmp->group, nullptr);
EXPECT_NE(lmp->output, nullptr);
EXPECT_NE(lmp->timer, nullptr);
EXPECT_EQ(lmp->world, MPI_COMM_WORLD);
EXPECT_EQ(lmp->infile, stdin);
EXPECT_EQ(lmp->screen, stdout);
EXPECT_EQ(lmp->logfile, nullptr);
EXPECT_GE(lmp->initclock, 0.0);
EXPECT_EQ(lmp->suffix_enable, 0);
EXPECT_EQ(lmp->suffix, nullptr);
EXPECT_EQ(lmp->suffix2, nullptr);
EXPECT_STREQ(lmp->exename, "LAMMPS_test");
EXPECT_EQ(lmp->num_package, 0);
EXPECT_EQ(lmp->clientserver, 0);
EXPECT_EQ(lmp->kokkos, nullptr);
EXPECT_EQ(lmp->atomKK, nullptr);
EXPECT_EQ(lmp->memoryKK, nullptr);
EXPECT_NE(lmp->python, nullptr);
EXPECT_EQ(lmp->citeme, nullptr);
if (LAMMPS::has_git_info) {
EXPECT_STRNE(LAMMPS::git_commit, "");
EXPECT_STRNE(LAMMPS::git_branch, "");
EXPECT_STRNE(LAMMPS::git_descriptor, "");
} else {
EXPECT_STREQ(LAMMPS::git_commit, "(unknown)");
EXPECT_STREQ(LAMMPS::git_branch, "(unknown)");
EXPECT_STREQ(LAMMPS::git_descriptor, "(unknown)");
} }
} }
TEST_F(LAMMPS_plain, TestStyles)
{
// skip tests if base class is not available
if (lmp == nullptr) return;
const char *found;
const char *atom_styles[] = {"atomic", "body", "charge", "ellipsoid", "hybrid",
"line", "sphere", "tri", NULL};
for (int i = 0; atom_styles[i] != NULL; ++i) {
found = lmp->match_style("atom", atom_styles[i]);
EXPECT_STREQ(found, NULL);
}
const char *molecule_atom_styles[] = {"angle", "bond", "full", "molecular", "template", NULL};
for (int i = 0; molecule_atom_styles[i] != NULL; ++i) {
found = lmp->match_style("atom", molecule_atom_styles[i]);
EXPECT_STREQ(found, "MOLECULE");
}
const char *kokkos_atom_styles[] = {"angle/kk", "bond/kk", "full/kk",
"molecular/kk", "hybrid/kk", NULL};
for (int i = 0; kokkos_atom_styles[i] != NULL; ++i) {
found = lmp->match_style("atom", kokkos_atom_styles[i]);
EXPECT_STREQ(found, "KOKKOS");
}
found = lmp->match_style("atom", "dipole");
EXPECT_STREQ(found, "DIPOLE");
found = lmp->match_style("atom", "peri");
EXPECT_STREQ(found, "PERI");
found = lmp->match_style("atom", "spin");
EXPECT_STREQ(found, "SPIN");
found = lmp->match_style("atom", "wavepacket");
EXPECT_STREQ(found, "USER-AWPMD");
found = lmp->match_style("atom", "dpd");
EXPECT_STREQ(found, "USER-DPD");
found = lmp->match_style("atom", "edpd");
EXPECT_STREQ(found, "USER-MESODPD");
found = lmp->match_style("atom", "mdpd");
EXPECT_STREQ(found, "USER-MESODPD");
found = lmp->match_style("atom", "tdpd");
EXPECT_STREQ(found, "USER-MESODPD");
found = lmp->match_style("atom", "spin");
EXPECT_STREQ(found, "SPIN");
found = lmp->match_style("atom", "smd");
EXPECT_STREQ(found, "USER-SMD");
found = lmp->match_style("atom", "sph");
EXPECT_STREQ(found, "USER-SPH");
found = lmp->match_style("atom", "i_don't_exist");
EXPECT_STREQ(found, NULL);
}
// test fixture for OpenMP with 2 threads
class LAMMPS_omp : public ::testing::Test {
protected:
LAMMPS *lmp;
LAMMPS_omp() : lmp(nullptr)
{
const char *args[] = {"LAMMPS_test"};
char **argv = (char **)args;
int argc = sizeof(args) / sizeof(char *);
int flag;
MPI_Initialized(&flag);
if (!flag) MPI_Init(&argc, &argv);
}
~LAMMPS_omp() override { lmp = nullptr; }
void SetUp() override
{
const char *args[] = {"LAMMPS_test", "-log", "none", "-screen", "none", "-echo", "screen",
"-pk", "omp", "2", "neigh", "yes", "-sf", "omp"};
char **argv = (char **)args;
int argc = sizeof(args) / sizeof(char *);
// only run this test fixture with omp suffix if USER-OMP package is installed
if (LAMMPS::is_installed_pkg("USER-OMP"))
lmp = new LAMMPS(argc, argv, MPI_COMM_WORLD);
else
GTEST_SKIP();
}
void TearDown() override { delete lmp; }
};
TEST_F(LAMMPS_omp, InitMembers)
{
EXPECT_NE(lmp->memory, nullptr);
EXPECT_NE(lmp->error, nullptr);
EXPECT_NE(lmp->universe, nullptr);
EXPECT_NE(lmp->input, nullptr);
EXPECT_NE(lmp->atom, nullptr);
EXPECT_NE(lmp->update, nullptr);
EXPECT_NE(lmp->neighbor, nullptr);
EXPECT_NE(lmp->comm, nullptr);
EXPECT_NE(lmp->domain, nullptr);
EXPECT_NE(lmp->force, nullptr);
EXPECT_NE(lmp->modify, nullptr);
EXPECT_NE(lmp->group, nullptr);
EXPECT_NE(lmp->output, nullptr);
EXPECT_NE(lmp->timer, nullptr);
EXPECT_EQ(lmp->world, MPI_COMM_WORLD);
EXPECT_EQ(lmp->infile, stdin);
EXPECT_EQ(lmp->screen, nullptr);
EXPECT_EQ(lmp->logfile, nullptr);
EXPECT_GE(lmp->initclock, 0.0);
EXPECT_EQ(lmp->suffix_enable, 1);
EXPECT_STREQ(lmp->suffix, "omp");
EXPECT_EQ(lmp->suffix2, nullptr);
EXPECT_STREQ(lmp->exename, "LAMMPS_test");
EXPECT_EQ(lmp->num_package, 1);
EXPECT_EQ(lmp->clientserver, 0);
EXPECT_EQ(lmp->kokkos, nullptr);
EXPECT_EQ(lmp->atomKK, nullptr);
EXPECT_EQ(lmp->memoryKK, nullptr);
EXPECT_NE(lmp->python, nullptr);
EXPECT_NE(lmp->citeme, nullptr);
if (LAMMPS::has_git_info) {
EXPECT_STRNE(LAMMPS::git_commit, "");
EXPECT_STRNE(LAMMPS::git_branch, "");
EXPECT_STRNE(LAMMPS::git_descriptor, "");
} else {
EXPECT_STREQ(LAMMPS::git_commit, "(unknown)");
EXPECT_STREQ(LAMMPS::git_branch, "(unknown)");
EXPECT_STREQ(LAMMPS::git_descriptor, "(unknown)");
}
}
// test fixture for Kokkos tests
class LAMMPS_kokkos : public ::testing::Test {
protected:
LAMMPS *lmp;
LAMMPS_kokkos() : lmp(nullptr)
{
const char *args[] = {"LAMMPS_test"};
char **argv = (char **)args;
int argc = sizeof(args) / sizeof(char *);
int flag;
MPI_Initialized(&flag);
if (!flag) MPI_Init(&argc, &argv);
}
~LAMMPS_kokkos() override { lmp = nullptr; }
void SetUp() override
{
const char *args[] = {"LAMMPS_test", "-log", "none", "-echo", "none", "-screen", "none",
"-k", "on", "t", "2", "-sf", "kk"};
char **argv = (char **)args;
int argc = sizeof(args) / sizeof(char *);
// only run this test fixture with kk suffix if KOKKOS package is installed
// also need to figure out a way to find which parallelizations are enabled
if (LAMMPS::is_installed_pkg("KOKKOS")) {
::testing::internal::CaptureStdout();
lmp = new LAMMPS(argc, argv, MPI_COMM_WORLD);
std::string output = ::testing::internal::GetCapturedStdout();
EXPECT_THAT(output, StartsWith("Kokkos::OpenMP::"));
} else
GTEST_SKIP();
}
void TearDown() override { delete lmp; }
};
TEST_F(LAMMPS_kokkos, InitMembers)
{
EXPECT_NE(lmp->memory, nullptr);
EXPECT_NE(lmp->error, nullptr);
EXPECT_NE(lmp->universe, nullptr);
EXPECT_NE(lmp->input, nullptr);
EXPECT_NE(lmp->atom, nullptr);
EXPECT_NE(lmp->update, nullptr);
EXPECT_NE(lmp->neighbor, nullptr);
EXPECT_NE(lmp->comm, nullptr);
EXPECT_NE(lmp->domain, nullptr);
EXPECT_NE(lmp->force, nullptr);
EXPECT_NE(lmp->modify, nullptr);
EXPECT_NE(lmp->group, nullptr);
EXPECT_NE(lmp->output, nullptr);
EXPECT_NE(lmp->timer, nullptr);
EXPECT_EQ(lmp->world, MPI_COMM_WORLD);
EXPECT_EQ(lmp->infile, stdin);
EXPECT_EQ(lmp->screen, nullptr);
EXPECT_EQ(lmp->logfile, nullptr);
EXPECT_GE(lmp->initclock, 0.0);
EXPECT_EQ(lmp->suffix_enable, 1);
EXPECT_STREQ(lmp->suffix, "kk");
EXPECT_EQ(lmp->suffix2, nullptr);
EXPECT_STREQ(lmp->exename, "LAMMPS_test");
EXPECT_EQ(lmp->num_package, 0);
EXPECT_EQ(lmp->clientserver, 0);
EXPECT_NE(lmp->kokkos, nullptr);
EXPECT_NE(lmp->atomKK, nullptr);
EXPECT_NE(lmp->memoryKK, nullptr);
EXPECT_NE(lmp->python, nullptr);
EXPECT_NE(lmp->citeme, nullptr);
if (LAMMPS::has_git_info) {
EXPECT_STRNE(LAMMPS::git_commit, "");
EXPECT_STRNE(LAMMPS::git_branch, "");
EXPECT_STRNE(LAMMPS::git_descriptor, "");
} else {
EXPECT_STREQ(LAMMPS::git_commit, "(unknown)");
EXPECT_STREQ(LAMMPS::git_branch, "(unknown)");
EXPECT_STREQ(LAMMPS::git_descriptor, "(unknown)");
}
}
// check help message printing
TEST(LAMMPS_help, HelpMessage)
{
const char *args[] = {"LAMMPS_test", "-h"};
char **argv = (char **)args;
int argc = sizeof(args) / sizeof(char *);
::testing::internal::CaptureStdout();
LAMMPS *lmp = new LAMMPS(argc, argv, MPI_COMM_WORLD);
std::string output = ::testing::internal::GetCapturedStdout();
EXPECT_THAT(output,
StartsWith("\nLarge-scale Atomic/Molecular Massively Parallel Simulator -"));
delete lmp;
}
} // namespace LAMMPS_NS

6
unittest/force-styles/test_fix_timestep.cpp
View File

@ -266,7 +266,7 @@ void generate_yaml_file(const char *outfile, const TestConfig &config)
// run_pos // run_pos
block.clear(); block.clear();
auto x = lmp->atom->x; auto x = lmp->atom->x;
for (int i = 1; i <= natoms; ++i) { for (int i = 1; i <= natoms; ++i) {
const int j = lmp->atom->map(i); const int j = lmp->atom->map(i);
block += fmt::format("{:3} {:23.16e} {:23.16e} {:23.16e}\n", i, x[j][0], x[j][1], x[j][2]); block += fmt::format("{:3} {:23.16e} {:23.16e} {:23.16e}\n", i, x[j][0], x[j][1], x[j][2]);
@ -519,8 +519,8 @@ TEST(FixTimestep, plain)
// rigid fixes need work to test properly with r-RESPA. // rigid fixes need work to test properly with r-RESPA.
// fix nve/limit cannot work with r-RESPA // fix nve/limit cannot work with r-RESPA
ifix = lmp->modify->find_fix("test"); ifix = lmp->modify->find_fix("test");
if (!utils::strmatch(lmp->modify->fix[ifix]->style, "^rigid") if (!utils::strmatch(lmp->modify->fix[ifix]->style, "^rigid") &&
&& !utils::strmatch(lmp->modify->fix[ifix]->style, "^nve/limit")) { !utils::strmatch(lmp->modify->fix[ifix]->style, "^nve/limit")) {
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
cleanup_lammps(lmp, test_config); cleanup_lammps(lmp, test_config);

2
unittest/force-styles/test_main.cpp
View File

@ -12,9 +12,9 @@
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
#include "test_main.h" #include "test_main.h"
#include "pointers.h"
#include "test_config.h" #include "test_config.h"
#include "test_config_reader.h" #include "test_config_reader.h"
#include "pointers.h"
#include "utils.h" #include "utils.h"
#include "gmock/gmock.h" #include "gmock/gmock.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"

525
unittest/formats/test_atom_styles.cpp
View File

@ -132,83 +132,82 @@ protected:
// default class Atom state // default class Atom state
struct AtomState { struct AtomState {
std::string atom_style = "atomic"; std::string atom_style = "atomic";
bigint natoms = 0; bigint natoms = 0;
int nlocal = 0; int nlocal = 0;
int nghost = 0; int nghost = 0;
int nmax = 1; int nmax = 1;
int tag_enable = 1; int tag_enable = 1;
int molecular = Atom::ATOMIC; int molecular = Atom::ATOMIC;
bigint nellipsoids = 0; bigint nellipsoids = 0;
bigint nlines = 0; bigint nlines = 0;
bigint ntris = 0; bigint ntris = 0;
bigint nbodies = 0; bigint nbodies = 0;
bigint nbonds = 0; bigint nbonds = 0;
bigint nangles = 0; bigint nangles = 0;
bigint ndihedrals = 0; bigint ndihedrals = 0;
bigint nimpropers = 0; bigint nimpropers = 0;
int ntypes = 0; int ntypes = 0;
int nbondtypes = 0; int nbondtypes = 0;
int nangletypes = 0; int nangletypes = 0;
int ndihedraltypes = 0; int ndihedraltypes = 0;
int nimpropertypes = 0; int nimpropertypes = 0;
int bond_per_atom = 0; int bond_per_atom = 0;
int angle_per_atom = 0; int angle_per_atom = 0;
int dihedral_per_atom = 0; int dihedral_per_atom = 0;
int improper_per_atom = 0; int improper_per_atom = 0;
int extra_bond_per_atom = 0; int extra_bond_per_atom = 0;
int extra_angle_per_atom = 0; int extra_angle_per_atom = 0;
int extra_dihedral_per_atom = 0; int extra_dihedral_per_atom = 0;
int extra_improper_per_atom = 0; int extra_improper_per_atom = 0;
int sphere_flag = 0; int sphere_flag = 0;
int ellipsoid_flag = 0; int ellipsoid_flag = 0;
int line_flag = 0; int line_flag = 0;
int tri_flag = 0; int tri_flag = 0;
int body_flag = 0; int body_flag = 0;
int peri_flag = 0; int peri_flag = 0;
int electron_flag = 0; int electron_flag = 0;
int wavepacket_flag = 0; int wavepacket_flag = 0;
int sph_flag = 0; int sph_flag = 0;
int molecule_flag = 0; int molecule_flag = 0;
int molindex_flag = 0; int molindex_flag = 0;
int molatom_flag = 0; int molatom_flag = 0;
int q_flag = 0; int q_flag = 0;
int mu_flag = 0; int mu_flag = 0;
int rmass_flag = 0; int rmass_flag = 0;
int radius_flag = 0; int radius_flag = 0;
int omega_flag = 0; int omega_flag = 0;
int torque_flag = 0; int torque_flag = 0;
int angmom_flag = 0; int angmom_flag = 0;
int vfrac_flag = 0; int vfrac_flag = 0;
int spin_flag = 0; int spin_flag = 0;
int eradius_flag = 0; int eradius_flag = 0;
int ervel_flag = 0; int ervel_flag = 0;
int erforce_flag = 0; int erforce_flag = 0;
int cs_flag = 0; int cs_flag = 0;
int csforce_flag = 0; int csforce_flag = 0;
int vforce_flag = 0; int vforce_flag = 0;
int ervelforce_flag = 0; int ervelforce_flag = 0;
int etag_flag = 0; int etag_flag = 0;
int rho_flag = 0; int rho_flag = 0;
int esph_flag = 0; int esph_flag = 0;
int cv_flag = 0; int cv_flag = 0;
int vest_flag = 0; int vest_flag = 0;
int dpd_flag = 0; int dpd_flag = 0;
int edpd_flag = 0; int edpd_flag = 0;
int tdpd_flag = 0; int tdpd_flag = 0;
int mesont_flag = 0; int mesont_flag = 0;
int sp_flag = 0; int sp_flag = 0;
int x0_flag = 0; int x0_flag = 0;
int smd_flag = 0; int smd_flag = 0;
int damage_flag = 0; int damage_flag = 0;
int contact_radius_flag = 0; int contact_radius_flag = 0;
int smd_data_9_flag = 0; int smd_data_9_flag = 0;
int smd_stress_flag = 0; int smd_stress_flag = 0;
int eff_plastic_strain_flag = 0; int eff_plastic_strain_flag = 0;
int eff_plastic_strain_rate_flag = 0; int eff_plastic_strain_rate_flag = 0;
double pdscale = 1.0; double pdscale = 1.0;
int maxspecial = 1; int maxspecial = 1;
@ -217,48 +216,49 @@ struct AtomState {
int nivector = 0; int nivector = 0;
int ndvector = 0; int ndvector = 0;
int nextra_grow = 0; int nextra_grow = 0;
int nextra_restart = 0; int nextra_restart = 0;
int nextra_border = 0; int nextra_border = 0;
int nextra_grow_max = 0; int nextra_grow_max = 0;
int nextra_restart_max = 0; int nextra_restart_max = 0;
int nextra_border_max = 0; int nextra_border_max = 0;
int nextra_store = 0; int nextra_store = 0;
int map_style = Atom::MAP_NONE; int map_style = Atom::MAP_NONE;
int map_user = 0; int map_user = 0;
tagint map_tag_max = -1; tagint map_tag_max = -1;
// properties X that aren't controlled by an equivalent X_flag // properties X that aren't controlled by an equivalent X_flag
bool has_type = true; bool has_type = true;
bool has_mask = true; bool has_mask = true;
bool has_image = true; bool has_image = true;
bool has_x = true; bool has_x = true;
bool has_v = true; bool has_v = true;
bool has_f = true; bool has_f = true;
bool has_bonds = false; bool has_bonds = false;
bool has_angles = false; bool has_angles = false;
bool has_dihedral = false; bool has_dihedral = false;
bool has_improper = false; bool has_improper = false;
bool has_iname = false; bool has_iname = false;
bool has_dname = false; bool has_dname = false;
bool has_mass = false; bool has_mass = false;
bool has_mass_setflag = false; bool has_mass_setflag = false;
bool has_nspecial = false; bool has_nspecial = false;
bool has_special = false; bool has_special = false;
}; };
#define ASSERT_ARRAY_ALLOCATED(ptr, enabled) \ #define ASSERT_ARRAY_ALLOCATED(ptr, enabled) \
if (enabled) { \ if (enabled) { \
ASSERT_NE(ptr, nullptr); \ ASSERT_NE(ptr, nullptr); \
} else { \ } else { \
ASSERT_EQ(ptr, nullptr); \ ASSERT_EQ(ptr, nullptr); \
} }
void ASSERT_ATOM_STATE_EQ(Atom* atom, const AtomState& expected) { void ASSERT_ATOM_STATE_EQ(Atom *atom, const AtomState &expected)
{
ASSERT_THAT(std::string(atom->atom_style), Eq(expected.atom_style)); ASSERT_THAT(std::string(atom->atom_style), Eq(expected.atom_style));
ASSERT_NE(atom->avec, nullptr); ASSERT_NE(atom->avec, nullptr);
@ -289,7 +289,7 @@ void ASSERT_ATOM_STATE_EQ(Atom* atom, const AtomState& expected) {
ASSERT_EQ(atom->extra_angle_per_atom, expected.extra_angle_per_atom); ASSERT_EQ(atom->extra_angle_per_atom, expected.extra_angle_per_atom);
ASSERT_EQ(atom->extra_dihedral_per_atom, expected.extra_dihedral_per_atom); ASSERT_EQ(atom->extra_dihedral_per_atom, expected.extra_dihedral_per_atom);
ASSERT_EQ(atom->extra_improper_per_atom, expected.extra_improper_per_atom); ASSERT_EQ(atom->extra_improper_per_atom, expected.extra_improper_per_atom);
ASSERT_EQ(atom->sphere_flag, expected.sphere_flag); ASSERT_EQ(atom->sphere_flag, expected.sphere_flag);
ASSERT_EQ(atom->ellipsoid_flag, expected.ellipsoid_flag); ASSERT_EQ(atom->ellipsoid_flag, expected.ellipsoid_flag);
ASSERT_EQ(atom->line_flag, expected.line_flag); ASSERT_EQ(atom->line_flag, expected.line_flag);
@ -470,14 +470,14 @@ TEST_F(AtomStyleTest, atomic_is_default)
{ {
AtomState expected; AtomState expected;
expected.atom_style = "atomic"; expected.atom_style = "atomic";
expected.molecular = Atom::ATOMIC; expected.molecular = Atom::ATOMIC;
expected.tag_enable = 1; expected.tag_enable = 1;
expected.has_type = true; expected.has_type = true;
expected.has_mask = true; expected.has_mask = true;
expected.has_image = true; expected.has_image = true;
expected.has_x = true; expected.has_x = true;
expected.has_v = true; expected.has_v = true;
expected.has_f = true; expected.has_f = true;
ASSERT_ATOM_STATE_EQ(lmp->atom, expected); ASSERT_ATOM_STATE_EQ(lmp->atom, expected);
} }
@ -486,14 +486,14 @@ TEST_F(AtomStyleTest, atomic_after_charge)
{ {
AtomState expected; AtomState expected;
expected.atom_style = "atomic"; expected.atom_style = "atomic";
expected.molecular = Atom::ATOMIC; expected.molecular = Atom::ATOMIC;
expected.tag_enable = 1; expected.tag_enable = 1;
expected.has_type = true; expected.has_type = true;
expected.has_mask = true; expected.has_mask = true;
expected.has_image = true; expected.has_image = true;
expected.has_x = true; expected.has_x = true;
expected.has_v = true; expected.has_v = true;
expected.has_f = true; expected.has_f = true;
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
lmp->input->one("atom_style charge"); lmp->input->one("atom_style charge");
@ -702,15 +702,15 @@ TEST_F(AtomStyleTest, charge)
AtomState expected; AtomState expected;
expected.atom_style = "charge"; expected.atom_style = "charge";
expected.molecular = Atom::ATOMIC; expected.molecular = Atom::ATOMIC;
expected.tag_enable = 1; expected.tag_enable = 1;
expected.has_type = true; expected.has_type = true;
expected.has_image = true; expected.has_image = true;
expected.has_mask = true; expected.has_mask = true;
expected.has_x = true; expected.has_x = true;
expected.has_v = true; expected.has_v = true;
expected.has_f = true; expected.has_f = true;
expected.q_flag = 1; expected.q_flag = 1;
ASSERT_ATOM_STATE_EQ(lmp->atom, expected); ASSERT_ATOM_STATE_EQ(lmp->atom, expected);
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
@ -878,20 +878,20 @@ TEST_F(AtomStyleTest, sphere)
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
AtomState expected; AtomState expected;
expected.atom_style = "sphere"; expected.atom_style = "sphere";
expected.molecular = Atom::ATOMIC; expected.molecular = Atom::ATOMIC;
expected.tag_enable = 1; expected.tag_enable = 1;
expected.sphere_flag = 1; expected.sphere_flag = 1;
expected.rmass_flag = 1; expected.rmass_flag = 1;
expected.radius_flag = 1; expected.radius_flag = 1;
expected.omega_flag = 1; expected.omega_flag = 1;
expected.torque_flag = 1; expected.torque_flag = 1;
expected.has_type = true; expected.has_type = true;
expected.has_mask = true; expected.has_mask = true;
expected.has_image = true; expected.has_image = true;
expected.has_x = true; expected.has_x = true;
expected.has_v = true; expected.has_v = true;
expected.has_f = true; expected.has_f = true;
ASSERT_ATOM_STATE_EQ(lmp->atom, expected); ASSERT_ATOM_STATE_EQ(lmp->atom, expected);
@ -1049,19 +1049,19 @@ TEST_F(AtomStyleTest, ellipsoid)
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
AtomState expected; AtomState expected;
expected.atom_style = "ellipsoid"; expected.atom_style = "ellipsoid";
expected.molecular = Atom::ATOMIC; expected.molecular = Atom::ATOMIC;
expected.tag_enable = 1; expected.tag_enable = 1;
expected.ellipsoid_flag = 1; expected.ellipsoid_flag = 1;
expected.rmass_flag = 1; expected.rmass_flag = 1;
expected.angmom_flag = 1; expected.angmom_flag = 1;
expected.torque_flag = 1; expected.torque_flag = 1;
expected.has_type = true; expected.has_type = true;
expected.has_mask = true; expected.has_mask = true;
expected.has_image = true; expected.has_image = true;
expected.has_x = true; expected.has_x = true;
expected.has_v = true; expected.has_v = true;
expected.has_f = true; expected.has_f = true;
ASSERT_ATOM_STATE_EQ(lmp->atom, expected); ASSERT_ATOM_STATE_EQ(lmp->atom, expected);
@ -1387,22 +1387,22 @@ TEST_F(AtomStyleTest, line)
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
AtomState expected; AtomState expected;
expected.atom_style = "line"; expected.atom_style = "line";
expected.molecular = Atom::ATOMIC; expected.molecular = Atom::ATOMIC;
expected.tag_enable = 1; expected.tag_enable = 1;
expected.sphere_flag = 1; expected.sphere_flag = 1;
expected.molecule_flag = 1; expected.molecule_flag = 1;
expected.line_flag = 1; expected.line_flag = 1;
expected.rmass_flag = 1; expected.rmass_flag = 1;
expected.radius_flag = 1; expected.radius_flag = 1;
expected.omega_flag = 1; expected.omega_flag = 1;
expected.torque_flag = 1; expected.torque_flag = 1;
expected.has_type = true; expected.has_type = true;
expected.has_mask = true; expected.has_mask = true;
expected.has_image = true; expected.has_image = true;
expected.has_x = true; expected.has_x = true;
expected.has_v = true; expected.has_v = true;
expected.has_f = true; expected.has_f = true;
ASSERT_ATOM_STATE_EQ(lmp->atom, expected); ASSERT_ATOM_STATE_EQ(lmp->atom, expected);
@ -1657,23 +1657,23 @@ TEST_F(AtomStyleTest, tri)
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
AtomState expected; AtomState expected;
expected.atom_style = "tri"; expected.atom_style = "tri";
expected.molecular = Atom::ATOMIC; expected.molecular = Atom::ATOMIC;
expected.tag_enable = 1; expected.tag_enable = 1;
expected.sphere_flag = 1; expected.sphere_flag = 1;
expected.molecule_flag = 1; expected.molecule_flag = 1;
expected.tri_flag = 1; expected.tri_flag = 1;
expected.rmass_flag = 1; expected.rmass_flag = 1;
expected.radius_flag = 1; expected.radius_flag = 1;
expected.omega_flag = 1; expected.omega_flag = 1;
expected.angmom_flag = 1; expected.angmom_flag = 1;
expected.torque_flag = 1; expected.torque_flag = 1;
expected.has_type = true; expected.has_type = true;
expected.has_mask = true; expected.has_mask = true;
expected.has_image = true; expected.has_image = true;
expected.has_x = true; expected.has_x = true;
expected.has_v = true; expected.has_v = true;
expected.has_f = true; expected.has_f = true;
ASSERT_ATOM_STATE_EQ(lmp->atom, expected); ASSERT_ATOM_STATE_EQ(lmp->atom, expected);
@ -2061,20 +2061,20 @@ TEST_F(AtomStyleTest, body_nparticle)
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
AtomState expected; AtomState expected;
expected.atom_style = "body"; expected.atom_style = "body";
expected.molecular = Atom::ATOMIC; expected.molecular = Atom::ATOMIC;
expected.tag_enable = 1; expected.tag_enable = 1;
expected.body_flag = 1; expected.body_flag = 1;
expected.rmass_flag = 1; expected.rmass_flag = 1;
expected.radius_flag = 1; expected.radius_flag = 1;
expected.angmom_flag = 1; expected.angmom_flag = 1;
expected.torque_flag = 1; expected.torque_flag = 1;
expected.has_type = true; expected.has_type = true;
expected.has_mask = true; expected.has_mask = true;
expected.has_image = true; expected.has_image = true;
expected.has_x = true; expected.has_x = true;
expected.has_v = true; expected.has_v = true;
expected.has_f = true; expected.has_f = true;
ASSERT_ATOM_STATE_EQ(lmp->atom, expected); ASSERT_ATOM_STATE_EQ(lmp->atom, expected);
@ -2631,22 +2631,22 @@ TEST_F(AtomStyleTest, template)
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
AtomState expected; AtomState expected;
expected.atom_style = "template"; expected.atom_style = "template";
expected.molecular = Atom::TEMPLATE; expected.molecular = Atom::TEMPLATE;
expected.nbondtypes = 2; expected.nbondtypes = 2;
expected.nangletypes = 2; expected.nangletypes = 2;
expected.tag_enable = 1; expected.tag_enable = 1;
expected.has_type = true; expected.has_type = true;
expected.has_mask = true; expected.has_mask = true;
expected.has_image = true; expected.has_image = true;
expected.has_x = true; expected.has_x = true;
expected.has_v = true; expected.has_v = true;
expected.has_f = true; expected.has_f = true;
expected.molecule_flag = 1; expected.molecule_flag = 1;
expected.molindex_flag = 1; expected.molindex_flag = 1;
expected.molatom_flag = 1; expected.molatom_flag = 1;
expected.nmolecule = 2; expected.nmolecule = 2;
expected.map_style = 3; expected.map_style = 3;
ASSERT_ATOM_STATE_EQ(lmp->atom, expected); ASSERT_ATOM_STATE_EQ(lmp->atom, expected);
@ -3027,23 +3027,23 @@ TEST_F(AtomStyleTest, template_charge)
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
AtomState expected; AtomState expected;
expected.atom_style = "hybrid"; expected.atom_style = "hybrid";
expected.molecular = Atom::TEMPLATE; expected.molecular = Atom::TEMPLATE;
expected.nbondtypes = 2; expected.nbondtypes = 2;
expected.nangletypes = 2; expected.nangletypes = 2;
expected.tag_enable = 1; expected.tag_enable = 1;
expected.has_type = true; expected.has_type = true;
expected.has_mask = true; expected.has_mask = true;
expected.has_image = true; expected.has_image = true;
expected.has_x = true; expected.has_x = true;
expected.has_v = true; expected.has_v = true;
expected.has_f = true; expected.has_f = true;
expected.molecule_flag = 1; expected.molecule_flag = 1;
expected.molindex_flag = 1; expected.molindex_flag = 1;
expected.molatom_flag = 1; expected.molatom_flag = 1;
expected.q_flag = 1; expected.q_flag = 1;
expected.nmolecule = 2; expected.nmolecule = 2;
expected.map_style = 3; expected.map_style = 3;
ASSERT_ATOM_STATE_EQ(lmp->atom, expected); ASSERT_ATOM_STATE_EQ(lmp->atom, expected);
@ -3407,7 +3407,6 @@ TEST_F(AtomStyleTest, template_charge)
ASSERT_EQ(lmp->atom->tag_consecutive(), 1); ASSERT_EQ(lmp->atom->tag_consecutive(), 1);
ASSERT_EQ(lmp->atom->map_tag_max, 16); ASSERT_EQ(lmp->atom->map_tag_max, 16);
type = lmp->atom->type; type = lmp->atom->type;
molecule = lmp->atom->molecule; molecule = lmp->atom->molecule;
molindex = lmp->atom->molindex; molindex = lmp->atom->molindex;
@ -3456,20 +3455,20 @@ TEST_F(AtomStyleTest, bond)
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
AtomState expected; AtomState expected;
expected.atom_style = "bond"; expected.atom_style = "bond";
expected.molecular = Atom::MOLECULAR; expected.molecular = Atom::MOLECULAR;
expected.tag_enable = 1; expected.tag_enable = 1;
expected.molecule_flag = 1; expected.molecule_flag = 1;
expected.has_type = true; expected.has_type = true;
expected.has_mask = true; expected.has_mask = true;
expected.has_image = true; expected.has_image = true;
expected.has_x = true; expected.has_x = true;
expected.has_v = true; expected.has_v = true;
expected.has_f = true; expected.has_f = true;
expected.has_bonds = true; expected.has_bonds = true;
expected.has_nspecial = true; expected.has_nspecial = true;
expected.has_special = true; expected.has_special = true;
expected.map_style = 3; expected.map_style = 3;
ASSERT_ATOM_STATE_EQ(lmp->atom, expected); ASSERT_ATOM_STATE_EQ(lmp->atom, expected);
@ -3804,21 +3803,21 @@ TEST_F(AtomStyleTest, angle)
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
AtomState expected; AtomState expected;
expected.atom_style = "angle"; expected.atom_style = "angle";
expected.molecular = Atom::MOLECULAR; expected.molecular = Atom::MOLECULAR;
expected.tag_enable = 1; expected.tag_enable = 1;
expected.molecule_flag = 1; expected.molecule_flag = 1;
expected.has_type = true; expected.has_type = true;
expected.has_mask = true; expected.has_mask = true;
expected.has_image = true; expected.has_image = true;
expected.has_x = true; expected.has_x = true;
expected.has_v = true; expected.has_v = true;
expected.has_f = true; expected.has_f = true;
expected.has_bonds = true; expected.has_bonds = true;
expected.has_angles = true; expected.has_angles = true;
expected.has_nspecial = true; expected.has_nspecial = true;
expected.has_special = true; expected.has_special = true;
expected.map_style = 3; expected.map_style = 3;
ASSERT_ATOM_STATE_EQ(lmp->atom, expected); ASSERT_ATOM_STATE_EQ(lmp->atom, expected);
@ -4164,28 +4163,28 @@ TEST_F(AtomStyleTest, full_ellipsoid)
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
AtomState expected; AtomState expected;
expected.atom_style = "hybrid"; expected.atom_style = "hybrid";
expected.molecular = Atom::MOLECULAR; expected.molecular = Atom::MOLECULAR;
expected.tag_enable = 1; expected.tag_enable = 1;
expected.molecule_flag = 1; expected.molecule_flag = 1;
expected.ellipsoid_flag = 1; expected.ellipsoid_flag = 1;
expected.q_flag = 1; expected.q_flag = 1;
expected.rmass_flag = 1; expected.rmass_flag = 1;
expected.torque_flag = 1; expected.torque_flag = 1;
expected.angmom_flag = 1; expected.angmom_flag = 1;
expected.has_type = true; expected.has_type = true;
expected.has_mask = true; expected.has_mask = true;
expected.has_image = true; expected.has_image = true;
expected.has_x = true; expected.has_x = true;
expected.has_v = true; expected.has_v = true;
expected.has_f = true; expected.has_f = true;
expected.has_bonds = true; expected.has_bonds = true;
expected.has_angles = true; expected.has_angles = true;
expected.has_dihedral = true; expected.has_dihedral = true;
expected.has_improper = true; expected.has_improper = true;
expected.has_nspecial = true; expected.has_nspecial = true;
expected.has_special = true; expected.has_special = true;
expected.map_style = 3; expected.map_style = 3;
ASSERT_ATOM_STATE_EQ(lmp->atom, expected); ASSERT_ATOM_STATE_EQ(lmp->atom, expected);

63
unittest/formats/test_dump_atom.cpp
View File

@ -11,30 +11,33 @@
See the README file in the top-level LAMMPS directory. See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
#include "gtest/gtest.h"
#include "gmock/gmock.h"
#include "fmt/format.h"
#include "utils.h"
#include "../testing/core.h" #include "../testing/core.h"
#include "../testing/systems/melt.h" #include "../testing/systems/melt.h"
#include "../testing/utils.h" #include "../testing/utils.h"
#include "fmt/format.h"
#include "utils.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include <string> #include <string>
using ::testing::Eq; using ::testing::Eq;
char * BINARY2TXT_BINARY = nullptr; char *BINARY2TXT_BINARY = nullptr;
class DumpAtomTest : public MeltTest { class DumpAtomTest : public MeltTest {
std::string dump_style = "atom"; std::string dump_style = "atom";
public: public:
void enable_triclinic() { void enable_triclinic()
{
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
command("change_box all triclinic"); command("change_box all triclinic");
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
} }
void generate_dump(std::string dump_file, std::string dump_modify_options, int ntimesteps) { void generate_dump(std::string dump_file, std::string dump_modify_options, int ntimesteps)
{
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
command(fmt::format("dump id all {} 1 {}", dump_style, dump_file)); command(fmt::format("dump id all {} 1 {}", dump_style, dump_file));
@ -46,7 +49,9 @@ public:
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
} }
void generate_text_and_binary_dump(std::string text_file, std::string binary_file, std::string dump_modify_options, int ntimesteps) { void generate_text_and_binary_dump(std::string text_file, std::string binary_file,
std::string dump_modify_options, int ntimesteps)
{
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
command(fmt::format("dump id0 all {} 1 {}", dump_style, text_file)); command(fmt::format("dump id0 all {} 1 {}", dump_style, text_file));
command(fmt::format("dump id1 all {} 1 {}", dump_style, binary_file)); command(fmt::format("dump id1 all {} 1 {}", dump_style, binary_file));
@ -60,7 +65,8 @@ public:
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
} }
std::string convert_binary_to_text(std::string binary_file) { std::string convert_binary_to_text(std::string binary_file)
{
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
std::string cmdline = fmt::format("{} {}", BINARY2TXT_BINARY, binary_file); std::string cmdline = fmt::format("{} {}", BINARY2TXT_BINARY, binary_file);
system(cmdline.c_str()); system(cmdline.c_str());
@ -290,9 +296,9 @@ TEST_F(DumpAtomTest, triclinic_with_image_run0)
TEST_F(DumpAtomTest, binary_run0) TEST_F(DumpAtomTest, binary_run0)
{ {
if(!BINARY2TXT_BINARY) GTEST_SKIP(); if (!BINARY2TXT_BINARY) GTEST_SKIP();
auto text_file = "dump_text_run0.melt"; auto text_file = "dump_text_run0.melt";
auto binary_file = "dump_binary_run0.melt.bin"; auto binary_file = "dump_binary_run0.melt.bin";
generate_text_and_binary_dump(text_file, binary_file, "", 0); generate_text_and_binary_dump(text_file, binary_file, "", 0);
@ -311,9 +317,9 @@ TEST_F(DumpAtomTest, binary_run0)
TEST_F(DumpAtomTest, binary_with_units_run0) TEST_F(DumpAtomTest, binary_with_units_run0)
{ {
if(!BINARY2TXT_BINARY) GTEST_SKIP(); if (!BINARY2TXT_BINARY) GTEST_SKIP();
auto text_file = "dump_text_with_units_run0.melt"; auto text_file = "dump_text_with_units_run0.melt";
auto binary_file = "dump_binary_with_units_run0.melt.bin"; auto binary_file = "dump_binary_with_units_run0.melt.bin";
generate_text_and_binary_dump(text_file, binary_file, "scale no units yes", 0); generate_text_and_binary_dump(text_file, binary_file, "scale no units yes", 0);
@ -332,9 +338,9 @@ TEST_F(DumpAtomTest, binary_with_units_run0)
TEST_F(DumpAtomTest, binary_with_time_run0) TEST_F(DumpAtomTest, binary_with_time_run0)
{ {
if(!BINARY2TXT_BINARY) GTEST_SKIP(); if (!BINARY2TXT_BINARY) GTEST_SKIP();
auto text_file = "dump_text_with_time_run0.melt"; auto text_file = "dump_text_with_time_run0.melt";
auto binary_file = "dump_binary_with_time_run0.melt.bin"; auto binary_file = "dump_binary_with_time_run0.melt.bin";
generate_text_and_binary_dump(text_file, binary_file, "scale no time yes", 0); generate_text_and_binary_dump(text_file, binary_file, "scale no time yes", 0);
@ -353,9 +359,9 @@ TEST_F(DumpAtomTest, binary_with_time_run0)
TEST_F(DumpAtomTest, binary_triclinic_run0) TEST_F(DumpAtomTest, binary_triclinic_run0)
{ {
if(!BINARY2TXT_BINARY) GTEST_SKIP(); if (!BINARY2TXT_BINARY) GTEST_SKIP();
auto text_file = "dump_text_tri_run0.melt"; auto text_file = "dump_text_tri_run0.melt";
auto binary_file = "dump_binary_tri_run0.melt.bin"; auto binary_file = "dump_binary_tri_run0.melt.bin";
enable_triclinic(); enable_triclinic();
@ -375,9 +381,9 @@ TEST_F(DumpAtomTest, binary_triclinic_run0)
TEST_F(DumpAtomTest, binary_triclinic_with_units_run0) TEST_F(DumpAtomTest, binary_triclinic_with_units_run0)
{ {
if(!BINARY2TXT_BINARY) GTEST_SKIP(); if (!BINARY2TXT_BINARY) GTEST_SKIP();
auto text_file = "dump_text_tri_with_units_run0.melt"; auto text_file = "dump_text_tri_with_units_run0.melt";
auto binary_file = "dump_binary_tri_with_units_run0.melt.bin"; auto binary_file = "dump_binary_tri_with_units_run0.melt.bin";
enable_triclinic(); enable_triclinic();
@ -397,9 +403,9 @@ TEST_F(DumpAtomTest, binary_triclinic_with_units_run0)
TEST_F(DumpAtomTest, binary_triclinic_with_time_run0) TEST_F(DumpAtomTest, binary_triclinic_with_time_run0)
{ {
if(!BINARY2TXT_BINARY) GTEST_SKIP(); if (!BINARY2TXT_BINARY) GTEST_SKIP();
auto text_file = "dump_text_tri_with_time_run0.melt"; auto text_file = "dump_text_tri_with_time_run0.melt";
auto binary_file = "dump_binary_tri_with_time_run0.melt.bin"; auto binary_file = "dump_binary_tri_with_time_run0.melt.bin";
enable_triclinic(); enable_triclinic();
@ -419,9 +425,9 @@ TEST_F(DumpAtomTest, binary_triclinic_with_time_run0)
TEST_F(DumpAtomTest, binary_triclinic_with_image_run0) TEST_F(DumpAtomTest, binary_triclinic_with_image_run0)
{ {
if(!BINARY2TXT_BINARY) GTEST_SKIP(); if (!BINARY2TXT_BINARY) GTEST_SKIP();
auto text_file = "dump_text_tri_with_image_run0.melt"; auto text_file = "dump_text_tri_with_image_run0.melt";
auto binary_file = "dump_binary_tri_with_image_run0.melt.bin"; auto binary_file = "dump_binary_tri_with_image_run0.melt.bin";
enable_triclinic(); enable_triclinic();
@ -501,8 +507,7 @@ TEST_F(DumpAtomTest, dump_modify_scale_invalid)
command("dump id all atom 1 dump.txt"); command("dump id all atom 1 dump.txt");
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
TEST_FAILURE(".*Illegal dump_modify command.*", TEST_FAILURE(".*Illegal dump_modify command.*", command("dump_modify id scale true"););
command("dump_modify id scale true"););
} }
TEST_F(DumpAtomTest, dump_modify_image_invalid) TEST_F(DumpAtomTest, dump_modify_image_invalid)
@ -511,8 +516,7 @@ TEST_F(DumpAtomTest, dump_modify_image_invalid)
command("dump id all atom 1 dump.txt"); command("dump id all atom 1 dump.txt");
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
TEST_FAILURE(".*Illegal dump_modify command.*", TEST_FAILURE(".*Illegal dump_modify command.*", command("dump_modify id image true"););
command("dump_modify id image true"););
} }
TEST_F(DumpAtomTest, dump_modify_invalid) TEST_F(DumpAtomTest, dump_modify_invalid)
@ -521,8 +525,7 @@ TEST_F(DumpAtomTest, dump_modify_invalid)
command("dump id all atom 1 dump.txt"); command("dump id all atom 1 dump.txt");
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
TEST_FAILURE(".*Illegal dump_modify command.*", TEST_FAILURE(".*Illegal dump_modify command.*", command("dump_modify id true"););
command("dump_modify id true"););
} }
TEST_F(DumpAtomTest, write_dump) TEST_F(DumpAtomTest, write_dump)
@ -547,7 +550,7 @@ TEST_F(DumpAtomTest, write_dump)
TEST_F(DumpAtomTest, binary_write_dump) TEST_F(DumpAtomTest, binary_write_dump)
{ {
if(!BINARY2TXT_BINARY) GTEST_SKIP(); if (!BINARY2TXT_BINARY) GTEST_SKIP();
auto reference = "dump_run0.melt.bin"; auto reference = "dump_run0.melt.bin";
auto dump_file = "write_dump_atom_run0_p0.melt.bin"; auto dump_file = "write_dump_atom_run0_p0.melt.bin";

69
unittest/formats/test_dump_atom_gz.cpp
View File

@ -11,30 +11,33 @@
See the README file in the top-level LAMMPS directory. See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
#include "gtest/gtest.h"
#include "gmock/gmock.h"
#include "fmt/format.h"
#include "utils.h"
#include "../testing/core.h" #include "../testing/core.h"
#include "../testing/systems/melt.h" #include "../testing/systems/melt.h"
#include "../testing/utils.h" #include "../testing/utils.h"
#include "fmt/format.h"
#include "utils.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include <string> #include <string>
char * GZIP_BINARY = nullptr; char *GZIP_BINARY = nullptr;
using ::testing::Eq; using ::testing::Eq;
class DumpAtomGZTest : public MeltTest { class DumpAtomGZTest : public MeltTest {
std::string dump_style = "atom"; std::string dump_style = "atom";
public: public:
void enable_triclinic() { void enable_triclinic()
{
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
command("change_box all triclinic"); command("change_box all triclinic");
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
} }
void generate_dump(std::string dump_file, std::string dump_modify_options, int ntimesteps) { void generate_dump(std::string dump_file, std::string dump_modify_options, int ntimesteps)
{
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
command(fmt::format("dump id all {} 1 {}", dump_style, dump_file)); command(fmt::format("dump id all {} 1 {}", dump_style, dump_file));
@ -46,7 +49,10 @@ public:
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
} }
void generate_text_and_compressed_dump(std::string text_file, std::string compressed_file, std::string compression_style, std::string dump_modify_options, int ntimesteps) { void generate_text_and_compressed_dump(std::string text_file, std::string compressed_file,
std::string compression_style,
std::string dump_modify_options, int ntimesteps)
{
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
command(fmt::format("dump id0 all {} 1 {}", dump_style, text_file)); command(fmt::format("dump id0 all {} 1 {}", dump_style, text_file));
command(fmt::format("dump id1 all {} 1 {}", compression_style, compressed_file)); command(fmt::format("dump id1 all {} 1 {}", compression_style, compressed_file));
@ -60,26 +66,27 @@ public:
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
} }
std::string convert_compressed_to_text(std::string compressed_file) { std::string convert_compressed_to_text(std::string compressed_file)
{
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
std::string converted_file = compressed_file.substr(0, compressed_file.find_last_of('.')); std::string converted_file = compressed_file.substr(0, compressed_file.find_last_of('.'));
std::string cmdline = fmt::format("{} -d -c {} > {}", GZIP_BINARY, compressed_file, converted_file); std::string cmdline =
fmt::format("{} -d -c {} > {}", GZIP_BINARY, compressed_file, converted_file);
system(cmdline.c_str()); system(cmdline.c_str());
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
return converted_file; return converted_file;
} }
}; };
//------------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------------
// GZ compressed files // GZ compressed files
//------------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------------
TEST_F(DumpAtomGZTest, compressed_run0) TEST_F(DumpAtomGZTest, compressed_run0)
{ {
if(!GZIP_BINARY) GTEST_SKIP(); if (!GZIP_BINARY) GTEST_SKIP();
auto text_file = "dump_gz_text_run0.melt"; auto text_file = "dump_gz_text_run0.melt";
auto compressed_file = "dump_gz_compressed_run0.melt.gz"; auto compressed_file = "dump_gz_compressed_run0.melt.gz";
generate_text_and_compressed_dump(text_file, compressed_file, "atom/gz", "", 0); generate_text_and_compressed_dump(text_file, compressed_file, "atom/gz", "", 0);
@ -101,12 +108,13 @@ TEST_F(DumpAtomGZTest, compressed_run0)
TEST_F(DumpAtomGZTest, compressed_with_units_run0) TEST_F(DumpAtomGZTest, compressed_with_units_run0)
{ {
if(!GZIP_BINARY) GTEST_SKIP(); if (!GZIP_BINARY) GTEST_SKIP();
auto text_file = "dump_gz_text_with_units_run0.melt"; auto text_file = "dump_gz_text_with_units_run0.melt";
auto compressed_file = "dump_gz_compressed_with_units_run0.melt.gz"; auto compressed_file = "dump_gz_compressed_with_units_run0.melt.gz";
generate_text_and_compressed_dump(text_file, compressed_file, "atom/gz", "scale no units yes", 0); generate_text_and_compressed_dump(text_file, compressed_file, "atom/gz", "scale no units yes",
0);
TearDown(); TearDown();
@ -124,12 +132,13 @@ TEST_F(DumpAtomGZTest, compressed_with_units_run0)
TEST_F(DumpAtomGZTest, compressed_with_time_run0) TEST_F(DumpAtomGZTest, compressed_with_time_run0)
{ {
if(!GZIP_BINARY) GTEST_SKIP(); if (!GZIP_BINARY) GTEST_SKIP();
auto text_file = "dump_gz_text_with_time_run0.melt"; auto text_file = "dump_gz_text_with_time_run0.melt";
auto compressed_file = "dump_gz_compressed_with_time_run0.melt.gz"; auto compressed_file = "dump_gz_compressed_with_time_run0.melt.gz";
generate_text_and_compressed_dump(text_file, compressed_file, "atom/gz", "scale no time yes", 0); generate_text_and_compressed_dump(text_file, compressed_file, "atom/gz", "scale no time yes",
0);
TearDown(); TearDown();
@ -147,9 +156,9 @@ TEST_F(DumpAtomGZTest, compressed_with_time_run0)
TEST_F(DumpAtomGZTest, compressed_triclinic_run0) TEST_F(DumpAtomGZTest, compressed_triclinic_run0)
{ {
if(!GZIP_BINARY) GTEST_SKIP(); if (!GZIP_BINARY) GTEST_SKIP();
auto text_file = "dump_gz_text_tri_run0.melt"; auto text_file = "dump_gz_text_tri_run0.melt";
auto compressed_file = "dump_gz_compressed_tri_run0.melt.gz"; auto compressed_file = "dump_gz_compressed_tri_run0.melt.gz";
enable_triclinic(); enable_triclinic();
@ -171,13 +180,14 @@ TEST_F(DumpAtomGZTest, compressed_triclinic_run0)
TEST_F(DumpAtomGZTest, compressed_triclinic_with_units_run0) TEST_F(DumpAtomGZTest, compressed_triclinic_with_units_run0)
{ {
if(!GZIP_BINARY) GTEST_SKIP(); if (!GZIP_BINARY) GTEST_SKIP();
auto text_file = "dump_gz_text_tri_with_units_run0.melt"; auto text_file = "dump_gz_text_tri_with_units_run0.melt";
auto compressed_file = "dump_gz_compressed_tri_with_units_run0.melt.gz"; auto compressed_file = "dump_gz_compressed_tri_with_units_run0.melt.gz";
enable_triclinic(); enable_triclinic();
generate_text_and_compressed_dump(text_file, compressed_file, "atom/gz", "scale no units yes", 0); generate_text_and_compressed_dump(text_file, compressed_file, "atom/gz", "scale no units yes",
0);
TearDown(); TearDown();
@ -195,13 +205,14 @@ TEST_F(DumpAtomGZTest, compressed_triclinic_with_units_run0)
TEST_F(DumpAtomGZTest, compressed_triclinic_with_time_run0) TEST_F(DumpAtomGZTest, compressed_triclinic_with_time_run0)
{ {
if(!GZIP_BINARY) GTEST_SKIP(); if (!GZIP_BINARY) GTEST_SKIP();
auto text_file = "dump_gz_text_tri_with_time_run0.melt"; auto text_file = "dump_gz_text_tri_with_time_run0.melt";
auto compressed_file = "dump_gz_compressed_tri_with_time_run0.melt.gz"; auto compressed_file = "dump_gz_compressed_tri_with_time_run0.melt.gz";
enable_triclinic(); enable_triclinic();
generate_text_and_compressed_dump(text_file, compressed_file, "atom/gz", "scale no time yes", 0); generate_text_and_compressed_dump(text_file, compressed_file, "atom/gz", "scale no time yes",
0);
TearDown(); TearDown();
@ -219,9 +230,9 @@ TEST_F(DumpAtomGZTest, compressed_triclinic_with_time_run0)
TEST_F(DumpAtomGZTest, compressed_triclinic_with_image_run0) TEST_F(DumpAtomGZTest, compressed_triclinic_with_image_run0)
{ {
if(!GZIP_BINARY) GTEST_SKIP(); if (!GZIP_BINARY) GTEST_SKIP();
auto text_file = "dump_gz_text_tri_with_image_run0.melt"; auto text_file = "dump_gz_text_tri_with_image_run0.melt";
auto compressed_file = "dump_gz_compressed_tri_with_image_run0.melt.gz"; auto compressed_file = "dump_gz_compressed_tri_with_image_run0.melt.gz";
enable_triclinic(); enable_triclinic();

69
unittest/formats/test_dump_atom_zstd.cpp
View File

@ -11,30 +11,33 @@
See the README file in the top-level LAMMPS directory. See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
#include "gtest/gtest.h"
#include "gmock/gmock.h"
#include "fmt/format.h"
#include "utils.h"
#include "../testing/core.h" #include "../testing/core.h"
#include "../testing/systems/melt.h" #include "../testing/systems/melt.h"
#include "../testing/utils.h" #include "../testing/utils.h"
#include "fmt/format.h"
#include "utils.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include <string> #include <string>
char * ZSTD_BINARY = nullptr; char *ZSTD_BINARY = nullptr;
using ::testing::Eq; using ::testing::Eq;
class DumpAtomZSTDTest : public MeltTest { class DumpAtomZSTDTest : public MeltTest {
std::string dump_style = "atom"; std::string dump_style = "atom";
public: public:
void enable_triclinic() { void enable_triclinic()
{
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
command("change_box all triclinic"); command("change_box all triclinic");
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
} }
void generate_dump(std::string dump_file, std::string dump_modify_options, int ntimesteps) { void generate_dump(std::string dump_file, std::string dump_modify_options, int ntimesteps)
{
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
command(fmt::format("dump id all {} 1 {}", dump_style, dump_file)); command(fmt::format("dump id all {} 1 {}", dump_style, dump_file));
@ -46,7 +49,10 @@ public:
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
} }
void generate_text_and_compressed_dump(std::string text_file, std::string compressed_file, std::string compression_style, std::string dump_modify_options, int ntimesteps) { void generate_text_and_compressed_dump(std::string text_file, std::string compressed_file,
std::string compression_style,
std::string dump_modify_options, int ntimesteps)
{
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
command(fmt::format("dump id0 all {} 1 {}", dump_style, text_file)); command(fmt::format("dump id0 all {} 1 {}", dump_style, text_file));
command(fmt::format("dump id1 all {} 1 {}", compression_style, compressed_file)); command(fmt::format("dump id1 all {} 1 {}", compression_style, compressed_file));
@ -60,26 +66,27 @@ public:
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
} }
std::string convert_compressed_to_text(std::string compressed_file) { std::string convert_compressed_to_text(std::string compressed_file)
{
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
std::string converted_file = compressed_file.substr(0, compressed_file.find_last_of('.')); std::string converted_file = compressed_file.substr(0, compressed_file.find_last_of('.'));
std::string cmdline = fmt::format("{} -d -c {} > {}", ZSTD_BINARY, compressed_file, converted_file); std::string cmdline =
fmt::format("{} -d -c {} > {}", ZSTD_BINARY, compressed_file, converted_file);
system(cmdline.c_str()); system(cmdline.c_str());
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
return converted_file; return converted_file;
} }
}; };
//------------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------------
// ZSTD compressed files // ZSTD compressed files
//------------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------------
TEST_F(DumpAtomZSTDTest, compressed_run0) TEST_F(DumpAtomZSTDTest, compressed_run0)
{ {
if(!ZSTD_BINARY) GTEST_SKIP(); if (!ZSTD_BINARY) GTEST_SKIP();
auto text_file = "dump_zstd_text_run0.melt"; auto text_file = "dump_zstd_text_run0.melt";
auto compressed_file = "dump_zstd_compressed_run0.melt.zst"; auto compressed_file = "dump_zstd_compressed_run0.melt.zst";
generate_text_and_compressed_dump(text_file, compressed_file, "atom/zstd", "", 0); generate_text_and_compressed_dump(text_file, compressed_file, "atom/zstd", "", 0);
@ -102,12 +109,13 @@ TEST_F(DumpAtomZSTDTest, compressed_run0)
TEST_F(DumpAtomZSTDTest, compressed_with_units_run0) TEST_F(DumpAtomZSTDTest, compressed_with_units_run0)
{ {
if(!ZSTD_BINARY) GTEST_SKIP(); if (!ZSTD_BINARY) GTEST_SKIP();
auto text_file = "dump_zstd_text_with_units_run0.melt"; auto text_file = "dump_zstd_text_with_units_run0.melt";
auto compressed_file = "dump_zstd_compressed_with_units_run0.melt.zst"; auto compressed_file = "dump_zstd_compressed_with_units_run0.melt.zst";
generate_text_and_compressed_dump(text_file, compressed_file, "atom/zstd", "scale no units yes", 0); generate_text_and_compressed_dump(text_file, compressed_file, "atom/zstd", "scale no units yes",
0);
// make sure file is closed // make sure file is closed
TearDown(); TearDown();
@ -126,12 +134,13 @@ TEST_F(DumpAtomZSTDTest, compressed_with_units_run0)
TEST_F(DumpAtomZSTDTest, compressed_with_time_run0) TEST_F(DumpAtomZSTDTest, compressed_with_time_run0)
{ {
if(!ZSTD_BINARY) GTEST_SKIP(); if (!ZSTD_BINARY) GTEST_SKIP();
auto text_file = "dump_zstd_text_with_time_run0.melt"; auto text_file = "dump_zstd_text_with_time_run0.melt";
auto compressed_file = "dump_zstd_compressed_with_time_run0.melt.zst"; auto compressed_file = "dump_zstd_compressed_with_time_run0.melt.zst";
generate_text_and_compressed_dump(text_file, compressed_file, "atom/zstd", "scale no time yes", 0); generate_text_and_compressed_dump(text_file, compressed_file, "atom/zstd", "scale no time yes",
0);
// make sure file is closed // make sure file is closed
TearDown(); TearDown();
@ -150,9 +159,9 @@ TEST_F(DumpAtomZSTDTest, compressed_with_time_run0)
TEST_F(DumpAtomZSTDTest, compressed_triclinic_run0) TEST_F(DumpAtomZSTDTest, compressed_triclinic_run0)
{ {
if(!ZSTD_BINARY) GTEST_SKIP(); if (!ZSTD_BINARY) GTEST_SKIP();
auto text_file = "dump_zstd_text_tri_run0.melt"; auto text_file = "dump_zstd_text_tri_run0.melt";
auto compressed_file = "dump_zstd_compressed_tri_run0.melt.zst"; auto compressed_file = "dump_zstd_compressed_tri_run0.melt.zst";
enable_triclinic(); enable_triclinic();
@ -175,13 +184,14 @@ TEST_F(DumpAtomZSTDTest, compressed_triclinic_run0)
TEST_F(DumpAtomZSTDTest, compressed_triclinic_with_units_run0) TEST_F(DumpAtomZSTDTest, compressed_triclinic_with_units_run0)
{ {
if(!ZSTD_BINARY) GTEST_SKIP(); if (!ZSTD_BINARY) GTEST_SKIP();
auto text_file = "dump_zstd_text_tri_with_units_run0.melt"; auto text_file = "dump_zstd_text_tri_with_units_run0.melt";
auto compressed_file = "dump_zstd_compressed_tri_with_units_run0.melt.zst"; auto compressed_file = "dump_zstd_compressed_tri_with_units_run0.melt.zst";
enable_triclinic(); enable_triclinic();
generate_text_and_compressed_dump(text_file, compressed_file, "atom/zstd", "scale no units yes", 0); generate_text_and_compressed_dump(text_file, compressed_file, "atom/zstd", "scale no units yes",
0);
// make sure file is closed // make sure file is closed
TearDown(); TearDown();
@ -200,13 +210,14 @@ TEST_F(DumpAtomZSTDTest, compressed_triclinic_with_units_run0)
TEST_F(DumpAtomZSTDTest, compressed_triclinic_with_time_run0) TEST_F(DumpAtomZSTDTest, compressed_triclinic_with_time_run0)
{ {
if(!ZSTD_BINARY) GTEST_SKIP(); if (!ZSTD_BINARY) GTEST_SKIP();
auto text_file = "dump_zstd_text_tri_with_time_run0.melt"; auto text_file = "dump_zstd_text_tri_with_time_run0.melt";
auto compressed_file = "dump_zstd_compressed_tri_with_time_run0.melt.zst"; auto compressed_file = "dump_zstd_compressed_tri_with_time_run0.melt.zst";
enable_triclinic(); enable_triclinic();
generate_text_and_compressed_dump(text_file, compressed_file, "atom/zstd", "scale no time yes", 0); generate_text_and_compressed_dump(text_file, compressed_file, "atom/zstd", "scale no time yes",
0);
// make sure file is closed // make sure file is closed
TearDown(); TearDown();
@ -225,9 +236,9 @@ TEST_F(DumpAtomZSTDTest, compressed_triclinic_with_time_run0)
TEST_F(DumpAtomZSTDTest, compressed_triclinic_with_image_run0) TEST_F(DumpAtomZSTDTest, compressed_triclinic_with_image_run0)
{ {
if(!ZSTD_BINARY) GTEST_SKIP(); if (!ZSTD_BINARY) GTEST_SKIP();
auto text_file = "dump_zstd_text_tri_with_image_run0.melt"; auto text_file = "dump_zstd_text_tri_with_image_run0.melt";
auto compressed_file = "dump_zstd_compressed_tri_with_image_run0.melt.zst"; auto compressed_file = "dump_zstd_compressed_tri_with_image_run0.melt.zst";
enable_triclinic(); enable_triclinic();

32
unittest/formats/test_dump_cfg.cpp
View File

@ -11,20 +11,23 @@
See the README file in the top-level LAMMPS directory. See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
#include "gtest/gtest.h"
#include "gmock/gmock.h"
#include "fmt/format.h"
#include "utils.h"
#include "../testing/core.h" #include "../testing/core.h"
#include "../testing/systems/melt.h" #include "../testing/systems/melt.h"
#include "../testing/utils.h" #include "../testing/utils.h"
#include "fmt/format.h"
#include "utils.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
using ::testing::Eq; using ::testing::Eq;
class DumpCfgTest : public MeltTest { class DumpCfgTest : public MeltTest {
std::string dump_style = "cfg"; std::string dump_style = "cfg";
public: public:
void generate_dump(std::string dump_file, std::string fields, std::string dump_modify_options, int ntimesteps) { void generate_dump(std::string dump_file, std::string fields, std::string dump_modify_options,
int ntimesteps)
{
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
command(fmt::format("dump id all {} 1 {} {}", dump_style, dump_file, fields)); command(fmt::format("dump id all {} 1 {} {}", dump_style, dump_file, fields));
@ -40,28 +43,26 @@ public:
TEST_F(DumpCfgTest, invalid_options) TEST_F(DumpCfgTest, invalid_options)
{ {
TEST_FAILURE(".*Dump cfg arguments must start with 'mass type xs ys zs'.*", TEST_FAILURE(".*Dump cfg arguments must start with 'mass type xs ys zs'.*",
command("dump id all cfg 1 dump.cfg id type proc procp1 mass x y z"); command("dump id all cfg 1 dump.cfg id type proc procp1 mass x y z"););
);
} }
TEST_F(DumpCfgTest, require_multifile) TEST_F(DumpCfgTest, require_multifile)
{ {
auto dump_file = "dump.melt.cfg_run.cfg"; auto dump_file = "dump.melt.cfg_run.cfg";
auto fields = "mass type xs ys zs id proc procp1 x y z ix iy iz xu yu zu xsu ysu zsu vx vy vz fx fy fz"; auto fields =
"mass type xs ys zs id proc procp1 x y z ix iy iz xu yu zu xsu ysu zsu vx vy vz fx fy fz";
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
command(fmt::format("dump id all cfg 1 {} {}", dump_file, fields)); command(fmt::format("dump id all cfg 1 {} {}", dump_file, fields));
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
TEST_FAILURE(".*Dump cfg requires one snapshot per file.*", TEST_FAILURE(".*Dump cfg requires one snapshot per file.*", command("run 0"););
command("run 0");
);
} }
TEST_F(DumpCfgTest, run0) TEST_F(DumpCfgTest, run0)
{ {
auto dump_file = "dump_cfg_run*.melt.cfg"; auto dump_file = "dump_cfg_run*.melt.cfg";
auto fields = "mass type xs ys zs id proc procp1 x y z ix iy iz vx vy vz fx fy fz"; auto fields = "mass type xs ys zs id proc procp1 x y z ix iy iz vx vy vz fx fy fz";
generate_dump(dump_file, fields, "", 0); generate_dump(dump_file, fields, "", 0);
@ -75,7 +76,7 @@ TEST_F(DumpCfgTest, run0)
TEST_F(DumpCfgTest, unwrap_run0) TEST_F(DumpCfgTest, unwrap_run0)
{ {
auto dump_file = "dump_cfg_unwrap_run*.melt.cfg"; auto dump_file = "dump_cfg_unwrap_run*.melt.cfg";
auto fields = "mass type xsu ysu zsu id proc procp1 x y z ix iy iz vx vy vz fx fy fz"; auto fields = "mass type xsu ysu zsu id proc procp1 x y z ix iy iz vx vy vz fx fy fz";
generate_dump(dump_file, fields, "", 0); generate_dump(dump_file, fields, "", 0);
@ -89,7 +90,7 @@ TEST_F(DumpCfgTest, unwrap_run0)
TEST_F(DumpCfgTest, no_buffer_run0) TEST_F(DumpCfgTest, no_buffer_run0)
{ {
auto dump_file = "dump_cfg_no_buffer_run*.melt.cfg"; auto dump_file = "dump_cfg_no_buffer_run*.melt.cfg";
auto fields = "mass type xsu ysu zsu id proc procp1 x y z ix iy iz vx vy vz fx fy fz"; auto fields = "mass type xsu ysu zsu id proc procp1 x y z ix iy iz vx vy vz fx fy fz";
generate_dump(dump_file, fields, "buffer no", 0); generate_dump(dump_file, fields, "buffer no", 0);
@ -103,7 +104,7 @@ TEST_F(DumpCfgTest, no_buffer_run0)
TEST_F(DumpCfgTest, no_unwrap_no_buffer_run0) TEST_F(DumpCfgTest, no_unwrap_no_buffer_run0)
{ {
auto dump_file = "dump_cfg_no_unwrap_no_buffer_run*.melt.cfg"; auto dump_file = "dump_cfg_no_unwrap_no_buffer_run*.melt.cfg";
auto fields = "mass type xs ys zs id proc procp1 x y z ix iy iz vx vy vz fx fy fz"; auto fields = "mass type xs ys zs id proc procp1 x y z ix iy iz vx vy vz fx fy fz";
generate_dump(dump_file, fields, "buffer no", 0); generate_dump(dump_file, fields, "buffer no", 0);
@ -114,7 +115,6 @@ TEST_F(DumpCfgTest, no_unwrap_no_buffer_run0)
delete_file("dump_cfg_no_unwrap_no_buffer_run0.melt.cfg"); delete_file("dump_cfg_no_unwrap_no_buffer_run0.melt.cfg");
} }
int main(int argc, char **argv) int main(int argc, char **argv)
{ {
MPI_Init(&argc, &argv); MPI_Init(&argc, &argv);

44
unittest/formats/test_dump_cfg_gz.cpp
View File

@ -11,23 +11,26 @@
See the README file in the top-level LAMMPS directory. See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
#include "gtest/gtest.h"
#include "gmock/gmock.h"
#include "fmt/format.h"
#include "utils.h"
#include "../testing/core.h" #include "../testing/core.h"
#include "../testing/systems/melt.h" #include "../testing/systems/melt.h"
#include "../testing/utils.h" #include "../testing/utils.h"
#include "fmt/format.h"
#include "utils.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
char * GZIP_BINARY = nullptr; char *GZIP_BINARY = nullptr;
using ::testing::Eq; using ::testing::Eq;
class DumpCfgGZTest : public MeltTest { class DumpCfgGZTest : public MeltTest {
std::string dump_style = "cfg"; std::string dump_style = "cfg";
public: public:
void generate_text_and_compressed_dump(std::string text_file, std::string compressed_file, std::string compression_style, void generate_text_and_compressed_dump(std::string text_file, std::string compressed_file,
std::string fields, std::string dump_modify_options, int ntimesteps) { std::string compression_style, std::string fields,
std::string dump_modify_options, int ntimesteps)
{
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
command(fmt::format("dump id0 all {} 1 {} {}", dump_style, text_file, fields)); command(fmt::format("dump id0 all {} 1 {} {}", dump_style, text_file, fields));
command(fmt::format("dump id1 all {} 1 {} {}", compression_style, compressed_file, fields)); command(fmt::format("dump id1 all {} 1 {} {}", compression_style, compressed_file, fields));
@ -41,10 +44,12 @@ public:
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
} }
std::string convert_compressed_to_text(std::string compressed_file) { std::string convert_compressed_to_text(std::string compressed_file)
{
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
std::string converted_file = compressed_file.substr(0, compressed_file.find_last_of('.')); std::string converted_file = compressed_file.substr(0, compressed_file.find_last_of('.'));
std::string cmdline = fmt::format("{} -d -c {} > {}", GZIP_BINARY, compressed_file, converted_file); std::string cmdline =
fmt::format("{} -d -c {} > {}", GZIP_BINARY, compressed_file, converted_file);
system(cmdline.c_str()); system(cmdline.c_str());
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
return converted_file; return converted_file;
@ -53,13 +58,13 @@ public:
TEST_F(DumpCfgGZTest, compressed_run0) TEST_F(DumpCfgGZTest, compressed_run0)
{ {
if(!GZIP_BINARY) GTEST_SKIP(); if (!GZIP_BINARY) GTEST_SKIP();
auto text_files = "dump_cfg_gz_text_run*.melt.cfg"; auto text_files = "dump_cfg_gz_text_run*.melt.cfg";
auto compressed_files = "dump_cfg_gz_compressed_run*.melt.cfg.gz"; auto compressed_files = "dump_cfg_gz_compressed_run*.melt.cfg.gz";
auto text_file = "dump_cfg_gz_text_run0.melt.cfg"; auto text_file = "dump_cfg_gz_text_run0.melt.cfg";
auto compressed_file = "dump_cfg_gz_compressed_run0.melt.cfg.gz"; auto compressed_file = "dump_cfg_gz_compressed_run0.melt.cfg.gz";
auto fields = "mass type xs ys zs id proc procp1 x y z ix iy iz vx vy vz fx fy fz"; auto fields = "mass type xs ys zs id proc procp1 x y z ix iy iz vx vy vz fx fy fz";
generate_text_and_compressed_dump(text_files, compressed_files, "cfg/gz", fields, "", 0); generate_text_and_compressed_dump(text_files, compressed_files, "cfg/gz", fields, "", 0);
@ -77,16 +82,15 @@ TEST_F(DumpCfgGZTest, compressed_run0)
delete_file(converted_file); delete_file(converted_file);
} }
TEST_F(DumpCfgGZTest, compressed_unwrap_run0) TEST_F(DumpCfgGZTest, compressed_unwrap_run0)
{ {
if(!GZIP_BINARY) GTEST_SKIP(); if (!GZIP_BINARY) GTEST_SKIP();
auto text_files = "dump_cfg_unwrap_gz_text_run*.melt.cfg"; auto text_files = "dump_cfg_unwrap_gz_text_run*.melt.cfg";
auto compressed_files = "dump_cfg_unwrap_gz_compressed_run*.melt.cfg.gz"; auto compressed_files = "dump_cfg_unwrap_gz_compressed_run*.melt.cfg.gz";
auto text_file = "dump_cfg_unwrap_gz_text_run0.melt.cfg"; auto text_file = "dump_cfg_unwrap_gz_text_run0.melt.cfg";
auto compressed_file = "dump_cfg_unwrap_gz_compressed_run0.melt.cfg.gz"; auto compressed_file = "dump_cfg_unwrap_gz_compressed_run0.melt.cfg.gz";
auto fields = "mass type xsu ysu zsu id proc procp1 x y z ix iy iz vx vy vz fx fy fz"; auto fields = "mass type xsu ysu zsu id proc procp1 x y z ix iy iz vx vy vz fx fy fz";
generate_text_and_compressed_dump(text_files, compressed_files, "cfg/gz", fields, "", 0); generate_text_and_compressed_dump(text_files, compressed_files, "cfg/gz", fields, "", 0);

44
unittest/formats/test_dump_cfg_zstd.cpp
View File

@ -11,23 +11,26 @@
See the README file in the top-level LAMMPS directory. See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
#include "gtest/gtest.h"
#include "gmock/gmock.h"
#include "fmt/format.h"
#include "utils.h"
#include "../testing/core.h" #include "../testing/core.h"
#include "../testing/systems/melt.h" #include "../testing/systems/melt.h"
#include "../testing/utils.h" #include "../testing/utils.h"
#include "fmt/format.h"
#include "utils.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
char * ZSTD_BINARY = nullptr; char *ZSTD_BINARY = nullptr;
using ::testing::Eq; using ::testing::Eq;
class DumpCfgZstdTest : public MeltTest { class DumpCfgZstdTest : public MeltTest {
std::string dump_style = "cfg"; std::string dump_style = "cfg";
public: public:
void generate_text_and_compressed_dump(std::string text_file, std::string compressed_file, std::string compression_style, void generate_text_and_compressed_dump(std::string text_file, std::string compressed_file,
std::string fields, std::string dump_modify_options, int ntimesteps) { std::string compression_style, std::string fields,
std::string dump_modify_options, int ntimesteps)
{
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
command(fmt::format("dump id0 all {} 1 {} {}", dump_style, text_file, fields)); command(fmt::format("dump id0 all {} 1 {} {}", dump_style, text_file, fields));
command(fmt::format("dump id1 all {} 1 {} {}", compression_style, compressed_file, fields)); command(fmt::format("dump id1 all {} 1 {} {}", compression_style, compressed_file, fields));
@ -41,10 +44,12 @@ public:
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
} }
std::string convert_compressed_to_text(std::string compressed_file) { std::string convert_compressed_to_text(std::string compressed_file)
{
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
std::string converted_file = compressed_file.substr(0, compressed_file.find_last_of('.')); std::string converted_file = compressed_file.substr(0, compressed_file.find_last_of('.'));
std::string cmdline = fmt::format("{} -d -c {} > {}", ZSTD_BINARY, compressed_file, converted_file); std::string cmdline =
fmt::format("{} -d -c {} > {}", ZSTD_BINARY, compressed_file, converted_file);
system(cmdline.c_str()); system(cmdline.c_str());
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
return converted_file; return converted_file;
@ -53,13 +58,13 @@ public:
TEST_F(DumpCfgZstdTest, compressed_run0) TEST_F(DumpCfgZstdTest, compressed_run0)
{ {
if(!ZSTD_BINARY) GTEST_SKIP(); if (!ZSTD_BINARY) GTEST_SKIP();
auto text_files = "dump_cfg_zstd_text_run*.melt.cfg"; auto text_files = "dump_cfg_zstd_text_run*.melt.cfg";
auto compressed_files = "dump_cfg_zstd_compressed_run*.melt.cfg.zst"; auto compressed_files = "dump_cfg_zstd_compressed_run*.melt.cfg.zst";
auto text_file = "dump_cfg_zstd_text_run0.melt.cfg"; auto text_file = "dump_cfg_zstd_text_run0.melt.cfg";
auto compressed_file = "dump_cfg_zstd_compressed_run0.melt.cfg.zst"; auto compressed_file = "dump_cfg_zstd_compressed_run0.melt.cfg.zst";
auto fields = "mass type xs ys zs id proc procp1 x y z ix iy iz vx vy vz fx fy fz"; auto fields = "mass type xs ys zs id proc procp1 x y z ix iy iz vx vy vz fx fy fz";
generate_text_and_compressed_dump(text_files, compressed_files, "cfg/zstd", fields, "", 0); generate_text_and_compressed_dump(text_files, compressed_files, "cfg/zstd", fields, "", 0);
@ -77,16 +82,15 @@ TEST_F(DumpCfgZstdTest, compressed_run0)
delete_file(converted_file); delete_file(converted_file);
} }
TEST_F(DumpCfgZstdTest, compressed_unwrap_run0) TEST_F(DumpCfgZstdTest, compressed_unwrap_run0)
{ {
if(!ZSTD_BINARY) GTEST_SKIP(); if (!ZSTD_BINARY) GTEST_SKIP();
auto text_files = "dump_cfg_unwrap_zstd_text_run*.melt.cfg"; auto text_files = "dump_cfg_unwrap_zstd_text_run*.melt.cfg";
auto compressed_files = "dump_cfg_unwrap_zstd_compressed_run*.melt.cfg.zst"; auto compressed_files = "dump_cfg_unwrap_zstd_compressed_run*.melt.cfg.zst";
auto text_file = "dump_cfg_unwrap_zstd_text_run0.melt.cfg"; auto text_file = "dump_cfg_unwrap_zstd_text_run0.melt.cfg";
auto compressed_file = "dump_cfg_unwrap_zstd_compressed_run0.melt.cfg.zst"; auto compressed_file = "dump_cfg_unwrap_zstd_compressed_run0.melt.cfg.zst";
auto fields = "mass type xsu ysu zsu id proc procp1 x y z ix iy iz vx vy vz fx fy fz"; auto fields = "mass type xsu ysu zsu id proc procp1 x y z ix iy iz vx vy vz fx fy fz";
generate_text_and_compressed_dump(text_files, compressed_files, "cfg/zstd", fields, "", 0); generate_text_and_compressed_dump(text_files, compressed_files, "cfg/zstd", fields, "", 0);

57
unittest/formats/test_dump_custom.cpp
View File

@ -11,28 +11,32 @@
See the README file in the top-level LAMMPS directory. See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
#include "gtest/gtest.h"
#include "gmock/gmock.h"
#include "fmt/format.h"
#include "utils.h"
#include "../testing/core.h" #include "../testing/core.h"
#include "../testing/systems/melt.h" #include "../testing/systems/melt.h"
#include "../testing/utils.h" #include "../testing/utils.h"
#include "fmt/format.h"
#include "utils.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
using ::testing::Eq; using ::testing::Eq;
char * BINARY2TXT_BINARY = nullptr; char *BINARY2TXT_BINARY = nullptr;
class DumpCustomTest : public MeltTest { class DumpCustomTest : public MeltTest {
std::string dump_style = "custom"; std::string dump_style = "custom";
public: public:
void enable_triclinic() { void enable_triclinic()
{
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
command("change_box all triclinic"); command("change_box all triclinic");
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
} }
void generate_dump(std::string dump_file, std::string fields, std::string dump_modify_options, int ntimesteps) { void generate_dump(std::string dump_file, std::string fields, std::string dump_modify_options,
int ntimesteps)
{
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
command(fmt::format("dump id all {} 1 {} {}", dump_style, dump_file, fields)); command(fmt::format("dump id all {} 1 {} {}", dump_style, dump_file, fields));
@ -44,8 +48,10 @@ public:
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
} }
void generate_text_and_binary_dump(std::string text_file, std::string binary_file, std::string fields, void generate_text_and_binary_dump(std::string text_file, std::string binary_file,
std::string dump_modify_options, int ntimesteps) { std::string fields, std::string dump_modify_options,
int ntimesteps)
{
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
command(fmt::format("dump id0 all {} 1 {} {}", dump_style, text_file, fields)); command(fmt::format("dump id0 all {} 1 {} {}", dump_style, text_file, fields));
command(fmt::format("dump id1 all {} 1 {} {}", dump_style, binary_file, fields)); command(fmt::format("dump id1 all {} 1 {} {}", dump_style, binary_file, fields));
@ -59,7 +65,8 @@ public:
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
} }
std::string convert_binary_to_text(std::string binary_file) { std::string convert_binary_to_text(std::string binary_file)
{
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
std::string cmdline = fmt::format("{} {}", BINARY2TXT_BINARY, binary_file); std::string cmdline = fmt::format("{} {}", BINARY2TXT_BINARY, binary_file);
system(cmdline.c_str()); system(cmdline.c_str());
@ -71,7 +78,8 @@ public:
TEST_F(DumpCustomTest, run1) TEST_F(DumpCustomTest, run1)
{ {
auto dump_file = "dump_custom_run1.melt"; auto dump_file = "dump_custom_run1.melt";
auto fields = "id type proc procp1 mass x y z ix iy iz xs ys zs xu yu zu xsu ysu zsu vx vy vz fx fy fz"; auto fields =
"id type proc procp1 mass x y z ix iy iz xs ys zs xu yu zu xsu ysu zsu vx vy vz fx fy fz";
generate_dump(dump_file, fields, "units yes", 1); generate_dump(dump_file, fields, "units yes", 1);
@ -88,7 +96,7 @@ TEST_F(DumpCustomTest, run1)
TEST_F(DumpCustomTest, thresh_run0) TEST_F(DumpCustomTest, thresh_run0)
{ {
auto dump_file = "dump_custom_thresh_run0.melt"; auto dump_file = "dump_custom_thresh_run0.melt";
auto fields = "id type x y z"; auto fields = "id type x y z";
generate_dump(dump_file, fields, "units yes thresh x < 1 thresh y < 1 thresh z < 1", 0); generate_dump(dump_file, fields, "units yes thresh x < 1 thresh y < 1 thresh z < 1", 0);
@ -109,7 +117,7 @@ TEST_F(DumpCustomTest, compute_run0)
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
auto dump_file = "dump_custom_compute_run0.melt"; auto dump_file = "dump_custom_compute_run0.melt";
auto fields = "id type x y z c_comp[1] c_comp[2] c_comp[3]"; auto fields = "id type x y z c_comp[1] c_comp[2] c_comp[3]";
generate_dump(dump_file, fields, "units yes", 0); generate_dump(dump_file, fields, "units yes", 0);
@ -130,7 +138,7 @@ TEST_F(DumpCustomTest, fix_run0)
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
auto dump_file = "dump_custom_compute_run0.melt"; auto dump_file = "dump_custom_compute_run0.melt";
auto fields = "id x y z f_numdiff[1] f_numdiff[2] f_numdiff[3]"; auto fields = "id x y z f_numdiff[1] f_numdiff[2] f_numdiff[3]";
generate_dump(dump_file, fields, "units yes", 0); generate_dump(dump_file, fields, "units yes", 0);
@ -152,7 +160,7 @@ TEST_F(DumpCustomTest, custom_run0)
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
auto dump_file = "dump_custom_custom_run0.melt"; auto dump_file = "dump_custom_custom_run0.melt";
auto fields = "id x y z i_flag1 d_flag2"; auto fields = "id x y z i_flag1 d_flag2";
generate_dump(dump_file, fields, "units yes", 0); generate_dump(dump_file, fields, "units yes", 0);
@ -168,9 +176,9 @@ TEST_F(DumpCustomTest, custom_run0)
TEST_F(DumpCustomTest, binary_run1) TEST_F(DumpCustomTest, binary_run1)
{ {
if(!BINARY2TXT_BINARY) GTEST_SKIP(); if (!BINARY2TXT_BINARY) GTEST_SKIP();
auto text_file = "dump_custom_text_run1.melt"; auto text_file = "dump_custom_text_run1.melt";
auto binary_file = "dump_custom_binary_run1.melt.bin"; auto binary_file = "dump_custom_binary_run1.melt.bin";
auto fields = "id type proc x y z ix iy iz xs ys zs xu yu zu xsu ysu zsu vx vy vz fx fy fz"; auto fields = "id type proc x y z ix iy iz xs ys zs xu yu zu xsu ysu zsu vx vy vz fx fy fz";
@ -191,7 +199,7 @@ TEST_F(DumpCustomTest, binary_run1)
TEST_F(DumpCustomTest, triclinic_run1) TEST_F(DumpCustomTest, triclinic_run1)
{ {
auto dump_file = "dump_custom_tri_run1.melt"; auto dump_file = "dump_custom_tri_run1.melt";
auto fields = "id type proc x y z ix iy iz xs ys zs xu yu zu xsu ysu zsu vx vy vz fx fy fz"; auto fields = "id type proc x y z ix iy iz xs ys zs xu yu zu xsu ysu zsu vx vy vz fx fy fz";
enable_triclinic(); enable_triclinic();
@ -209,12 +217,12 @@ TEST_F(DumpCustomTest, triclinic_run1)
TEST_F(DumpCustomTest, binary_triclinic_run1) TEST_F(DumpCustomTest, binary_triclinic_run1)
{ {
if(!BINARY2TXT_BINARY) GTEST_SKIP(); if (!BINARY2TXT_BINARY) GTEST_SKIP();
auto text_file = "dump_custom_tri_text_run1.melt"; auto text_file = "dump_custom_tri_text_run1.melt";
auto binary_file = "dump_custom_tri_binary_run1.melt.bin"; auto binary_file = "dump_custom_tri_binary_run1.melt.bin";
auto fields = "id type proc x y z xs ys zs xsu ysu zsu vx vy vz fx fy fz"; auto fields = "id type proc x y z xs ys zs xsu ysu zsu vx vy vz fx fy fz";
enable_triclinic(); enable_triclinic();
generate_text_and_binary_dump(text_file, binary_file, fields, "units yes", 1); generate_text_and_binary_dump(text_file, binary_file, fields, "units yes", 1);
@ -239,8 +247,8 @@ TEST_F(DumpCustomTest, with_variable_run1)
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
auto dump_file = "dump_custom_with_variable_run1.melt"; auto dump_file = "dump_custom_with_variable_run1.melt";
auto fields = "id type x y z v_p"; auto fields = "id type x y z v_p";
generate_dump(dump_file, fields, "units yes", 1); generate_dump(dump_file, fields, "units yes", 1);
ASSERT_FILE_EXISTS(dump_file); ASSERT_FILE_EXISTS(dump_file);
@ -253,7 +261,6 @@ TEST_F(DumpCustomTest, with_variable_run1)
delete_file(dump_file); delete_file(dump_file);
} }
int main(int argc, char **argv) int main(int argc, char **argv)
{ {
MPI_Init(&argc, &argv); MPI_Init(&argc, &argv);

48
unittest/formats/test_dump_custom_gz.cpp
View File

@ -11,28 +11,32 @@
See the README file in the top-level LAMMPS directory. See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
#include "gtest/gtest.h"
#include "gmock/gmock.h"
#include "fmt/format.h"
#include "utils.h"
#include "../testing/core.h" #include "../testing/core.h"
#include "../testing/systems/melt.h" #include "../testing/systems/melt.h"
#include "../testing/utils.h" #include "../testing/utils.h"
#include "fmt/format.h"
#include "utils.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
using ::testing::Eq; using ::testing::Eq;
char * GZIP_BINARY = nullptr; char *GZIP_BINARY = nullptr;
class DumpCustomGZTest : public MeltTest { class DumpCustomGZTest : public MeltTest {
std::string dump_style = "custom"; std::string dump_style = "custom";
public: public:
void enable_triclinic() { void enable_triclinic()
{
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
command("change_box all triclinic"); command("change_box all triclinic");
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
} }
void generate_dump(std::string dump_file, std::string fields, std::string dump_modify_options, int ntimesteps) { void generate_dump(std::string dump_file, std::string fields, std::string dump_modify_options,
int ntimesteps)
{
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
command(fmt::format("dump id all {} 1 {} {}", dump_style, dump_file, fields)); command(fmt::format("dump id all {} 1 {} {}", dump_style, dump_file, fields));
@ -44,8 +48,10 @@ public:
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
} }
void generate_text_and_compressed_dump(std::string text_file, std::string compressed_file, std::string compression_style, void generate_text_and_compressed_dump(std::string text_file, std::string compressed_file,
std::string fields, std::string dump_modify_options, int ntimesteps) { std::string compression_style, std::string fields,
std::string dump_modify_options, int ntimesteps)
{
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
command(fmt::format("dump id0 all {} 1 {} {}", dump_style, text_file, fields)); command(fmt::format("dump id0 all {} 1 {} {}", dump_style, text_file, fields));
command(fmt::format("dump id1 all {} 1 {} {}", compression_style, compressed_file, fields)); command(fmt::format("dump id1 all {} 1 {} {}", compression_style, compressed_file, fields));
@ -59,10 +65,12 @@ public:
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
} }
std::string convert_compressed_to_text(std::string compressed_file) { std::string convert_compressed_to_text(std::string compressed_file)
{
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
std::string converted_file = compressed_file.substr(0, compressed_file.find_last_of('.')); std::string converted_file = compressed_file.substr(0, compressed_file.find_last_of('.'));
std::string cmdline = fmt::format("{} -d -c {} > {}", GZIP_BINARY, compressed_file, converted_file); std::string cmdline =
fmt::format("{} -d -c {} > {}", GZIP_BINARY, compressed_file, converted_file);
system(cmdline.c_str()); system(cmdline.c_str());
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
return converted_file; return converted_file;
@ -71,13 +79,14 @@ public:
TEST_F(DumpCustomGZTest, compressed_run1) TEST_F(DumpCustomGZTest, compressed_run1)
{ {
if(!GZIP_BINARY) GTEST_SKIP(); if (!GZIP_BINARY) GTEST_SKIP();
auto text_file = "dump_custom_gz_text_run1.melt"; auto text_file = "dump_custom_gz_text_run1.melt";
auto compressed_file = "dump_custom_gz_compressed_run1.melt.gz"; auto compressed_file = "dump_custom_gz_compressed_run1.melt.gz";
auto fields = "id type proc x y z ix iy iz xs ys zs xu yu zu xsu ysu zsu vx vy vz fx fy fz"; auto fields = "id type proc x y z ix iy iz xs ys zs xu yu zu xsu ysu zsu vx vy vz fx fy fz";
generate_text_and_compressed_dump(text_file, compressed_file, "custom/gz", fields, "units yes", 1); generate_text_and_compressed_dump(text_file, compressed_file, "custom/gz", fields, "units yes",
1);
TearDown(); TearDown();
@ -95,15 +104,16 @@ TEST_F(DumpCustomGZTest, compressed_run1)
TEST_F(DumpCustomGZTest, compressed_triclinic_run1) TEST_F(DumpCustomGZTest, compressed_triclinic_run1)
{ {
if(!GZIP_BINARY) GTEST_SKIP(); if (!GZIP_BINARY) GTEST_SKIP();
auto text_file = "dump_custom_gz_tri_text_run1.melt"; auto text_file = "dump_custom_gz_tri_text_run1.melt";
auto compressed_file = "dump_custom_gz_tri_compressed_run1.melt.gz"; auto compressed_file = "dump_custom_gz_tri_compressed_run1.melt.gz";
auto fields = "id type proc x y z xs ys zs xsu ysu zsu vx vy vz fx fy fz"; auto fields = "id type proc x y z xs ys zs xsu ysu zsu vx vy vz fx fy fz";
enable_triclinic(); enable_triclinic();
generate_text_and_compressed_dump(text_file, compressed_file, "custom/gz", fields, "units yes", 1); generate_text_and_compressed_dump(text_file, compressed_file, "custom/gz", fields, "units yes",
1);
TearDown(); TearDown();

48
unittest/formats/test_dump_custom_zstd.cpp
View File

@ -11,28 +11,32 @@
See the README file in the top-level LAMMPS directory. See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
#include "gtest/gtest.h"
#include "gmock/gmock.h"
#include "fmt/format.h"
#include "utils.h"
#include "../testing/core.h" #include "../testing/core.h"
#include "../testing/systems/melt.h" #include "../testing/systems/melt.h"
#include "../testing/utils.h" #include "../testing/utils.h"
#include "fmt/format.h"
#include "utils.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
using ::testing::Eq; using ::testing::Eq;
char * ZSTD_BINARY = nullptr; char *ZSTD_BINARY = nullptr;
class DumpCustomZstdTest : public MeltTest { class DumpCustomZstdTest : public MeltTest {
std::string dump_style = "custom"; std::string dump_style = "custom";
public: public:
void enable_triclinic() { void enable_triclinic()
{
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
command("change_box all triclinic"); command("change_box all triclinic");
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
} }
void generate_dump(std::string dump_file, std::string fields, std::string dump_modify_options, int ntimesteps) { void generate_dump(std::string dump_file, std::string fields, std::string dump_modify_options,
int ntimesteps)
{
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
command(fmt::format("dump id all {} 1 {} {}", dump_style, dump_file, fields)); command(fmt::format("dump id all {} 1 {} {}", dump_style, dump_file, fields));
@ -44,8 +48,10 @@ public:
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
} }
void generate_text_and_compressed_dump(std::string text_file, std::string compressed_file, std::string compression_style, void generate_text_and_compressed_dump(std::string text_file, std::string compressed_file,
std::string fields, std::string dump_modify_options, int ntimesteps) { std::string compression_style, std::string fields,
std::string dump_modify_options, int ntimesteps)
{
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
command(fmt::format("dump id0 all {} 1 {} {}", dump_style, text_file, fields)); command(fmt::format("dump id0 all {} 1 {} {}", dump_style, text_file, fields));
command(fmt::format("dump id1 all {} 1 {} {}", compression_style, compressed_file, fields)); command(fmt::format("dump id1 all {} 1 {} {}", compression_style, compressed_file, fields));
@ -59,10 +65,12 @@ public:
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
} }
std::string convert_compressed_to_text(std::string compressed_file) { std::string convert_compressed_to_text(std::string compressed_file)
{
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
std::string converted_file = compressed_file.substr(0, compressed_file.find_last_of('.')); std::string converted_file = compressed_file.substr(0, compressed_file.find_last_of('.'));
std::string cmdline = fmt::format("{} -d -c {} > {}", ZSTD_BINARY, compressed_file, converted_file); std::string cmdline =
fmt::format("{} -d -c {} > {}", ZSTD_BINARY, compressed_file, converted_file);
system(cmdline.c_str()); system(cmdline.c_str());
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
return converted_file; return converted_file;
@ -71,13 +79,14 @@ public:
TEST_F(DumpCustomZstdTest, compressed_run1) TEST_F(DumpCustomZstdTest, compressed_run1)
{ {
if(!ZSTD_BINARY) GTEST_SKIP(); if (!ZSTD_BINARY) GTEST_SKIP();
auto text_file = "dump_custom_zstd_text_run1.melt"; auto text_file = "dump_custom_zstd_text_run1.melt";
auto compressed_file = "dump_custom_zstd_compressed_run1.melt.zst"; auto compressed_file = "dump_custom_zstd_compressed_run1.melt.zst";
auto fields = "id type proc x y z ix iy iz xs ys zs xu yu zu xsu ysu zsu vx vy vz fx fy fz"; auto fields = "id type proc x y z ix iy iz xs ys zs xu yu zu xsu ysu zsu vx vy vz fx fy fz";
generate_text_and_compressed_dump(text_file, compressed_file, "custom/zstd", fields, "units yes", 1); generate_text_and_compressed_dump(text_file, compressed_file, "custom/zstd", fields,
"units yes", 1);
TearDown(); TearDown();
@ -95,15 +104,16 @@ TEST_F(DumpCustomZstdTest, compressed_run1)
TEST_F(DumpCustomZstdTest, compressed_triclinic_run1) TEST_F(DumpCustomZstdTest, compressed_triclinic_run1)
{ {
if(!ZSTD_BINARY) GTEST_SKIP(); if (!ZSTD_BINARY) GTEST_SKIP();
auto text_file = "dump_custom_zstd_tri_text_run1.melt"; auto text_file = "dump_custom_zstd_tri_text_run1.melt";
auto compressed_file = "dump_custom_zstd_tri_compressed_run1.melt.zst"; auto compressed_file = "dump_custom_zstd_tri_compressed_run1.melt.zst";
auto fields = "id type proc x y z xs ys zs xsu ysu zsu vx vy vz fx fy fz"; auto fields = "id type proc x y z xs ys zs xsu ysu zsu vx vy vz fx fy fz";
enable_triclinic(); enable_triclinic();
generate_text_and_compressed_dump(text_file, compressed_file, "custom/zstd", fields, "units yes", 1); generate_text_and_compressed_dump(text_file, compressed_file, "custom/zstd", fields,
"units yes", 1);
TearDown(); TearDown();

33
unittest/formats/test_dump_local_gz.cpp
View File

@ -11,23 +11,26 @@
See the README file in the top-level LAMMPS directory. See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
#include "gtest/gtest.h"
#include "gmock/gmock.h"
#include "fmt/format.h"
#include "utils.h"
#include "../testing/core.h" #include "../testing/core.h"
#include "../testing/systems/melt.h" #include "../testing/systems/melt.h"
#include "../testing/utils.h" #include "../testing/utils.h"
#include "fmt/format.h"
#include "utils.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
char * GZIP_BINARY = nullptr; char *GZIP_BINARY = nullptr;
using ::testing::Eq; using ::testing::Eq;
class DumpLocalGZTest : public MeltTest { class DumpLocalGZTest : public MeltTest {
std::string dump_style = "local"; std::string dump_style = "local";
public: public:
void generate_text_and_compressed_dump(std::string text_file, std::string compressed_file, std::string compression_style, void generate_text_and_compressed_dump(std::string text_file, std::string compressed_file,
std::string fields, std::string dump_modify_options, int ntimesteps) { std::string compression_style, std::string fields,
std::string dump_modify_options, int ntimesteps)
{
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
command(fmt::format("dump id0 all {} 1 {} {}", dump_style, text_file, fields)); command(fmt::format("dump id0 all {} 1 {} {}", dump_style, text_file, fields));
command(fmt::format("dump id1 all {} 1 {} {}", compression_style, compressed_file, fields)); command(fmt::format("dump id1 all {} 1 {} {}", compression_style, compressed_file, fields));
@ -41,10 +44,12 @@ public:
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
} }
std::string convert_compressed_to_text(std::string compressed_file) { std::string convert_compressed_to_text(std::string compressed_file)
{
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
std::string converted_file = compressed_file.substr(0, compressed_file.find_last_of('.')); std::string converted_file = compressed_file.substr(0, compressed_file.find_last_of('.'));
std::string cmdline = fmt::format("{} -d -c {} > {}", GZIP_BINARY, compressed_file, converted_file); std::string cmdline =
fmt::format("{} -d -c {} > {}", GZIP_BINARY, compressed_file, converted_file);
system(cmdline.c_str()); system(cmdline.c_str());
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
return converted_file; return converted_file;
@ -53,17 +58,17 @@ public:
TEST_F(DumpLocalGZTest, compressed_run0) TEST_F(DumpLocalGZTest, compressed_run0)
{ {
if(!GZIP_BINARY) GTEST_SKIP(); if (!GZIP_BINARY) GTEST_SKIP();
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
command("compute comp all pair/local dist eng"); command("compute comp all pair/local dist eng");
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
auto text_files = "dump_local_gz_text_run*.melt.local"; auto text_files = "dump_local_gz_text_run*.melt.local";
auto compressed_files = "dump_local_gz_compressed_run*.melt.local.gz"; auto compressed_files = "dump_local_gz_compressed_run*.melt.local.gz";
auto text_file = "dump_local_gz_text_run0.melt.local"; auto text_file = "dump_local_gz_text_run0.melt.local";
auto compressed_file = "dump_local_gz_compressed_run0.melt.local.gz"; auto compressed_file = "dump_local_gz_compressed_run0.melt.local.gz";
auto fields = "index c_comp[1]"; auto fields = "index c_comp[1]";
generate_text_and_compressed_dump(text_files, compressed_files, "local/gz", fields, "", 0); generate_text_and_compressed_dump(text_files, compressed_files, "local/gz", fields, "", 0);

33
unittest/formats/test_dump_local_zstd.cpp
View File

@ -11,23 +11,26 @@
See the README file in the top-level LAMMPS directory. See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
#include "gtest/gtest.h"
#include "gmock/gmock.h"
#include "fmt/format.h"
#include "utils.h"
#include "../testing/core.h" #include "../testing/core.h"
#include "../testing/systems/melt.h" #include "../testing/systems/melt.h"
#include "../testing/utils.h" #include "../testing/utils.h"
#include "fmt/format.h"
#include "utils.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
char * ZSTD_BINARY = nullptr; char *ZSTD_BINARY = nullptr;
using ::testing::Eq; using ::testing::Eq;
class DumpLocalGZTest : public MeltTest { class DumpLocalGZTest : public MeltTest {
std::string dump_style = "local"; std::string dump_style = "local";
public: public:
void generate_text_and_compressed_dump(std::string text_file, std::string compressed_file, std::string compression_style, void generate_text_and_compressed_dump(std::string text_file, std::string compressed_file,
std::string fields, std::string dump_modify_options, int ntimesteps) { std::string compression_style, std::string fields,
std::string dump_modify_options, int ntimesteps)
{
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
command(fmt::format("dump id0 all {} 1 {} {}", dump_style, text_file, fields)); command(fmt::format("dump id0 all {} 1 {} {}", dump_style, text_file, fields));
command(fmt::format("dump id1 all {} 1 {} {}", compression_style, compressed_file, fields)); command(fmt::format("dump id1 all {} 1 {} {}", compression_style, compressed_file, fields));
@ -41,10 +44,12 @@ public:
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
} }
std::string convert_compressed_to_text(std::string compressed_file) { std::string convert_compressed_to_text(std::string compressed_file)
{
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
std::string converted_file = compressed_file.substr(0, compressed_file.find_last_of('.')); std::string converted_file = compressed_file.substr(0, compressed_file.find_last_of('.'));
std::string cmdline = fmt::format("{} -d -c {} > {}", ZSTD_BINARY, compressed_file, converted_file); std::string cmdline =
fmt::format("{} -d -c {} > {}", ZSTD_BINARY, compressed_file, converted_file);
system(cmdline.c_str()); system(cmdline.c_str());
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
return converted_file; return converted_file;
@ -53,17 +58,17 @@ public:
TEST_F(DumpLocalGZTest, compressed_run0) TEST_F(DumpLocalGZTest, compressed_run0)
{ {
if(!ZSTD_BINARY) GTEST_SKIP(); if (!ZSTD_BINARY) GTEST_SKIP();
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
command("compute comp all pair/local dist eng"); command("compute comp all pair/local dist eng");
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
auto text_files = "dump_local_zstd_text_run*.melt.local"; auto text_files = "dump_local_zstd_text_run*.melt.local";
auto compressed_files = "dump_local_zstd_compressed_run*.melt.local.zst"; auto compressed_files = "dump_local_zstd_compressed_run*.melt.local.zst";
auto text_file = "dump_local_zstd_text_run0.melt.local"; auto text_file = "dump_local_zstd_text_run0.melt.local";
auto compressed_file = "dump_local_zstd_compressed_run0.melt.local.zst"; auto compressed_file = "dump_local_zstd_compressed_run0.melt.local.zst";
auto fields = "index c_comp[1]"; auto fields = "index c_comp[1]";
generate_text_and_compressed_dump(text_files, compressed_files, "local/zstd", fields, "", 0); generate_text_and_compressed_dump(text_files, compressed_files, "local/zstd", fields, "", 0);

31
unittest/formats/test_dump_xyz_gz.cpp
View File

@ -11,23 +11,26 @@
See the README file in the top-level LAMMPS directory. See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
#include "gtest/gtest.h"
#include "gmock/gmock.h"
#include "fmt/format.h"
#include "utils.h"
#include "../testing/core.h" #include "../testing/core.h"
#include "../testing/systems/melt.h" #include "../testing/systems/melt.h"
#include "../testing/utils.h" #include "../testing/utils.h"
#include "fmt/format.h"
#include "utils.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
char * GZIP_BINARY = nullptr; char *GZIP_BINARY = nullptr;
using ::testing::Eq; using ::testing::Eq;
class DumpXYZGZTest : public MeltTest { class DumpXYZGZTest : public MeltTest {
std::string dump_style = "xyz"; std::string dump_style = "xyz";
public: public:
void generate_text_and_compressed_dump(std::string text_file, std::string compressed_file, std::string compression_style, void generate_text_and_compressed_dump(std::string text_file, std::string compressed_file,
std::string dump_modify_options, int ntimesteps) { std::string compression_style,
std::string dump_modify_options, int ntimesteps)
{
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
command(fmt::format("dump id0 all {} 1 {}", dump_style, text_file)); command(fmt::format("dump id0 all {} 1 {}", dump_style, text_file));
command(fmt::format("dump id1 all {} 1 {}", compression_style, compressed_file)); command(fmt::format("dump id1 all {} 1 {}", compression_style, compressed_file));
@ -41,10 +44,12 @@ public:
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
} }
std::string convert_compressed_to_text(std::string compressed_file) { std::string convert_compressed_to_text(std::string compressed_file)
{
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
std::string converted_file = compressed_file.substr(0, compressed_file.find_last_of('.')); std::string converted_file = compressed_file.substr(0, compressed_file.find_last_of('.'));
std::string cmdline = fmt::format("{} -d -c {} > {}", GZIP_BINARY, compressed_file, converted_file); std::string cmdline =
fmt::format("{} -d -c {} > {}", GZIP_BINARY, compressed_file, converted_file);
system(cmdline.c_str()); system(cmdline.c_str());
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
return converted_file; return converted_file;
@ -53,12 +58,12 @@ public:
TEST_F(DumpXYZGZTest, compressed_run0) TEST_F(DumpXYZGZTest, compressed_run0)
{ {
if(!GZIP_BINARY) GTEST_SKIP(); if (!GZIP_BINARY) GTEST_SKIP();
auto text_files = "dump_xyz_gz_text_run*.melt.xyz"; auto text_files = "dump_xyz_gz_text_run*.melt.xyz";
auto compressed_files = "dump_xyz_gz_compressed_run*.melt.xyz.gz"; auto compressed_files = "dump_xyz_gz_compressed_run*.melt.xyz.gz";
auto text_file = "dump_xyz_gz_text_run0.melt.xyz"; auto text_file = "dump_xyz_gz_text_run0.melt.xyz";
auto compressed_file = "dump_xyz_gz_compressed_run0.melt.xyz.gz"; auto compressed_file = "dump_xyz_gz_compressed_run0.melt.xyz.gz";
generate_text_and_compressed_dump(text_files, compressed_files, "xyz/gz", "", 0); generate_text_and_compressed_dump(text_files, compressed_files, "xyz/gz", "", 0);

31
unittest/formats/test_dump_xyz_zstd.cpp
View File

@ -11,23 +11,26 @@
See the README file in the top-level LAMMPS directory. See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */ ------------------------------------------------------------------------- */
#include "gtest/gtest.h"
#include "gmock/gmock.h"
#include "fmt/format.h"
#include "utils.h"
#include "../testing/core.h" #include "../testing/core.h"
#include "../testing/systems/melt.h" #include "../testing/systems/melt.h"
#include "../testing/utils.h" #include "../testing/utils.h"
#include "fmt/format.h"
#include "utils.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
char * ZSTD_BINARY = nullptr; char *ZSTD_BINARY = nullptr;
using ::testing::Eq; using ::testing::Eq;
class DumpXYZGZTest : public MeltTest { class DumpXYZGZTest : public MeltTest {
std::string dump_style = "xyz"; std::string dump_style = "xyz";
public: public:
void generate_text_and_compressed_dump(std::string text_file, std::string compressed_file, std::string compression_style, void generate_text_and_compressed_dump(std::string text_file, std::string compressed_file,
std::string dump_modify_options, int ntimesteps) { std::string compression_style,
std::string dump_modify_options, int ntimesteps)
{
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
command(fmt::format("dump id0 all {} 1 {}", dump_style, text_file)); command(fmt::format("dump id0 all {} 1 {}", dump_style, text_file));
command(fmt::format("dump id1 all {} 1 {}", compression_style, compressed_file)); command(fmt::format("dump id1 all {} 1 {}", compression_style, compressed_file));
@ -41,10 +44,12 @@ public:
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
} }
std::string convert_compressed_to_text(std::string compressed_file) { std::string convert_compressed_to_text(std::string compressed_file)
{
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
std::string converted_file = compressed_file.substr(0, compressed_file.find_last_of('.')); std::string converted_file = compressed_file.substr(0, compressed_file.find_last_of('.'));
std::string cmdline = fmt::format("{} -d -c {} > {}", ZSTD_BINARY, compressed_file, converted_file); std::string cmdline =
fmt::format("{} -d -c {} > {}", ZSTD_BINARY, compressed_file, converted_file);
system(cmdline.c_str()); system(cmdline.c_str());
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
return converted_file; return converted_file;
@ -53,12 +58,12 @@ public:
TEST_F(DumpXYZGZTest, compressed_run0) TEST_F(DumpXYZGZTest, compressed_run0)
{ {
if(!ZSTD_BINARY) GTEST_SKIP(); if (!ZSTD_BINARY) GTEST_SKIP();
auto text_files = "dump_xyz_zstd_text_run*.melt.xyz"; auto text_files = "dump_xyz_zstd_text_run*.melt.xyz";
auto compressed_files = "dump_xyz_zstd_compressed_run*.melt.xyz.zst"; auto compressed_files = "dump_xyz_zstd_compressed_run*.melt.xyz.zst";
auto text_file = "dump_xyz_zstd_text_run0.melt.xyz"; auto text_file = "dump_xyz_zstd_text_run0.melt.xyz";
auto compressed_file = "dump_xyz_zstd_compressed_run0.melt.xyz.zst"; auto compressed_file = "dump_xyz_zstd_compressed_run0.melt.xyz.zst";
generate_text_and_compressed_dump(text_files, compressed_files, "xyz/zstd", "", 0); generate_text_and_compressed_dump(text_files, compressed_files, "xyz/zstd", "", 0);

7
unittest/formats/test_pair_unit_convert.cpp
View File

@ -650,15 +650,14 @@ TEST_F(PairUnitConvertTest, table_real2metal)
double pnew; double pnew;
lmp->output->thermo->evaluate_keyword("press", &pnew); lmp->output->thermo->evaluate_keyword("press", &pnew);
EXPECT_NEAR(pold, 1.0/p_convert * pnew, fabs(pnew * rel_error)); EXPECT_NEAR(pold, 1.0 / p_convert * pnew, fabs(pnew * rel_error));
double enew = lmp->force->pair->eng_vdwl + lmp->force->pair->eng_coul; double enew = lmp->force->pair->eng_vdwl + lmp->force->pair->eng_coul;
EXPECT_NEAR(1.0/ev_convert * eold, enew, fabs(enew * rel_error)); EXPECT_NEAR(1.0 / ev_convert * eold, enew, fabs(enew * rel_error));
f = lmp->atom->f; f = lmp->atom->f;
for (int i = 0; i < 4; ++i) for (int i = 0; i < 4; ++i)
for (int j = 0; j < 3; ++j) for (int j = 0; j < 3; ++j)
EXPECT_NEAR(1.0/ev_convert * fold[i][j], f[i][j], EXPECT_NEAR(1.0 / ev_convert * fold[i][j], f[i][j], fabs(f[i][j] * rel_error));
fabs(f[i][j] * rel_error));
} }
TEST_F(PairUnitConvertTest, tersoff) TEST_F(PairUnitConvertTest, tersoff)

2
unittest/formats/test_potential_file_reader.cpp
View File

@ -31,8 +31,8 @@
#include <cstring> #include <cstring>
#include <iostream> #include <iostream>
#include <vector>
#include <mpi.h> #include <mpi.h>
#include <vector>
#if defined(OMPI_MAJOR_VERSION) #if defined(OMPI_MAJOR_VERSION)
const bool have_openmpi = true; const bool have_openmpi = true;

63
unittest/fortran/wrap_commands.cpp
View File

@ -1,65 +1,70 @@
// unit tests for issuing command to a LAMMPS instance through the Fortran wrapper // unit tests for issuing command to a LAMMPS instance through the Fortran wrapper
#include "lammps.h" #include "lammps.h"
#include <cstdio> // for stdin, stdout
#include <mpi.h> #include <mpi.h>
#include <cstdio> // for stdin, stdout
#include <string> #include <string>
#include "gtest/gtest.h" #include "gtest/gtest.h"
// prototypes for fortran reverse wrapper functions // prototypes for fortran reverse wrapper functions
extern "C" { extern "C" {
void *f_lammps_with_args(); void *f_lammps_with_args();
void f_lammps_close(); void f_lammps_close();
void f_lammps_file(); void f_lammps_file();
void f_lammps_command(); void f_lammps_command();
void f_lammps_commands_list(); void f_lammps_commands_list();
void f_lammps_commands_string(); void f_lammps_commands_string();
double f_lammps_get_natoms(); double f_lammps_get_natoms();
} }
class LAMMPS_commands : public ::testing::Test class LAMMPS_commands : public ::testing::Test {
{
protected: protected:
LAMMPS_NS::LAMMPS *lmp; LAMMPS_NS::LAMMPS *lmp;
LAMMPS_commands() {}; LAMMPS_commands(){};
~LAMMPS_commands() override {}; ~LAMMPS_commands() override{};
void SetUp() override { void SetUp() override
{
::testing::internal::CaptureStdout(); ::testing::internal::CaptureStdout();
lmp = (LAMMPS_NS::LAMMPS *)f_lammps_with_args(); lmp = (LAMMPS_NS::LAMMPS *)f_lammps_with_args();
std::string output = ::testing::internal::GetCapturedStdout(); std::string output = ::testing::internal::GetCapturedStdout();
EXPECT_STREQ(output.substr(0,8).c_str(), "LAMMPS ("); EXPECT_STREQ(output.substr(0, 8).c_str(), "LAMMPS (");
} }
void TearDown() override { void TearDown() override
{
::testing::internal::CaptureStdout(); ::testing::internal::CaptureStdout();
f_lammps_close(); f_lammps_close();
std::string output = ::testing::internal::GetCapturedStdout(); std::string output = ::testing::internal::GetCapturedStdout();
EXPECT_STREQ(output.substr(0,16).c_str(), "Total wall time:"); EXPECT_STREQ(output.substr(0, 16).c_str(), "Total wall time:");
lmp = nullptr; lmp = nullptr;
} }
}; };
TEST_F(LAMMPS_commands, from_file) { TEST_F(LAMMPS_commands, from_file)
EXPECT_EQ(f_lammps_get_natoms(),0); {
EXPECT_EQ(f_lammps_get_natoms(), 0);
f_lammps_file(); f_lammps_file();
EXPECT_EQ(f_lammps_get_natoms(),2); EXPECT_EQ(f_lammps_get_natoms(), 2);
}; };
TEST_F(LAMMPS_commands, from_line) { TEST_F(LAMMPS_commands, from_line)
EXPECT_EQ(f_lammps_get_natoms(),0); {
EXPECT_EQ(f_lammps_get_natoms(), 0);
f_lammps_command(); f_lammps_command();
EXPECT_EQ(f_lammps_get_natoms(),1); EXPECT_EQ(f_lammps_get_natoms(), 1);
}; };
TEST_F(LAMMPS_commands, from_list) { TEST_F(LAMMPS_commands, from_list)
EXPECT_EQ(f_lammps_get_natoms(),0); {
EXPECT_EQ(f_lammps_get_natoms(), 0);
f_lammps_commands_list(); f_lammps_commands_list();
EXPECT_EQ(f_lammps_get_natoms(),2); EXPECT_EQ(f_lammps_get_natoms(), 2);
}; };
TEST_F(LAMMPS_commands, from_string) { TEST_F(LAMMPS_commands, from_string)
EXPECT_EQ(f_lammps_get_natoms(),0); {
EXPECT_EQ(f_lammps_get_natoms(), 0);
f_lammps_commands_string(); f_lammps_commands_string();
EXPECT_EQ(f_lammps_get_natoms(),2); EXPECT_EQ(f_lammps_get_natoms(), 2);
}; };

60
unittest/fortran/wrap_create.cpp
View File

@ -1,33 +1,34 @@
// unit tests for the LAMMPS base class // unit tests for the LAMMPS base class
#include "lammps.h" #include "lammps.h"
#include <cstdio> // for stdin, stdout
#include <mpi.h> #include <mpi.h>
#include <cstdio> // for stdin, stdout
#include <string> #include <string>
#include "gtest/gtest.h" #include "gtest/gtest.h"
// prototypes for fortran reverse wrapper functions // prototypes for fortran reverse wrapper functions
extern "C" { extern "C" {
void *f_lammps_open_no_args(); void *f_lammps_open_no_args();
void *f_lammps_open_with_args(); void *f_lammps_open_with_args();
void *f_lammps_no_mpi_no_args(); void *f_lammps_no_mpi_no_args();
void *f_lammps_no_mpi_with_args(); void *f_lammps_no_mpi_with_args();
void f_lammps_close(); void f_lammps_close();
int f_lammps_get_comm(); int f_lammps_get_comm();
} }
TEST(open_no_mpi, no_args) { TEST(open_no_mpi, no_args)
{
::testing::internal::CaptureStdout(); ::testing::internal::CaptureStdout();
int mpi_init=0; int mpi_init = 0;
MPI_Initialized(&mpi_init); MPI_Initialized(&mpi_init);
EXPECT_EQ(mpi_init,0); EXPECT_EQ(mpi_init, 0);
void *handle = f_lammps_no_mpi_no_args(); void *handle = f_lammps_no_mpi_no_args();
std::string output = ::testing::internal::GetCapturedStdout(); std::string output = ::testing::internal::GetCapturedStdout();
EXPECT_STREQ(output.substr(0,6).c_str(),"LAMMPS"); EXPECT_STREQ(output.substr(0, 6).c_str(), "LAMMPS");
LAMMPS_NS::LAMMPS *lmp = (LAMMPS_NS::LAMMPS *)handle; LAMMPS_NS::LAMMPS *lmp = (LAMMPS_NS::LAMMPS *)handle;
MPI_Initialized(&mpi_init); MPI_Initialized(&mpi_init);
EXPECT_NE(mpi_init,0); EXPECT_NE(mpi_init, 0);
EXPECT_EQ(lmp->world, MPI_COMM_WORLD); EXPECT_EQ(lmp->world, MPI_COMM_WORLD);
EXPECT_EQ(lmp->infile, stdin); EXPECT_EQ(lmp->infile, stdin);
EXPECT_EQ(lmp->screen, stdout); EXPECT_EQ(lmp->screen, stdout);
@ -35,14 +36,15 @@ TEST(open_no_mpi, no_args) {
::testing::internal::CaptureStdout(); ::testing::internal::CaptureStdout();
f_lammps_close(); f_lammps_close();
output = ::testing::internal::GetCapturedStdout(); output = ::testing::internal::GetCapturedStdout();
EXPECT_STREQ(output.substr(0,16).c_str(), "Total wall time:"); EXPECT_STREQ(output.substr(0, 16).c_str(), "Total wall time:");
} }
TEST(open_no_mpi, with_args) { TEST(open_no_mpi, with_args)
{
::testing::internal::CaptureStdout(); ::testing::internal::CaptureStdout();
void *handle = f_lammps_no_mpi_with_args(); void *handle = f_lammps_no_mpi_with_args();
std::string output = ::testing::internal::GetCapturedStdout(); std::string output = ::testing::internal::GetCapturedStdout();
EXPECT_STREQ(output.substr(0,6).c_str(),"LAMMPS"); EXPECT_STREQ(output.substr(0, 6).c_str(), "LAMMPS");
LAMMPS_NS::LAMMPS *lmp = (LAMMPS_NS::LAMMPS *)handle; LAMMPS_NS::LAMMPS *lmp = (LAMMPS_NS::LAMMPS *)handle;
EXPECT_EQ(lmp->infile, stdin); EXPECT_EQ(lmp->infile, stdin);
EXPECT_EQ(lmp->screen, stdout); EXPECT_EQ(lmp->screen, stdout);
@ -53,17 +55,18 @@ TEST(open_no_mpi, with_args) {
::testing::internal::CaptureStdout(); ::testing::internal::CaptureStdout();
f_lammps_close(); f_lammps_close();
output = ::testing::internal::GetCapturedStdout(); output = ::testing::internal::GetCapturedStdout();
EXPECT_STREQ(output.substr(0,16).c_str(), "Total wall time:"); EXPECT_STREQ(output.substr(0, 16).c_str(), "Total wall time:");
} }
TEST(fortran_open, no_args) { TEST(fortran_open, no_args)
{
::testing::internal::CaptureStdout(); ::testing::internal::CaptureStdout();
void *handle = f_lammps_open_no_args(); void *handle = f_lammps_open_no_args();
std::string output = ::testing::internal::GetCapturedStdout(); std::string output = ::testing::internal::GetCapturedStdout();
EXPECT_STREQ(output.substr(0,6).c_str(),"LAMMPS"); EXPECT_STREQ(output.substr(0, 6).c_str(), "LAMMPS");
LAMMPS_NS::LAMMPS *lmp = (LAMMPS_NS::LAMMPS *)handle; LAMMPS_NS::LAMMPS *lmp = (LAMMPS_NS::LAMMPS *)handle;
int f_comm = f_lammps_get_comm(); int f_comm = f_lammps_get_comm();
MPI_Comm mycomm = MPI_Comm_f2c(f_comm); MPI_Comm mycomm = MPI_Comm_f2c(f_comm);
EXPECT_EQ(lmp->world, mycomm); EXPECT_EQ(lmp->world, mycomm);
EXPECT_EQ(lmp->infile, stdin); EXPECT_EQ(lmp->infile, stdin);
@ -72,17 +75,18 @@ TEST(fortran_open, no_args) {
::testing::internal::CaptureStdout(); ::testing::internal::CaptureStdout();
f_lammps_close(); f_lammps_close();
output = ::testing::internal::GetCapturedStdout(); output = ::testing::internal::GetCapturedStdout();
EXPECT_STREQ(output.substr(0,16).c_str(), "Total wall time:"); EXPECT_STREQ(output.substr(0, 16).c_str(), "Total wall time:");
} }
TEST(fortran_open, with_args) { TEST(fortran_open, with_args)
{
::testing::internal::CaptureStdout(); ::testing::internal::CaptureStdout();
void *handle = f_lammps_open_with_args(); void *handle = f_lammps_open_with_args();
std::string output = ::testing::internal::GetCapturedStdout(); std::string output = ::testing::internal::GetCapturedStdout();
EXPECT_STREQ(output.substr(0,6).c_str(),"LAMMPS"); EXPECT_STREQ(output.substr(0, 6).c_str(), "LAMMPS");
LAMMPS_NS::LAMMPS *lmp = (LAMMPS_NS::LAMMPS *)handle; LAMMPS_NS::LAMMPS *lmp = (LAMMPS_NS::LAMMPS *)handle;
int f_comm = f_lammps_get_comm(); int f_comm = f_lammps_get_comm();
MPI_Comm mycomm = MPI_Comm_f2c(f_comm); MPI_Comm mycomm = MPI_Comm_f2c(f_comm);
EXPECT_EQ(lmp->world, mycomm); EXPECT_EQ(lmp->world, mycomm);
EXPECT_EQ(lmp->infile, stdin); EXPECT_EQ(lmp->infile, stdin);
@ -93,5 +97,5 @@ TEST(fortran_open, with_args) {
::testing::internal::CaptureStdout(); ::testing::internal::CaptureStdout();
f_lammps_close(); f_lammps_close();
output = ::testing::internal::GetCapturedStdout(); output = ::testing::internal::GetCapturedStdout();
EXPECT_STREQ(output.substr(0,16).c_str(), "Total wall time:"); EXPECT_STREQ(output.substr(0, 16).c_str(), "Total wall time:");
} }

10
unittest/python/test_python_package.cpp
View File

@ -32,13 +32,13 @@ bool verbose = false;
using LAMMPS_NS::utils::split_words; using LAMMPS_NS::utils::split_words;
namespace LAMMPS_NS { namespace LAMMPS_NS {
using ::testing::StrEq;
using ::testing::MatchesRegex; using ::testing::MatchesRegex;
using ::testing::StrEq;
class PythonPackageTest : public ::testing::Test { class PythonPackageTest : public ::testing::Test {
protected: protected:
LAMMPS *lmp; LAMMPS *lmp;
Info *info; Info *info;
void SetUp() override void SetUp() override
{ {
@ -74,7 +74,7 @@ protected:
TEST_F(PythonPackageTest, python_invoke) TEST_F(PythonPackageTest, python_invoke)
{ {
if (!info->has_style("command","python")) GTEST_SKIP(); if (!info->has_style("command", "python")) GTEST_SKIP();
// execute python function from file // execute python function from file
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
lmp->input->one("python printnum file ${input_dir}/func.py"); lmp->input->one("python printnum file ${input_dir}/func.py");
@ -107,9 +107,9 @@ TEST_F(PythonPackageTest, python_invoke)
ASSERT_THAT(output, MatchesRegex("python.*2.25.*")); ASSERT_THAT(output, MatchesRegex("python.*2.25.*"));
} }
TEST_F(PythonPackageTest, python_variable) TEST_F(PythonPackageTest, python_variable)
{ {
if (!info->has_style("command","python")) GTEST_SKIP(); if (!info->has_style("command", "python")) GTEST_SKIP();
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
lmp->input->one("variable sq python square"); lmp->input->one("variable sq python square");
lmp->input->one("variable val index 1.5"); lmp->input->one("variable val index 1.5");

18
unittest/testing/core.h
View File

@ -41,31 +41,26 @@ using ::testing::MatchesRegex;
// whether to print verbose output (i.e. not capturing LAMMPS screen output). // whether to print verbose output (i.e. not capturing LAMMPS screen output).
bool verbose = false; bool verbose = false;
class LAMMPSTest : public ::testing::Test { class LAMMPSTest : public ::testing::Test {
public: public:
void command(const std::string &line) { void command(const std::string &line) { lmp->input->one(line.c_str()); }
lmp->input->one(line.c_str());
}
protected: protected:
const char * testbinary = "LAMMPSTest"; const char *testbinary = "LAMMPSTest";
LAMMPS *lmp; LAMMPS *lmp;
void SetUp() override void SetUp() override
{ {
const char *args[] = { testbinary, "-log", "none", "-echo", "screen", "-nocite"}; const char *args[] = {testbinary, "-log", "none", "-echo", "screen", "-nocite"};
char **argv = (char **)args; char **argv = (char **)args;
int argc = sizeof(args) / sizeof(char *); int argc = sizeof(args) / sizeof(char *);
if (!verbose) ::testing::internal::CaptureStdout(); if (!verbose) ::testing::internal::CaptureStdout();
lmp = new LAMMPS(argc, argv, MPI_COMM_WORLD); lmp = new LAMMPS(argc, argv, MPI_COMM_WORLD);
InitSystem(); InitSystem();
if (!verbose) ::testing::internal::GetCapturedStdout(); if (!verbose) ::testing::internal::GetCapturedStdout();
} }
virtual void InitSystem() {}
virtual void InitSystem() {
}
void TearDown() override void TearDown() override
{ {
@ -76,5 +71,4 @@ protected:
} }
}; };
#endif #endif

5
unittest/testing/systems/melt.h
View File

@ -17,7 +17,8 @@
class MeltTest : public LAMMPSTest { class MeltTest : public LAMMPSTest {
protected: protected:
virtual void InitSystem() override { virtual void InitSystem() override
{
command("units lj"); command("units lj");
command("atom_style atomic"); command("atom_style atomic");
command("atom_modify map yes"); command("atom_modify map yes");
@ -34,7 +35,7 @@ protected:
command("pair_coeff 1 1 1.0 1.0 2.5"); command("pair_coeff 1 1 1.0 1.0 2.5");
command("neighbor 0.3 bin"); command("neighbor 0.3 bin");
command("neigh_modify every 20 delay 0 check no"); command("neigh_modify every 20 delay 0 check no");
} }
}; };

18
unittest/testing/utils.h
View File

@ -13,12 +13,12 @@
#ifndef TEST_EXTENSIONS__H #ifndef TEST_EXTENSIONS__H
#define TEST_EXTENSIONS__H #define TEST_EXTENSIONS__H
#include <string>
#include <vector>
#include <iostream>
#include <fstream> #include <fstream>
#include <sys/types.h> #include <iostream>
#include <string>
#include <sys/stat.h> #include <sys/stat.h>
#include <sys/types.h>
#include <vector>
static void delete_file(const std::string &filename) static void delete_file(const std::string &filename)
{ {
@ -44,14 +44,15 @@ static bool equal_lines(const std::string &fileA, const std::string &fileB)
std::string lineA, lineB; std::string lineA, lineB;
while (std::getline(afile, lineA)) { while (std::getline(afile, lineA)) {
if(!std::getline(bfile, lineB)) return false; if (!std::getline(bfile, lineB)) return false;
if(lineA != lineB) return false; if (lineA != lineB) return false;
} }
return true; return true;
} }
static std::vector<std::string> read_lines(const std::string &filename) { static std::vector<std::string> read_lines(const std::string &filename)
{
std::vector<std::string> lines; std::vector<std::string> lines;
std::ifstream infile(filename); std::ifstream infile(filename);
std::string line; std::string line;
@ -62,7 +63,8 @@ static std::vector<std::string> read_lines(const std::string &filename) {
return lines; return lines;
} }
static bool file_exists(const std::string &filename) { static bool file_exists(const std::string &filename)
{
struct stat result; struct stat result;
return stat(filename.c_str(), &result) == 0; return stat(filename.c_str(), &result) == 0;
} }

1182
unittest/utils/test_math_eigen_impl.cpp
View File

File diff suppressed because it is too large Load Diff

316
unittest/utils/test_mempool.cpp
View File

@ -19,329 +19,333 @@
using namespace LAMMPS_NS; using namespace LAMMPS_NS;
TEST(MyPage, int) { TEST(MyPage, int)
{
MyPage<int> p; MyPage<int> p;
// default init. maxchunk=1, pagesize=1024 // default init. maxchunk=1, pagesize=1024
int rv = p.init(); int rv = p.init();
ASSERT_EQ(rv,0); ASSERT_EQ(rv, 0);
ASSERT_EQ(p.ndatum,0); ASSERT_EQ(p.ndatum, 0);
ASSERT_EQ(p.nchunk,0); ASSERT_EQ(p.nchunk, 0);
int *iptr = p.vget(); int *iptr = p.vget();
// second call to vget() should give same pointer without vgot() // second call to vget() should give same pointer without vgot()
ASSERT_EQ(iptr,p.vget()); ASSERT_EQ(iptr, p.vget());
p.vgot(1); p.vgot(1);
++iptr; ++iptr;
ASSERT_EQ(0,p.status()); ASSERT_EQ(0, p.status());
ASSERT_EQ(p.ndatum,1); ASSERT_EQ(p.ndatum, 1);
ASSERT_EQ(p.nchunk,1); ASSERT_EQ(p.nchunk, 1);
ASSERT_EQ(iptr,p.vget()); ASSERT_EQ(iptr, p.vget());
// use too large chunk size // use too large chunk size
p.vgot(2); p.vgot(2);
ASSERT_EQ(1,p.status()); ASSERT_EQ(1, p.status());
p.reset(); p.reset();
ASSERT_EQ(p.ndatum,0); ASSERT_EQ(p.ndatum, 0);
ASSERT_EQ(p.nchunk,0); ASSERT_EQ(p.nchunk, 0);
iptr = p.vget(); iptr = p.vget();
p.vgot(1); p.vgot(1);
++iptr; ++iptr;
ASSERT_EQ(iptr,p.get()); ASSERT_EQ(iptr, p.get());
++iptr; ++iptr;
ASSERT_EQ(iptr,p.get(1)); ASSERT_EQ(iptr, p.get(1));
ASSERT_EQ(p.ndatum,3); ASSERT_EQ(p.ndatum, 3);
ASSERT_EQ(p.nchunk,3); ASSERT_EQ(p.nchunk, 3);
// restart with custom init. maxchunk=16, pagesize=256 // restart with custom init. maxchunk=16, pagesize=256
rv = p.init(16,64,2); rv = p.init(16, 64, 2);
ASSERT_EQ(rv,0); ASSERT_EQ(rv, 0);
ASSERT_EQ(p.ndatum,0); ASSERT_EQ(p.ndatum, 0);
ASSERT_EQ(p.nchunk,0); ASSERT_EQ(p.nchunk, 0);
iptr = p.vget(); iptr = p.vget();
// second call to vget() should give same pointer without vgot() // second call to vget() should give same pointer without vgot()
ASSERT_EQ(iptr,p.vget()); ASSERT_EQ(iptr, p.vget());
p.vgot(16); p.vgot(16);
iptr += 16; iptr += 16;
ASSERT_EQ(0,p.status()); ASSERT_EQ(0, p.status());
ASSERT_EQ(p.ndatum,16); ASSERT_EQ(p.ndatum, 16);
ASSERT_EQ(p.nchunk,1); ASSERT_EQ(p.nchunk, 1);
// use too large chunk size // use too large chunk size
ASSERT_EQ(iptr,p.vget()); ASSERT_EQ(iptr, p.vget());
p.vgot(32); p.vgot(32);
ASSERT_EQ(1,p.status()); ASSERT_EQ(1, p.status());
p.reset(); p.reset();
ASSERT_EQ(0,p.status()); ASSERT_EQ(0, p.status());
ASSERT_EQ(p.ndatum,0); ASSERT_EQ(p.ndatum, 0);
ASSERT_EQ(p.nchunk,0); ASSERT_EQ(p.nchunk, 0);
iptr = p.vget(); iptr = p.vget();
p.vgot(16); p.vgot(16);
iptr = p.vget(); iptr = p.vget();
p.vgot(4); p.vgot(4);
iptr += 4; iptr += 4;
ASSERT_EQ(iptr,p.get()); ASSERT_EQ(iptr, p.get());
++iptr; ++iptr;
ASSERT_EQ(iptr,p.get(16)); ASSERT_EQ(iptr, p.get(16));
ASSERT_DOUBLE_EQ(p.size(),(double)sizeof(int)*128.0); ASSERT_DOUBLE_EQ(p.size(), (double)sizeof(int) * 128.0);
ASSERT_EQ(p.ndatum,37); ASSERT_EQ(p.ndatum, 37);
ASSERT_EQ(p.nchunk,4); ASSERT_EQ(p.nchunk, 4);
p.get(16); p.get(16);
p.get(16); p.get(16);
// allocation on the same page // allocation on the same page
iptr = p.get(16); iptr = p.get(16);
iptr += 16; iptr += 16;
ASSERT_EQ(iptr,p.get(16)); ASSERT_EQ(iptr, p.get(16));
// allocation on different pages // allocation on different pages
p.get(16); p.get(16);
iptr += 16; iptr += 16;
ASSERT_NE(iptr,p.get(16)); ASSERT_NE(iptr, p.get(16));
ASSERT_DOUBLE_EQ(p.size(),(double)sizeof(int)*256.0); ASSERT_DOUBLE_EQ(p.size(), (double)sizeof(int) * 256.0);
ASSERT_EQ(p.ndatum,133); ASSERT_EQ(p.ndatum, 133);
ASSERT_EQ(p.nchunk,10); ASSERT_EQ(p.nchunk, 10);
} }
TEST(MyPage, double) { TEST(MyPage, double)
{
MyPage<double> p; MyPage<double> p;
// default init. maxchunk=1, pagesize=1024 // default init. maxchunk=1, pagesize=1024
int rv = p.init(); int rv = p.init();
ASSERT_EQ(rv,0); ASSERT_EQ(rv, 0);
ASSERT_EQ(p.ndatum,0); ASSERT_EQ(p.ndatum, 0);
ASSERT_EQ(p.nchunk,0); ASSERT_EQ(p.nchunk, 0);
double *iptr = p.vget(); double *iptr = p.vget();
// second call to vget() should give same pointer without vgot() // second call to vget() should give same pointer without vgot()
ASSERT_EQ(iptr,p.vget()); ASSERT_EQ(iptr, p.vget());
p.vgot(1); p.vgot(1);
++iptr; ++iptr;
ASSERT_EQ(0,p.status()); ASSERT_EQ(0, p.status());
ASSERT_EQ(p.ndatum,1); ASSERT_EQ(p.ndatum, 1);
ASSERT_EQ(p.nchunk,1); ASSERT_EQ(p.nchunk, 1);
ASSERT_EQ(iptr,p.vget()); ASSERT_EQ(iptr, p.vget());
// use too large chunk size // use too large chunk size
p.vgot(2); p.vgot(2);
ASSERT_EQ(1,p.status()); ASSERT_EQ(1, p.status());
p.reset(); p.reset();
ASSERT_EQ(p.ndatum,0); ASSERT_EQ(p.ndatum, 0);
ASSERT_EQ(p.nchunk,0); ASSERT_EQ(p.nchunk, 0);
iptr = p.vget(); iptr = p.vget();
p.vgot(1); p.vgot(1);
++iptr; ++iptr;
ASSERT_EQ(iptr,p.get()); ASSERT_EQ(iptr, p.get());
++iptr; ++iptr;
ASSERT_EQ(iptr,p.get(1)); ASSERT_EQ(iptr, p.get(1));
ASSERT_EQ(p.ndatum,3); ASSERT_EQ(p.ndatum, 3);
ASSERT_EQ(p.nchunk,3); ASSERT_EQ(p.nchunk, 3);
// restart with custom init. maxchunk=16, pagesize=256 // restart with custom init. maxchunk=16, pagesize=256
rv = p.init(16,64,2); rv = p.init(16, 64, 2);
ASSERT_EQ(rv,0); ASSERT_EQ(rv, 0);
ASSERT_EQ(p.ndatum,0); ASSERT_EQ(p.ndatum, 0);
ASSERT_EQ(p.nchunk,0); ASSERT_EQ(p.nchunk, 0);
iptr = p.vget(); iptr = p.vget();
// second call to vget() should give same pointer without vgot() // second call to vget() should give same pointer without vgot()
ASSERT_EQ(iptr,p.vget()); ASSERT_EQ(iptr, p.vget());
p.vgot(16); p.vgot(16);
iptr += 16; iptr += 16;
ASSERT_EQ(0,p.status()); ASSERT_EQ(0, p.status());
ASSERT_EQ(p.ndatum,16); ASSERT_EQ(p.ndatum, 16);
ASSERT_EQ(p.nchunk,1); ASSERT_EQ(p.nchunk, 1);
// use too large chunk size // use too large chunk size
ASSERT_EQ(iptr,p.vget()); ASSERT_EQ(iptr, p.vget());
p.vgot(32); p.vgot(32);
ASSERT_EQ(1,p.status()); ASSERT_EQ(1, p.status());
p.reset(); p.reset();
ASSERT_EQ(0,p.status()); ASSERT_EQ(0, p.status());
ASSERT_EQ(p.ndatum,0); ASSERT_EQ(p.ndatum, 0);
ASSERT_EQ(p.nchunk,0); ASSERT_EQ(p.nchunk, 0);
iptr = p.vget(); iptr = p.vget();
p.vgot(16); p.vgot(16);
iptr = p.vget(); iptr = p.vget();
p.vgot(4); p.vgot(4);
iptr += 4; iptr += 4;
ASSERT_EQ(iptr,p.get()); ASSERT_EQ(iptr, p.get());
++iptr; ++iptr;
ASSERT_EQ(iptr,p.get(16)); ASSERT_EQ(iptr, p.get(16));
ASSERT_DOUBLE_EQ(p.size(),(double)sizeof(double)*128.0); ASSERT_DOUBLE_EQ(p.size(), (double)sizeof(double) * 128.0);
ASSERT_EQ(p.ndatum,37); ASSERT_EQ(p.ndatum, 37);
ASSERT_EQ(p.nchunk,4); ASSERT_EQ(p.nchunk, 4);
p.get(16); p.get(16);
p.get(16); p.get(16);
// allocation on the same page // allocation on the same page
iptr = p.get(16); iptr = p.get(16);
iptr += 16; iptr += 16;
ASSERT_EQ(iptr,p.get(16)); ASSERT_EQ(iptr, p.get(16));
// allocation on different pages // allocation on different pages
p.get(16); p.get(16);
iptr += 16; iptr += 16;
ASSERT_NE(iptr,p.get(16)); ASSERT_NE(iptr, p.get(16));
ASSERT_DOUBLE_EQ(p.size(),(double)sizeof(double)*256.0); ASSERT_DOUBLE_EQ(p.size(), (double)sizeof(double) * 256.0);
ASSERT_EQ(p.ndatum,133); ASSERT_EQ(p.ndatum, 133);
ASSERT_EQ(p.nchunk,10); ASSERT_EQ(p.nchunk, 10);
} }
TEST(MyPage, bigint) { TEST(MyPage, bigint)
{
MyPage<bigint> p; MyPage<bigint> p;
// default init. maxchunk=1, pagesize=1024 // default init. maxchunk=1, pagesize=1024
int rv = p.init(); int rv = p.init();
ASSERT_EQ(rv,0); ASSERT_EQ(rv, 0);
ASSERT_EQ(p.ndatum,0); ASSERT_EQ(p.ndatum, 0);
ASSERT_EQ(p.nchunk,0); ASSERT_EQ(p.nchunk, 0);
bigint *iptr = p.vget(); bigint *iptr = p.vget();
// second call to vget() should give same pointer without vgot() // second call to vget() should give same pointer without vgot()
ASSERT_EQ(iptr,p.vget()); ASSERT_EQ(iptr, p.vget());
p.vgot(1); p.vgot(1);
++iptr; ++iptr;
ASSERT_EQ(0,p.status()); ASSERT_EQ(0, p.status());
ASSERT_EQ(p.ndatum,1); ASSERT_EQ(p.ndatum, 1);
ASSERT_EQ(p.nchunk,1); ASSERT_EQ(p.nchunk, 1);
ASSERT_EQ(iptr,p.vget()); ASSERT_EQ(iptr, p.vget());
// use too large chunk size // use too large chunk size
p.vgot(2); p.vgot(2);
ASSERT_EQ(1,p.status()); ASSERT_EQ(1, p.status());
p.reset(); p.reset();
ASSERT_EQ(p.ndatum,0); ASSERT_EQ(p.ndatum, 0);
ASSERT_EQ(p.nchunk,0); ASSERT_EQ(p.nchunk, 0);
iptr = p.vget(); iptr = p.vget();
p.vgot(1); p.vgot(1);
++iptr; ++iptr;
ASSERT_EQ(iptr,p.get()); ASSERT_EQ(iptr, p.get());
++iptr; ++iptr;
ASSERT_EQ(iptr,p.get(1)); ASSERT_EQ(iptr, p.get(1));
ASSERT_EQ(p.ndatum,3); ASSERT_EQ(p.ndatum, 3);
ASSERT_EQ(p.nchunk,3); ASSERT_EQ(p.nchunk, 3);
// restart with custom init. maxchunk=16, pagesize=256 // restart with custom init. maxchunk=16, pagesize=256
rv = p.init(16,64,2); rv = p.init(16, 64, 2);
ASSERT_EQ(rv,0); ASSERT_EQ(rv, 0);
ASSERT_EQ(p.ndatum,0); ASSERT_EQ(p.ndatum, 0);
ASSERT_EQ(p.nchunk,0); ASSERT_EQ(p.nchunk, 0);
iptr = p.vget(); iptr = p.vget();
// second call to vget() should give same pointer without vgot() // second call to vget() should give same pointer without vgot()
ASSERT_EQ(iptr,p.vget()); ASSERT_EQ(iptr, p.vget());
p.vgot(16); p.vgot(16);
iptr += 16; iptr += 16;
ASSERT_EQ(0,p.status()); ASSERT_EQ(0, p.status());
ASSERT_EQ(p.ndatum,16); ASSERT_EQ(p.ndatum, 16);
ASSERT_EQ(p.nchunk,1); ASSERT_EQ(p.nchunk, 1);
// use too large chunk size // use too large chunk size
ASSERT_EQ(iptr,p.vget()); ASSERT_EQ(iptr, p.vget());
p.vgot(32); p.vgot(32);
ASSERT_EQ(1,p.status()); ASSERT_EQ(1, p.status());
p.reset(); p.reset();
ASSERT_EQ(0,p.status()); ASSERT_EQ(0, p.status());
ASSERT_EQ(p.ndatum,0); ASSERT_EQ(p.ndatum, 0);
ASSERT_EQ(p.nchunk,0); ASSERT_EQ(p.nchunk, 0);
iptr = p.vget(); iptr = p.vget();
p.vgot(16); p.vgot(16);
iptr = p.vget(); iptr = p.vget();
p.vgot(4); p.vgot(4);
iptr += 4; iptr += 4;
ASSERT_EQ(iptr,p.get()); ASSERT_EQ(iptr, p.get());
++iptr; ++iptr;
ASSERT_EQ(iptr,p.get(16)); ASSERT_EQ(iptr, p.get(16));
ASSERT_DOUBLE_EQ(p.size(),(double)sizeof(bigint)*128.0); ASSERT_DOUBLE_EQ(p.size(), (double)sizeof(bigint) * 128.0);
ASSERT_EQ(p.ndatum,37); ASSERT_EQ(p.ndatum, 37);
ASSERT_EQ(p.nchunk,4); ASSERT_EQ(p.nchunk, 4);
p.get(16); p.get(16);
p.get(16); p.get(16);
// allocation on the same page // allocation on the same page
iptr = p.get(16); iptr = p.get(16);
iptr += 16; iptr += 16;
ASSERT_EQ(iptr,p.get(16)); ASSERT_EQ(iptr, p.get(16));
// allocation on different pages // allocation on different pages
p.get(16); p.get(16);
iptr += 16; iptr += 16;
ASSERT_NE(iptr,p.get(16)); ASSERT_NE(iptr, p.get(16));
ASSERT_DOUBLE_EQ(p.size(),(double)sizeof(bigint)*256.0); ASSERT_DOUBLE_EQ(p.size(), (double)sizeof(bigint) * 256.0);
ASSERT_EQ(p.ndatum,133); ASSERT_EQ(p.ndatum, 133);
ASSERT_EQ(p.nchunk,10); ASSERT_EQ(p.nchunk, 10);
} }
TEST(MyPoolChunk, int) { TEST(MyPoolChunk, int)
{
// defaults to minchunk=1, maxchunk=1, nbin=1, chunksperpage=1024, pagedelta=1 // defaults to minchunk=1, maxchunk=1, nbin=1, chunksperpage=1024, pagedelta=1
MyPoolChunk<int> p; MyPoolChunk<int> p;
ASSERT_EQ(p.ndatum,0); ASSERT_EQ(p.ndatum, 0);
ASSERT_EQ(p.nchunk,0); ASSERT_EQ(p.nchunk, 0);
ASSERT_EQ(p.size(),0.0); ASSERT_EQ(p.size(), 0.0);
int idx=~0x0000; int idx = ~0x0000;
int *iptr = p.get(idx); int *iptr = p.get(idx);
ASSERT_NE(iptr,nullptr); ASSERT_NE(iptr, nullptr);
ASSERT_EQ(idx,0); ASSERT_EQ(idx, 0);
iptr = p.get(1,idx); iptr = p.get(1, idx);
ASSERT_NE(iptr,nullptr); ASSERT_NE(iptr, nullptr);
ASSERT_EQ(idx,1); ASSERT_EQ(idx, 1);
// we have only one page allocated // we have only one page allocated
ASSERT_EQ(p.size(),1024*sizeof(int)+1024*sizeof(int)+sizeof(void *)+sizeof(int)); ASSERT_EQ(p.size(), 1024 * sizeof(int) + 1024 * sizeof(int) + sizeof(void *) + sizeof(int));
ASSERT_EQ(p.ndatum,2); ASSERT_EQ(p.ndatum, 2);
ASSERT_EQ(p.nchunk,2); ASSERT_EQ(p.nchunk, 2);
p.put(0); p.put(0);
ASSERT_EQ(p.ndatum,1); ASSERT_EQ(p.ndatum, 1);
ASSERT_EQ(p.nchunk,1); ASSERT_EQ(p.nchunk, 1);
iptr = p.get(2,idx); iptr = p.get(2, idx);
ASSERT_EQ(iptr,nullptr); ASSERT_EQ(iptr, nullptr);
ASSERT_EQ(p.status(),3); ASSERT_EQ(p.status(), 3);
ASSERT_EQ(p.ndatum,1); ASSERT_EQ(p.ndatum, 1);
ASSERT_EQ(p.nchunk,1); ASSERT_EQ(p.nchunk, 1);
} }
TEST(MyPoolChunk, double) { TEST(MyPoolChunk, double)
{
// defaults to minchunk=1, maxchunk=1, nbin=1, chunksperpage=1024, pagedelta=1 // defaults to minchunk=1, maxchunk=1, nbin=1, chunksperpage=1024, pagedelta=1
MyPoolChunk<double> p; MyPoolChunk<double> p;
ASSERT_EQ(p.ndatum,0); ASSERT_EQ(p.ndatum, 0);
ASSERT_EQ(p.nchunk,0); ASSERT_EQ(p.nchunk, 0);
ASSERT_EQ(p.size(),0.0); ASSERT_EQ(p.size(), 0.0);
int idx=~0x0000; int idx = ~0x0000;
double *dptr = p.get(idx); double *dptr = p.get(idx);
ASSERT_NE(dptr,nullptr); ASSERT_NE(dptr, nullptr);
ASSERT_EQ(idx,0); ASSERT_EQ(idx, 0);
dptr = p.get(1,idx); dptr = p.get(1, idx);
ASSERT_NE(dptr,nullptr); ASSERT_NE(dptr, nullptr);
ASSERT_EQ(idx,1); ASSERT_EQ(idx, 1);
// we have only one page allocated // we have only one page allocated
ASSERT_EQ(p.size(),1024*sizeof(int)+1024*sizeof(double)+sizeof(void *)+sizeof(int)); ASSERT_EQ(p.size(), 1024 * sizeof(int) + 1024 * sizeof(double) + sizeof(void *) + sizeof(int));
p.put(0); p.put(0);
ASSERT_EQ(p.ndatum,1); ASSERT_EQ(p.ndatum, 1);
ASSERT_EQ(p.nchunk,1); ASSERT_EQ(p.nchunk, 1);
dptr = p.get(2,idx); dptr = p.get(2, idx);
ASSERT_EQ(dptr,nullptr); ASSERT_EQ(dptr, nullptr);
ASSERT_EQ(p.status(),3); ASSERT_EQ(p.status(), 3);
ASSERT_EQ(p.ndatum,1); ASSERT_EQ(p.ndatum, 1);
ASSERT_EQ(p.nchunk,1); ASSERT_EQ(p.nchunk, 1);
} }

6
unittest/utils/test_tokenizer.cpp
View File

@ -158,13 +158,15 @@ TEST(ValueTokenizer, valid_double_with_exponential)
ASSERT_DOUBLE_EQ(values.next_double(), 3.14e22); ASSERT_DOUBLE_EQ(values.next_double(), 3.14e22);
} }
TEST(ValueTokenizer, contains) { TEST(ValueTokenizer, contains)
{
ValueTokenizer values("test word"); ValueTokenizer values("test word");
ASSERT_TRUE(values.contains("test")); ASSERT_TRUE(values.contains("test"));
ASSERT_TRUE(values.contains("word")); ASSERT_TRUE(values.contains("word"));
} }
TEST(ValueTokenizer, not_contains) { TEST(ValueTokenizer, not_contains)
{
ValueTokenizer values("test word"); ValueTokenizer values("test word");
ASSERT_FALSE(values.contains("test2")); ASSERT_FALSE(values.contains("test2"));
} }

107
unittest/utils/test_utils.cpp
View File

@ -27,7 +27,7 @@ using ::testing::Eq;
using ::testing::StrEq; using ::testing::StrEq;
#if !defined(FLERR) #if !defined(FLERR)
#define FLERR __FILE__,__LINE__ #define FLERR __FILE__, __LINE__
#endif #endif
TEST(Utils, trim) TEST(Utils, trim)
@ -373,11 +373,11 @@ TEST(Utils, bounds_case1)
nlo = nhi = -1; nlo = nhi = -1;
utils::bounds(FLERR, "9", 0, 10, nlo, nhi, nullptr); utils::bounds(FLERR, "9", 0, 10, nlo, nhi, nullptr);
ASSERT_EQ(nlo,9); ASSERT_EQ(nlo, 9);
ASSERT_EQ(nhi,9); ASSERT_EQ(nhi, 9);
utils::bounds(FLERR, "1", 1, 10, nlo, nhi, nullptr); utils::bounds(FLERR, "1", 1, 10, nlo, nhi, nullptr);
ASSERT_EQ(nlo,1); ASSERT_EQ(nlo, 1);
ASSERT_EQ(nhi,1); ASSERT_EQ(nhi, 1);
} }
TEST(Utils, bounds_case2) TEST(Utils, bounds_case2)
@ -386,11 +386,11 @@ TEST(Utils, bounds_case2)
nlo = nhi = -1; nlo = nhi = -1;
utils::bounds(FLERR, "*", 0, 10, nlo, nhi, nullptr); utils::bounds(FLERR, "*", 0, 10, nlo, nhi, nullptr);
ASSERT_EQ(nlo,0); ASSERT_EQ(nlo, 0);
ASSERT_EQ(nhi,10); ASSERT_EQ(nhi, 10);
utils::bounds(FLERR, "*", -10, 5, nlo, nhi, nullptr); utils::bounds(FLERR, "*", -10, 5, nlo, nhi, nullptr);
ASSERT_EQ(nlo,-10); ASSERT_EQ(nlo, -10);
ASSERT_EQ(nhi,5); ASSERT_EQ(nhi, 5);
} }
TEST(Utils, bounds_case3) TEST(Utils, bounds_case3)
@ -399,11 +399,11 @@ TEST(Utils, bounds_case3)
nlo = nhi = -1; nlo = nhi = -1;
utils::bounds(FLERR, "2*", 0, 10, nlo, nhi, nullptr); utils::bounds(FLERR, "2*", 0, 10, nlo, nhi, nullptr);
ASSERT_EQ(nlo,2); ASSERT_EQ(nlo, 2);
ASSERT_EQ(nhi,10); ASSERT_EQ(nhi, 10);
utils::bounds(FLERR, "3*", -10, 5, nlo, nhi, nullptr); utils::bounds(FLERR, "3*", -10, 5, nlo, nhi, nullptr);
ASSERT_EQ(nlo,3); ASSERT_EQ(nlo, 3);
ASSERT_EQ(nhi,5); ASSERT_EQ(nhi, 5);
} }
TEST(Utils, bounds_case4) TEST(Utils, bounds_case4)
@ -412,11 +412,11 @@ TEST(Utils, bounds_case4)
nlo = nhi = -1; nlo = nhi = -1;
utils::bounds(FLERR, "*2", 0, 10, nlo, nhi, nullptr); utils::bounds(FLERR, "*2", 0, 10, nlo, nhi, nullptr);
ASSERT_EQ(nlo,0); ASSERT_EQ(nlo, 0);
ASSERT_EQ(nhi,2); ASSERT_EQ(nhi, 2);
utils::bounds(FLERR, "*3", -10, 5, nlo, nhi, nullptr); utils::bounds(FLERR, "*3", -10, 5, nlo, nhi, nullptr);
ASSERT_EQ(nlo,-10); ASSERT_EQ(nlo, -10);
ASSERT_EQ(nhi,3); ASSERT_EQ(nhi, 3);
} }
TEST(Utils, bounds_case5) TEST(Utils, bounds_case5)
@ -425,11 +425,11 @@ TEST(Utils, bounds_case5)
nlo = nhi = -1; nlo = nhi = -1;
utils::bounds(FLERR, "2*5", 0, 10, nlo, nhi, nullptr); utils::bounds(FLERR, "2*5", 0, 10, nlo, nhi, nullptr);
ASSERT_EQ(nlo,2); ASSERT_EQ(nlo, 2);
ASSERT_EQ(nhi,5); ASSERT_EQ(nhi, 5);
utils::bounds(FLERR, "-2*3", -10, 5, nlo, nhi, nullptr); utils::bounds(FLERR, "-2*3", -10, 5, nlo, nhi, nullptr);
ASSERT_EQ(nlo,-2); ASSERT_EQ(nlo, -2);
ASSERT_EQ(nhi,3); ASSERT_EQ(nhi, 3);
} }
TEST(Utils, boundsbig_case1) TEST(Utils, boundsbig_case1)
@ -438,11 +438,11 @@ TEST(Utils, boundsbig_case1)
nlo = nhi = -1; nlo = nhi = -1;
utils::bounds(FLERR, "9", 0, 10, nlo, nhi, nullptr); utils::bounds(FLERR, "9", 0, 10, nlo, nhi, nullptr);
ASSERT_EQ(nlo,9); ASSERT_EQ(nlo, 9);
ASSERT_EQ(nhi,9); ASSERT_EQ(nhi, 9);
utils::bounds(FLERR, "1", 1, 10, nlo, nhi, nullptr); utils::bounds(FLERR, "1", 1, 10, nlo, nhi, nullptr);
ASSERT_EQ(nlo,1); ASSERT_EQ(nlo, 1);
ASSERT_EQ(nhi,1); ASSERT_EQ(nhi, 1);
} }
TEST(Utils, boundsbig_case2) TEST(Utils, boundsbig_case2)
@ -451,11 +451,11 @@ TEST(Utils, boundsbig_case2)
nlo = nhi = -1; nlo = nhi = -1;
utils::bounds(FLERR, "*", 0, 10, nlo, nhi, nullptr); utils::bounds(FLERR, "*", 0, 10, nlo, nhi, nullptr);
ASSERT_EQ(nlo,0); ASSERT_EQ(nlo, 0);
ASSERT_EQ(nhi,10); ASSERT_EQ(nhi, 10);
utils::bounds(FLERR, "*", -10, 5, nlo, nhi, nullptr); utils::bounds(FLERR, "*", -10, 5, nlo, nhi, nullptr);
ASSERT_EQ(nlo,-10); ASSERT_EQ(nlo, -10);
ASSERT_EQ(nhi,5); ASSERT_EQ(nhi, 5);
} }
TEST(Utils, boundsbig_case3) TEST(Utils, boundsbig_case3)
@ -464,11 +464,11 @@ TEST(Utils, boundsbig_case3)
nlo = nhi = -1; nlo = nhi = -1;
utils::bounds(FLERR, "2*", 0, 10, nlo, nhi, nullptr); utils::bounds(FLERR, "2*", 0, 10, nlo, nhi, nullptr);
ASSERT_EQ(nlo,2); ASSERT_EQ(nlo, 2);
ASSERT_EQ(nhi,10); ASSERT_EQ(nhi, 10);
utils::bounds(FLERR, "3*", -10, 5, nlo, nhi, nullptr); utils::bounds(FLERR, "3*", -10, 5, nlo, nhi, nullptr);
ASSERT_EQ(nlo,3); ASSERT_EQ(nlo, 3);
ASSERT_EQ(nhi,5); ASSERT_EQ(nhi, 5);
} }
TEST(Utils, boundsbig_case4) TEST(Utils, boundsbig_case4)
@ -477,11 +477,11 @@ TEST(Utils, boundsbig_case4)
nlo = nhi = -1; nlo = nhi = -1;
utils::bounds(FLERR, "*2", 0, 10, nlo, nhi, nullptr); utils::bounds(FLERR, "*2", 0, 10, nlo, nhi, nullptr);
ASSERT_EQ(nlo,0); ASSERT_EQ(nlo, 0);
ASSERT_EQ(nhi,2); ASSERT_EQ(nhi, 2);
utils::bounds(FLERR, "*3", -10, 5, nlo, nhi, nullptr); utils::bounds(FLERR, "*3", -10, 5, nlo, nhi, nullptr);
ASSERT_EQ(nlo,-10); ASSERT_EQ(nlo, -10);
ASSERT_EQ(nhi,3); ASSERT_EQ(nhi, 3);
} }
TEST(Utils, boundsbig_case5) TEST(Utils, boundsbig_case5)
@ -490,11 +490,11 @@ TEST(Utils, boundsbig_case5)
nlo = nhi = -1; nlo = nhi = -1;
utils::bounds(FLERR, "2*5", 0, 10, nlo, nhi, nullptr); utils::bounds(FLERR, "2*5", 0, 10, nlo, nhi, nullptr);
ASSERT_EQ(nlo,2); ASSERT_EQ(nlo, 2);
ASSERT_EQ(nhi,5); ASSERT_EQ(nhi, 5);
utils::bounds(FLERR, "-2*3", -10, 5, nlo, nhi, nullptr); utils::bounds(FLERR, "-2*3", -10, 5, nlo, nhi, nullptr);
ASSERT_EQ(nlo,-2); ASSERT_EQ(nlo, -2);
ASSERT_EQ(nhi,3); ASSERT_EQ(nhi, 3);
} }
TEST(Utils, guesspath) TEST(Utils, guesspath)
@ -628,19 +628,18 @@ TEST(Utils, timespec2seconds_hhmmss)
ASSERT_DOUBLE_EQ(utils::timespec2seconds("2:10:45"), 7845.0); ASSERT_DOUBLE_EQ(utils::timespec2seconds("2:10:45"), 7845.0);
} }
TEST(Utils, date2num) TEST(Utils, date2num)
{ {
ASSERT_EQ(utils::date2num("1Jan05"),20050101); ASSERT_EQ(utils::date2num("1Jan05"), 20050101);
ASSERT_EQ(utils::date2num("10Feb2005"),20050210); ASSERT_EQ(utils::date2num("10Feb2005"), 20050210);
ASSERT_EQ(utils::date2num("02Mar10"),20100302); ASSERT_EQ(utils::date2num("02Mar10"), 20100302);
ASSERT_EQ(utils::date2num(" 5Apr1900"),19000405); ASSERT_EQ(utils::date2num(" 5Apr1900"), 19000405);
ASSERT_EQ(utils::date2num("10May22 "),20220510); ASSERT_EQ(utils::date2num("10May22 "), 20220510);
ASSERT_EQ(utils::date2num("1 Jun 05"),20050601); ASSERT_EQ(utils::date2num("1 Jun 05"), 20050601);
ASSERT_EQ(utils::date2num("10 Jul 2005"),20050710); ASSERT_EQ(utils::date2num("10 Jul 2005"), 20050710);
ASSERT_EQ(utils::date2num("02 Aug 10"),20100802); ASSERT_EQ(utils::date2num("02 Aug 10"), 20100802);
ASSERT_EQ(utils::date2num(" 5 September 99"),20990905); ASSERT_EQ(utils::date2num(" 5 September 99"), 20990905);
ASSERT_EQ(utils::date2num("10October22 "),20221010); ASSERT_EQ(utils::date2num("10October22 "), 20221010);
ASSERT_EQ(utils::date2num("30November 02"),20021130); ASSERT_EQ(utils::date2num("30November 02"), 20021130);
ASSERT_EQ(utils::date2num("31December100"),1001231); ASSERT_EQ(utils::date2num("31December100"), 1001231);
} }