reformat unittest sources with clang-format
This commit is contained in:
Axel Kohlmeyer
committed by
Richard Berger
Richard Berger
parent
a8b60848c3
commit
569a000e6b
@ -480,182 +480,182 @@ TEST_F(ResetIDsTest, TopologyData)
|
||||
ASSERT_EQ(lmp->atom->natoms, 23);
|
||||
ASSERT_EQ(lmp->atom->map_tag_max, 26);
|
||||
|
||||
auto num_bond = lmp->atom->num_bond;
|
||||
auto num_angle = lmp->atom->num_angle;
|
||||
auto num_dihedral = lmp->atom->num_dihedral;
|
||||
auto num_improper = lmp->atom->num_improper;
|
||||
auto bond_atom = lmp->atom->bond_atom;
|
||||
auto angle_atom1 = lmp->atom->angle_atom1;
|
||||
auto angle_atom2 = lmp->atom->angle_atom2;
|
||||
auto angle_atom3 = lmp->atom->angle_atom3;
|
||||
ASSERT_EQ(num_bond[GETIDX(1)],2);
|
||||
ASSERT_EQ(bond_atom[GETIDX(1)][0],2);
|
||||
ASSERT_EQ(bond_atom[GETIDX(1)][1],3);
|
||||
ASSERT_EQ(num_bond[GETIDX(2)],0);
|
||||
ASSERT_EQ(num_bond[GETIDX(3)],3);
|
||||
ASSERT_EQ(bond_atom[GETIDX(3)][0],4);
|
||||
ASSERT_EQ(bond_atom[GETIDX(3)][1],5);
|
||||
ASSERT_EQ(bond_atom[GETIDX(3)][2],6);
|
||||
ASSERT_EQ(num_bond[GETIDX(4)],0);
|
||||
ASSERT_EQ(num_bond[GETIDX(5)],0);
|
||||
ASSERT_EQ(num_bond[GETIDX(6)],2);
|
||||
ASSERT_EQ(bond_atom[GETIDX(6)][0],8);
|
||||
ASSERT_EQ(bond_atom[GETIDX(6)][1],7);
|
||||
ASSERT_EQ(num_bond[GETIDX(7)],0);
|
||||
ASSERT_EQ(num_bond[GETIDX(8)],2);
|
||||
ASSERT_EQ(bond_atom[GETIDX(8)][0],9);
|
||||
ASSERT_EQ(bond_atom[GETIDX(8)][1],10);
|
||||
ASSERT_EQ(num_bond[GETIDX(9)],0);
|
||||
ASSERT_EQ(num_bond[GETIDX(10)],3);
|
||||
ASSERT_EQ(bond_atom[GETIDX(10)][0],11);
|
||||
ASSERT_EQ(bond_atom[GETIDX(10)][1],12);
|
||||
ASSERT_EQ(bond_atom[GETIDX(10)][2],16);
|
||||
ASSERT_EQ(num_bond[GETIDX(11)],0);
|
||||
ASSERT_EQ(num_bond[GETIDX(12)],3);
|
||||
ASSERT_EQ(bond_atom[GETIDX(12)][0],13);
|
||||
ASSERT_EQ(bond_atom[GETIDX(12)][1],14);
|
||||
ASSERT_EQ(bond_atom[GETIDX(12)][2],15);
|
||||
ASSERT_EQ(num_bond[GETIDX(13)],0);
|
||||
ASSERT_EQ(num_bond[GETIDX(14)],0);
|
||||
ASSERT_EQ(num_bond[GETIDX(15)],0);
|
||||
ASSERT_EQ(num_bond[GETIDX(16)],1);
|
||||
ASSERT_EQ(bond_atom[GETIDX(16)][0],17);
|
||||
ASSERT_EQ(num_bond[GETIDX(17)],0);
|
||||
ASSERT_EQ(num_bond[GETIDX(18)],2);
|
||||
ASSERT_EQ(bond_atom[GETIDX(18)][0],19);
|
||||
ASSERT_EQ(bond_atom[GETIDX(18)][1],20);
|
||||
ASSERT_EQ(num_bond[GETIDX(19)],0);
|
||||
ASSERT_EQ(num_bond[GETIDX(20)],0);
|
||||
ASSERT_EQ(num_bond[GETIDX(24)],2);
|
||||
ASSERT_EQ(bond_atom[GETIDX(24)][0],25);
|
||||
ASSERT_EQ(bond_atom[GETIDX(24)][1],26);
|
||||
ASSERT_EQ(num_bond[GETIDX(25)],0);
|
||||
ASSERT_EQ(num_bond[GETIDX(26)],0);
|
||||
auto num_bond = lmp->atom->num_bond;
|
||||
auto num_angle = lmp->atom->num_angle;
|
||||
auto num_dihedral = lmp->atom->num_dihedral;
|
||||
auto num_improper = lmp->atom->num_improper;
|
||||
auto bond_atom = lmp->atom->bond_atom;
|
||||
auto angle_atom1 = lmp->atom->angle_atom1;
|
||||
auto angle_atom2 = lmp->atom->angle_atom2;
|
||||
auto angle_atom3 = lmp->atom->angle_atom3;
|
||||
ASSERT_EQ(num_bond[GETIDX(1)], 2);
|
||||
ASSERT_EQ(bond_atom[GETIDX(1)][0], 2);
|
||||
ASSERT_EQ(bond_atom[GETIDX(1)][1], 3);
|
||||
ASSERT_EQ(num_bond[GETIDX(2)], 0);
|
||||
ASSERT_EQ(num_bond[GETIDX(3)], 3);
|
||||
ASSERT_EQ(bond_atom[GETIDX(3)][0], 4);
|
||||
ASSERT_EQ(bond_atom[GETIDX(3)][1], 5);
|
||||
ASSERT_EQ(bond_atom[GETIDX(3)][2], 6);
|
||||
ASSERT_EQ(num_bond[GETIDX(4)], 0);
|
||||
ASSERT_EQ(num_bond[GETIDX(5)], 0);
|
||||
ASSERT_EQ(num_bond[GETIDX(6)], 2);
|
||||
ASSERT_EQ(bond_atom[GETIDX(6)][0], 8);
|
||||
ASSERT_EQ(bond_atom[GETIDX(6)][1], 7);
|
||||
ASSERT_EQ(num_bond[GETIDX(7)], 0);
|
||||
ASSERT_EQ(num_bond[GETIDX(8)], 2);
|
||||
ASSERT_EQ(bond_atom[GETIDX(8)][0], 9);
|
||||
ASSERT_EQ(bond_atom[GETIDX(8)][1], 10);
|
||||
ASSERT_EQ(num_bond[GETIDX(9)], 0);
|
||||
ASSERT_EQ(num_bond[GETIDX(10)], 3);
|
||||
ASSERT_EQ(bond_atom[GETIDX(10)][0], 11);
|
||||
ASSERT_EQ(bond_atom[GETIDX(10)][1], 12);
|
||||
ASSERT_EQ(bond_atom[GETIDX(10)][2], 16);
|
||||
ASSERT_EQ(num_bond[GETIDX(11)], 0);
|
||||
ASSERT_EQ(num_bond[GETIDX(12)], 3);
|
||||
ASSERT_EQ(bond_atom[GETIDX(12)][0], 13);
|
||||
ASSERT_EQ(bond_atom[GETIDX(12)][1], 14);
|
||||
ASSERT_EQ(bond_atom[GETIDX(12)][2], 15);
|
||||
ASSERT_EQ(num_bond[GETIDX(13)], 0);
|
||||
ASSERT_EQ(num_bond[GETIDX(14)], 0);
|
||||
ASSERT_EQ(num_bond[GETIDX(15)], 0);
|
||||
ASSERT_EQ(num_bond[GETIDX(16)], 1);
|
||||
ASSERT_EQ(bond_atom[GETIDX(16)][0], 17);
|
||||
ASSERT_EQ(num_bond[GETIDX(17)], 0);
|
||||
ASSERT_EQ(num_bond[GETIDX(18)], 2);
|
||||
ASSERT_EQ(bond_atom[GETIDX(18)][0], 19);
|
||||
ASSERT_EQ(bond_atom[GETIDX(18)][1], 20);
|
||||
ASSERT_EQ(num_bond[GETIDX(19)], 0);
|
||||
ASSERT_EQ(num_bond[GETIDX(20)], 0);
|
||||
ASSERT_EQ(num_bond[GETIDX(24)], 2);
|
||||
ASSERT_EQ(bond_atom[GETIDX(24)][0], 25);
|
||||
ASSERT_EQ(bond_atom[GETIDX(24)][1], 26);
|
||||
ASSERT_EQ(num_bond[GETIDX(25)], 0);
|
||||
ASSERT_EQ(num_bond[GETIDX(26)], 0);
|
||||
|
||||
ASSERT_EQ(num_angle[GETIDX(1)],1);
|
||||
ASSERT_EQ(angle_atom1[GETIDX(1)][0],2);
|
||||
ASSERT_EQ(angle_atom2[GETIDX(1)][0],1);
|
||||
ASSERT_EQ(angle_atom3[GETIDX(1)][0],3);
|
||||
ASSERT_EQ(num_angle[GETIDX(2)],0);
|
||||
ASSERT_EQ(num_angle[GETIDX(3)],6);
|
||||
ASSERT_EQ(angle_atom1[GETIDX(3)][0],1);
|
||||
ASSERT_EQ(angle_atom2[GETIDX(3)][0],3);
|
||||
ASSERT_EQ(angle_atom3[GETIDX(3)][0],5);
|
||||
ASSERT_EQ(angle_atom1[GETIDX(3)][1],1);
|
||||
ASSERT_EQ(angle_atom2[GETIDX(3)][1],3);
|
||||
ASSERT_EQ(angle_atom3[GETIDX(3)][1],4);
|
||||
ASSERT_EQ(angle_atom1[GETIDX(3)][2],1);
|
||||
ASSERT_EQ(angle_atom2[GETIDX(3)][2],3);
|
||||
ASSERT_EQ(angle_atom3[GETIDX(3)][2],6);
|
||||
ASSERT_EQ(angle_atom1[GETIDX(3)][3],4);
|
||||
ASSERT_EQ(angle_atom2[GETIDX(3)][3],3);
|
||||
ASSERT_EQ(angle_atom3[GETIDX(3)][3],5);
|
||||
ASSERT_EQ(angle_atom1[GETIDX(3)][4],5);
|
||||
ASSERT_EQ(angle_atom2[GETIDX(3)][4],3);
|
||||
ASSERT_EQ(angle_atom3[GETIDX(3)][4],6);
|
||||
ASSERT_EQ(num_angle[GETIDX(18)],1);
|
||||
ASSERT_EQ(angle_atom1[GETIDX(18)][0],19);
|
||||
ASSERT_EQ(angle_atom2[GETIDX(18)][0],18);
|
||||
ASSERT_EQ(angle_atom3[GETIDX(18)][0],20);
|
||||
ASSERT_EQ(num_angle[GETIDX(24)],1);
|
||||
ASSERT_EQ(angle_atom1[GETIDX(24)][0],25);
|
||||
ASSERT_EQ(angle_atom2[GETIDX(24)][0],24);
|
||||
ASSERT_EQ(angle_atom3[GETIDX(24)][0],26);
|
||||
ASSERT_EQ(num_angle[GETIDX(1)], 1);
|
||||
ASSERT_EQ(angle_atom1[GETIDX(1)][0], 2);
|
||||
ASSERT_EQ(angle_atom2[GETIDX(1)][0], 1);
|
||||
ASSERT_EQ(angle_atom3[GETIDX(1)][0], 3);
|
||||
ASSERT_EQ(num_angle[GETIDX(2)], 0);
|
||||
ASSERT_EQ(num_angle[GETIDX(3)], 6);
|
||||
ASSERT_EQ(angle_atom1[GETIDX(3)][0], 1);
|
||||
ASSERT_EQ(angle_atom2[GETIDX(3)][0], 3);
|
||||
ASSERT_EQ(angle_atom3[GETIDX(3)][0], 5);
|
||||
ASSERT_EQ(angle_atom1[GETIDX(3)][1], 1);
|
||||
ASSERT_EQ(angle_atom2[GETIDX(3)][1], 3);
|
||||
ASSERT_EQ(angle_atom3[GETIDX(3)][1], 4);
|
||||
ASSERT_EQ(angle_atom1[GETIDX(3)][2], 1);
|
||||
ASSERT_EQ(angle_atom2[GETIDX(3)][2], 3);
|
||||
ASSERT_EQ(angle_atom3[GETIDX(3)][2], 6);
|
||||
ASSERT_EQ(angle_atom1[GETIDX(3)][3], 4);
|
||||
ASSERT_EQ(angle_atom2[GETIDX(3)][3], 3);
|
||||
ASSERT_EQ(angle_atom3[GETIDX(3)][3], 5);
|
||||
ASSERT_EQ(angle_atom1[GETIDX(3)][4], 5);
|
||||
ASSERT_EQ(angle_atom2[GETIDX(3)][4], 3);
|
||||
ASSERT_EQ(angle_atom3[GETIDX(3)][4], 6);
|
||||
ASSERT_EQ(num_angle[GETIDX(18)], 1);
|
||||
ASSERT_EQ(angle_atom1[GETIDX(18)][0], 19);
|
||||
ASSERT_EQ(angle_atom2[GETIDX(18)][0], 18);
|
||||
ASSERT_EQ(angle_atom3[GETIDX(18)][0], 20);
|
||||
ASSERT_EQ(num_angle[GETIDX(24)], 1);
|
||||
ASSERT_EQ(angle_atom1[GETIDX(24)][0], 25);
|
||||
ASSERT_EQ(angle_atom2[GETIDX(24)][0], 24);
|
||||
ASSERT_EQ(angle_atom3[GETIDX(24)][0], 26);
|
||||
|
||||
if (!verbose) ::testing::internal::CaptureStdout();
|
||||
lmp->input->one("reset_atom_ids sort yes");
|
||||
if (!verbose) ::testing::internal::GetCapturedStdout();
|
||||
|
||||
num_bond = lmp->atom->num_bond;
|
||||
num_angle = lmp->atom->num_angle;
|
||||
num_dihedral = lmp->atom->num_dihedral;
|
||||
num_improper = lmp->atom->num_improper;
|
||||
bond_atom = lmp->atom->bond_atom;
|
||||
angle_atom1 = lmp->atom->angle_atom1;
|
||||
angle_atom2 = lmp->atom->angle_atom2;
|
||||
angle_atom3 = lmp->atom->angle_atom3;
|
||||
ASSERT_EQ(num_bond[GETIDX(1)],2);
|
||||
ASSERT_EQ(bond_atom[GETIDX(1)][0],3);
|
||||
ASSERT_EQ(bond_atom[GETIDX(1)][1],2);
|
||||
ASSERT_EQ(num_bond[GETIDX(2)],0);
|
||||
ASSERT_EQ(num_bond[GETIDX(3)],2);
|
||||
ASSERT_EQ(bond_atom[GETIDX(3)][0],16);
|
||||
ASSERT_EQ(bond_atom[GETIDX(3)][1],5);
|
||||
ASSERT_EQ(num_bond[GETIDX(4)],0);
|
||||
ASSERT_EQ(num_bond[GETIDX(5)],3);
|
||||
ASSERT_EQ(bond_atom[GETIDX(5)][0],4);
|
||||
ASSERT_EQ(bond_atom[GETIDX(5)][1],8);
|
||||
ASSERT_EQ(bond_atom[GETIDX(5)][2],18);
|
||||
ASSERT_EQ(num_bond[GETIDX(6)],0);
|
||||
ASSERT_EQ(num_bond[GETIDX(7)],0);
|
||||
ASSERT_EQ(num_bond[GETIDX(8)],3);
|
||||
ASSERT_EQ(bond_atom[GETIDX(8)][0],9);
|
||||
ASSERT_EQ(bond_atom[GETIDX(8)][1],6);
|
||||
ASSERT_EQ(bond_atom[GETIDX(8)][2],7);
|
||||
ASSERT_EQ(num_bond[GETIDX(9)],0);
|
||||
ASSERT_EQ(num_bond[GETIDX(10)],0);
|
||||
ASSERT_EQ(num_bond[GETIDX(11)],3);
|
||||
ASSERT_EQ(bond_atom[GETIDX(11)][0],10);
|
||||
ASSERT_EQ(bond_atom[GETIDX(11)][1],19);
|
||||
ASSERT_EQ(bond_atom[GETIDX(11)][2],1);
|
||||
ASSERT_EQ(num_bond[GETIDX(12)],0);
|
||||
ASSERT_EQ(num_bond[GETIDX(13)],0);
|
||||
ASSERT_EQ(num_bond[GETIDX(14)],2);
|
||||
ASSERT_EQ(bond_atom[GETIDX(14)][0],13);
|
||||
ASSERT_EQ(bond_atom[GETIDX(14)][1],15);
|
||||
ASSERT_EQ(num_bond[GETIDX(15)],0);
|
||||
ASSERT_EQ(num_bond[GETIDX(16)],0);
|
||||
ASSERT_EQ(num_bond[GETIDX(17)],0);
|
||||
ASSERT_EQ(num_bond[GETIDX(18)],1);
|
||||
ASSERT_EQ(bond_atom[GETIDX(18)][0],17);
|
||||
ASSERT_EQ(num_bond[GETIDX(19)],0);
|
||||
ASSERT_EQ(num_bond[GETIDX(20)],2);
|
||||
ASSERT_EQ(bond_atom[GETIDX(20)][0],12);
|
||||
ASSERT_EQ(bond_atom[GETIDX(20)][1],11);
|
||||
ASSERT_EQ(num_bond[GETIDX(21)],0);
|
||||
ASSERT_EQ(num_bond[GETIDX(22)],2);
|
||||
ASSERT_EQ(bond_atom[GETIDX(22)][0],21);
|
||||
ASSERT_EQ(bond_atom[GETIDX(22)][1],23);
|
||||
ASSERT_EQ(num_bond[GETIDX(23)],0);
|
||||
num_bond = lmp->atom->num_bond;
|
||||
num_angle = lmp->atom->num_angle;
|
||||
num_dihedral = lmp->atom->num_dihedral;
|
||||
num_improper = lmp->atom->num_improper;
|
||||
bond_atom = lmp->atom->bond_atom;
|
||||
angle_atom1 = lmp->atom->angle_atom1;
|
||||
angle_atom2 = lmp->atom->angle_atom2;
|
||||
angle_atom3 = lmp->atom->angle_atom3;
|
||||
ASSERT_EQ(num_bond[GETIDX(1)], 2);
|
||||
ASSERT_EQ(bond_atom[GETIDX(1)][0], 3);
|
||||
ASSERT_EQ(bond_atom[GETIDX(1)][1], 2);
|
||||
ASSERT_EQ(num_bond[GETIDX(2)], 0);
|
||||
ASSERT_EQ(num_bond[GETIDX(3)], 2);
|
||||
ASSERT_EQ(bond_atom[GETIDX(3)][0], 16);
|
||||
ASSERT_EQ(bond_atom[GETIDX(3)][1], 5);
|
||||
ASSERT_EQ(num_bond[GETIDX(4)], 0);
|
||||
ASSERT_EQ(num_bond[GETIDX(5)], 3);
|
||||
ASSERT_EQ(bond_atom[GETIDX(5)][0], 4);
|
||||
ASSERT_EQ(bond_atom[GETIDX(5)][1], 8);
|
||||
ASSERT_EQ(bond_atom[GETIDX(5)][2], 18);
|
||||
ASSERT_EQ(num_bond[GETIDX(6)], 0);
|
||||
ASSERT_EQ(num_bond[GETIDX(7)], 0);
|
||||
ASSERT_EQ(num_bond[GETIDX(8)], 3);
|
||||
ASSERT_EQ(bond_atom[GETIDX(8)][0], 9);
|
||||
ASSERT_EQ(bond_atom[GETIDX(8)][1], 6);
|
||||
ASSERT_EQ(bond_atom[GETIDX(8)][2], 7);
|
||||
ASSERT_EQ(num_bond[GETIDX(9)], 0);
|
||||
ASSERT_EQ(num_bond[GETIDX(10)], 0);
|
||||
ASSERT_EQ(num_bond[GETIDX(11)], 3);
|
||||
ASSERT_EQ(bond_atom[GETIDX(11)][0], 10);
|
||||
ASSERT_EQ(bond_atom[GETIDX(11)][1], 19);
|
||||
ASSERT_EQ(bond_atom[GETIDX(11)][2], 1);
|
||||
ASSERT_EQ(num_bond[GETIDX(12)], 0);
|
||||
ASSERT_EQ(num_bond[GETIDX(13)], 0);
|
||||
ASSERT_EQ(num_bond[GETIDX(14)], 2);
|
||||
ASSERT_EQ(bond_atom[GETIDX(14)][0], 13);
|
||||
ASSERT_EQ(bond_atom[GETIDX(14)][1], 15);
|
||||
ASSERT_EQ(num_bond[GETIDX(15)], 0);
|
||||
ASSERT_EQ(num_bond[GETIDX(16)], 0);
|
||||
ASSERT_EQ(num_bond[GETIDX(17)], 0);
|
||||
ASSERT_EQ(num_bond[GETIDX(18)], 1);
|
||||
ASSERT_EQ(bond_atom[GETIDX(18)][0], 17);
|
||||
ASSERT_EQ(num_bond[GETIDX(19)], 0);
|
||||
ASSERT_EQ(num_bond[GETIDX(20)], 2);
|
||||
ASSERT_EQ(bond_atom[GETIDX(20)][0], 12);
|
||||
ASSERT_EQ(bond_atom[GETIDX(20)][1], 11);
|
||||
ASSERT_EQ(num_bond[GETIDX(21)], 0);
|
||||
ASSERT_EQ(num_bond[GETIDX(22)], 2);
|
||||
ASSERT_EQ(bond_atom[GETIDX(22)][0], 21);
|
||||
ASSERT_EQ(bond_atom[GETIDX(22)][1], 23);
|
||||
ASSERT_EQ(num_bond[GETIDX(23)], 0);
|
||||
|
||||
ASSERT_EQ(num_angle[GETIDX(1)],3);
|
||||
ASSERT_EQ(angle_atom1[GETIDX(1)][0],11);
|
||||
ASSERT_EQ(angle_atom2[GETIDX(1)][0],1);
|
||||
ASSERT_EQ(angle_atom3[GETIDX(1)][0],2);
|
||||
ASSERT_EQ(angle_atom1[GETIDX(1)][1],11);
|
||||
ASSERT_EQ(angle_atom2[GETIDX(1)][1],1);
|
||||
ASSERT_EQ(angle_atom3[GETIDX(1)][1],3);
|
||||
ASSERT_EQ(angle_atom1[GETIDX(1)][2],2);
|
||||
ASSERT_EQ(angle_atom2[GETIDX(1)][2],1);
|
||||
ASSERT_EQ(angle_atom3[GETIDX(1)][2],3);
|
||||
ASSERT_EQ(num_angle[GETIDX(2)],0);
|
||||
ASSERT_EQ(num_angle[GETIDX(5)],6);
|
||||
ASSERT_EQ(angle_atom1[GETIDX(5)][0],3);
|
||||
ASSERT_EQ(angle_atom2[GETIDX(5)][0],5);
|
||||
ASSERT_EQ(angle_atom3[GETIDX(5)][0],4);
|
||||
ASSERT_EQ(angle_atom1[GETIDX(5)][1],3);
|
||||
ASSERT_EQ(angle_atom2[GETIDX(5)][1],5);
|
||||
ASSERT_EQ(angle_atom3[GETIDX(5)][1],18);
|
||||
ASSERT_EQ(angle_atom1[GETIDX(5)][2],4);
|
||||
ASSERT_EQ(angle_atom2[GETIDX(5)][2],5);
|
||||
ASSERT_EQ(angle_atom3[GETIDX(5)][2],8);
|
||||
ASSERT_EQ(angle_atom1[GETIDX(5)][3],8);
|
||||
ASSERT_EQ(angle_atom2[GETIDX(5)][3],5);
|
||||
ASSERT_EQ(angle_atom3[GETIDX(5)][3],18);
|
||||
ASSERT_EQ(angle_atom1[GETIDX(5)][4],3);
|
||||
ASSERT_EQ(angle_atom2[GETIDX(5)][4],5);
|
||||
ASSERT_EQ(angle_atom3[GETIDX(5)][4],8);
|
||||
ASSERT_EQ(angle_atom1[GETIDX(5)][5],4);
|
||||
ASSERT_EQ(angle_atom2[GETIDX(5)][5],5);
|
||||
ASSERT_EQ(angle_atom3[GETIDX(5)][5],18);
|
||||
ASSERT_EQ(num_angle[GETIDX(20)],1);
|
||||
ASSERT_EQ(angle_atom1[GETIDX(20)][0],12);
|
||||
ASSERT_EQ(angle_atom2[GETIDX(20)][0],20);
|
||||
ASSERT_EQ(angle_atom3[GETIDX(20)][0],11);
|
||||
ASSERT_EQ(num_angle[GETIDX(22)],1);
|
||||
ASSERT_EQ(angle_atom1[GETIDX(22)][0],21);
|
||||
ASSERT_EQ(angle_atom2[GETIDX(22)][0],22);
|
||||
ASSERT_EQ(angle_atom3[GETIDX(22)][0],23);
|
||||
ASSERT_EQ(num_angle[GETIDX(1)], 3);
|
||||
ASSERT_EQ(angle_atom1[GETIDX(1)][0], 11);
|
||||
ASSERT_EQ(angle_atom2[GETIDX(1)][0], 1);
|
||||
ASSERT_EQ(angle_atom3[GETIDX(1)][0], 2);
|
||||
ASSERT_EQ(angle_atom1[GETIDX(1)][1], 11);
|
||||
ASSERT_EQ(angle_atom2[GETIDX(1)][1], 1);
|
||||
ASSERT_EQ(angle_atom3[GETIDX(1)][1], 3);
|
||||
ASSERT_EQ(angle_atom1[GETIDX(1)][2], 2);
|
||||
ASSERT_EQ(angle_atom2[GETIDX(1)][2], 1);
|
||||
ASSERT_EQ(angle_atom3[GETIDX(1)][2], 3);
|
||||
ASSERT_EQ(num_angle[GETIDX(2)], 0);
|
||||
ASSERT_EQ(num_angle[GETIDX(5)], 6);
|
||||
ASSERT_EQ(angle_atom1[GETIDX(5)][0], 3);
|
||||
ASSERT_EQ(angle_atom2[GETIDX(5)][0], 5);
|
||||
ASSERT_EQ(angle_atom3[GETIDX(5)][0], 4);
|
||||
ASSERT_EQ(angle_atom1[GETIDX(5)][1], 3);
|
||||
ASSERT_EQ(angle_atom2[GETIDX(5)][1], 5);
|
||||
ASSERT_EQ(angle_atom3[GETIDX(5)][1], 18);
|
||||
ASSERT_EQ(angle_atom1[GETIDX(5)][2], 4);
|
||||
ASSERT_EQ(angle_atom2[GETIDX(5)][2], 5);
|
||||
ASSERT_EQ(angle_atom3[GETIDX(5)][2], 8);
|
||||
ASSERT_EQ(angle_atom1[GETIDX(5)][3], 8);
|
||||
ASSERT_EQ(angle_atom2[GETIDX(5)][3], 5);
|
||||
ASSERT_EQ(angle_atom3[GETIDX(5)][3], 18);
|
||||
ASSERT_EQ(angle_atom1[GETIDX(5)][4], 3);
|
||||
ASSERT_EQ(angle_atom2[GETIDX(5)][4], 5);
|
||||
ASSERT_EQ(angle_atom3[GETIDX(5)][4], 8);
|
||||
ASSERT_EQ(angle_atom1[GETIDX(5)][5], 4);
|
||||
ASSERT_EQ(angle_atom2[GETIDX(5)][5], 5);
|
||||
ASSERT_EQ(angle_atom3[GETIDX(5)][5], 18);
|
||||
ASSERT_EQ(num_angle[GETIDX(20)], 1);
|
||||
ASSERT_EQ(angle_atom1[GETIDX(20)][0], 12);
|
||||
ASSERT_EQ(angle_atom2[GETIDX(20)][0], 20);
|
||||
ASSERT_EQ(angle_atom3[GETIDX(20)][0], 11);
|
||||
ASSERT_EQ(num_angle[GETIDX(22)], 1);
|
||||
ASSERT_EQ(angle_atom1[GETIDX(22)][0], 21);
|
||||
ASSERT_EQ(angle_atom2[GETIDX(22)][0], 22);
|
||||
ASSERT_EQ(angle_atom3[GETIDX(22)][0], 23);
|
||||
}
|
||||
|
||||
TEST_F(ResetIDsTest, DeathTests)
|
||||
|
||||
@ -319,7 +319,7 @@ TEST_F(SimpleCommandsTest, Shell)
|
||||
lmp->input->one("shell putenv TEST_VARIABLE=simpletest");
|
||||
if (!verbose) ::testing::internal::GetCapturedStdout();
|
||||
|
||||
char * test_var = getenv("TEST_VARIABLE");
|
||||
char *test_var = getenv("TEST_VARIABLE");
|
||||
ASSERT_NE(test_var, nullptr);
|
||||
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");
|
||||
if (!verbose) ::testing::internal::GetCapturedStdout();
|
||||
|
||||
char * test_var2 = getenv("TEST_VARIABLE2");
|
||||
char * other_var = getenv("OTHER_VARIABLE");
|
||||
char *test_var2 = getenv("TEST_VARIABLE2");
|
||||
char *other_var = getenv("OTHER_VARIABLE");
|
||||
|
||||
ASSERT_NE(test_var2, nullptr);
|
||||
ASSERT_THAT(test_var2, StrEq("simpletest2"));
|
||||
|
||||
@ -1,114 +1,110 @@
|
||||
// unit tests for issuing command to a LAMMPS instance through the Input class
|
||||
|
||||
#include "lammps.h"
|
||||
#include "input.h"
|
||||
#include "atom.h"
|
||||
#include "input.h"
|
||||
#include "lammps.h"
|
||||
#include "memory.h"
|
||||
#include <cstring>
|
||||
#include <mpi.h>
|
||||
#include <string>
|
||||
#include <cstring>
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
const char *demo_input[] = {
|
||||
"region box block 0 $x 0 2 0 2",
|
||||
"create_box 1 box",
|
||||
"create_atoms 1 single 1.0 1.0 ${zpos}" };
|
||||
const char *cont_input[] = {
|
||||
"create_atoms 1 single &",
|
||||
"0.2 0.1 0.1" };
|
||||
const char *demo_input[] = {"region box block 0 $x 0 2 0 2", "create_box 1 box",
|
||||
"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:
|
||||
LAMMPS *lmp;
|
||||
Input_commands() {
|
||||
const char *args[] = {"LAMMPS_test"};
|
||||
char **argv = (char **)args;
|
||||
int argc = sizeof(args)/sizeof(char *);
|
||||
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);
|
||||
}
|
||||
~Input_commands() override {}
|
||||
int flag;
|
||||
MPI_Initialized(&flag);
|
||||
if (!flag) MPI_Init(&argc, &argv);
|
||||
}
|
||||
~Input_commands() override {}
|
||||
|
||||
void SetUp() override {
|
||||
const char *args[] = {"LAMMPS_test",
|
||||
"-log", "none",
|
||||
"-echo", "screen",
|
||||
"-nocite",
|
||||
"-var", "zpos", "1.5",
|
||||
"-var","x","2"};
|
||||
char **argv = (char **)args;
|
||||
int argc = sizeof(args)/sizeof(char *);
|
||||
void SetUp() override
|
||||
{
|
||||
const char *args[] = {"LAMMPS_test", "-log", "none", "-echo", "screen", "-nocite",
|
||||
"-var", "zpos", "1.5", "-var", "x", "2"};
|
||||
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_STREQ(output.substr(0,8).c_str(), "LAMMPS (");
|
||||
}
|
||||
void TearDown() override {
|
||||
::testing::internal::CaptureStdout();
|
||||
delete lmp;
|
||||
std::string output = ::testing::internal::GetCapturedStdout();
|
||||
EXPECT_STREQ(output.substr(0,16).c_str(), "Total wall time:");
|
||||
lmp = nullptr;
|
||||
}
|
||||
};
|
||||
::testing::internal::CaptureStdout();
|
||||
lmp = new LAMMPS(argc, argv, MPI_COMM_WORLD);
|
||||
std::string output = ::testing::internal::GetCapturedStdout();
|
||||
EXPECT_STREQ(output.substr(0, 8).c_str(), "LAMMPS (");
|
||||
}
|
||||
void TearDown() override
|
||||
{
|
||||
::testing::internal::CaptureStdout();
|
||||
delete lmp;
|
||||
std::string output = ::testing::internal::GetCapturedStdout();
|
||||
EXPECT_STREQ(output.substr(0, 16).c_str(), "Total wall time:");
|
||||
lmp = nullptr;
|
||||
}
|
||||
};
|
||||
|
||||
TEST_F(Input_commands, from_file) {
|
||||
FILE *fp;
|
||||
const char demo_file[] = "in.test";
|
||||
const char cont_file[] = "in.cont";
|
||||
TEST_F(Input_commands, from_file)
|
||||
{
|
||||
FILE *fp;
|
||||
const char demo_file[] = "in.test";
|
||||
const char cont_file[] = "in.cont";
|
||||
|
||||
fp = fopen(demo_file,"w");
|
||||
for (unsigned int i=0; i < sizeof(demo_input)/sizeof(char *); ++i) {
|
||||
fputs(demo_input[i],fp);
|
||||
fputc('\n',fp);
|
||||
}
|
||||
fclose(fp);
|
||||
fp = fopen(cont_file,"w");
|
||||
for (unsigned int i=0; i < sizeof(cont_input)/sizeof(char *); ++i) {
|
||||
fputs(cont_input[i],fp);
|
||||
fputc('\n',fp);
|
||||
}
|
||||
fclose(fp);
|
||||
fp = fopen(demo_file, "w");
|
||||
for (unsigned int i = 0; i < sizeof(demo_input) / sizeof(char *); ++i) {
|
||||
fputs(demo_input[i], fp);
|
||||
fputc('\n', fp);
|
||||
}
|
||||
fclose(fp);
|
||||
fp = fopen(cont_file, "w");
|
||||
for (unsigned int i = 0; i < sizeof(cont_input) / sizeof(char *); ++i) {
|
||||
fputs(cont_input[i], fp);
|
||||
fputc('\n', fp);
|
||||
}
|
||||
fclose(fp);
|
||||
|
||||
EXPECT_EQ(lmp->atom->natoms,0);
|
||||
lmp->input->file(demo_file);
|
||||
lmp->input->file(cont_file);
|
||||
EXPECT_EQ(lmp->atom->natoms,2);
|
||||
EXPECT_EQ(lmp->atom->natoms, 0);
|
||||
lmp->input->file(demo_file);
|
||||
lmp->input->file(cont_file);
|
||||
EXPECT_EQ(lmp->atom->natoms, 2);
|
||||
|
||||
unlink(demo_file);
|
||||
unlink(cont_file);
|
||||
};
|
||||
unlink(demo_file);
|
||||
unlink(cont_file);
|
||||
};
|
||||
|
||||
TEST_F(Input_commands, from_line) {
|
||||
EXPECT_EQ(lmp->atom->natoms,0);
|
||||
for (unsigned int i=0; i < sizeof(demo_input)/sizeof(char *); ++i) {
|
||||
lmp->input->one(demo_input[i]);
|
||||
}
|
||||
EXPECT_EQ(lmp->atom->natoms,1);
|
||||
};
|
||||
TEST_F(Input_commands, from_line)
|
||||
{
|
||||
EXPECT_EQ(lmp->atom->natoms, 0);
|
||||
for (unsigned int i = 0; i < sizeof(demo_input) / sizeof(char *); ++i) {
|
||||
lmp->input->one(demo_input[i]);
|
||||
}
|
||||
EXPECT_EQ(lmp->atom->natoms, 1);
|
||||
};
|
||||
|
||||
TEST_F(Input_commands, substitute) {
|
||||
char *string,*scratch;
|
||||
int nstring=100,nscratch=100;
|
||||
TEST_F(Input_commands, substitute)
|
||||
{
|
||||
char *string, *scratch;
|
||||
int nstring = 100, nscratch = 100;
|
||||
|
||||
lmp->memory->create(string,nstring,"test:string");
|
||||
lmp->memory->create(scratch,nscratch,"test:scratch");
|
||||
strcpy(string,demo_input[0]);
|
||||
lmp->input->substitute(string,scratch,nstring,nscratch,0);
|
||||
EXPECT_STREQ(string,"region box block 0 2 0 2 0 2");
|
||||
lmp->memory->create(string, nstring, "test:string");
|
||||
lmp->memory->create(scratch, nscratch, "test:scratch");
|
||||
strcpy(string, demo_input[0]);
|
||||
lmp->input->substitute(string, scratch, nstring, nscratch, 0);
|
||||
EXPECT_STREQ(string, "region box block 0 2 0 2 0 2");
|
||||
|
||||
strcpy(string,demo_input[2]);
|
||||
lmp->input->substitute(string,scratch,nstring,nscratch,0);
|
||||
EXPECT_STREQ(string,"create_atoms 1 single 1.0 1.0 1.5");
|
||||
lmp->memory->destroy(string);
|
||||
lmp->memory->destroy(scratch);
|
||||
};
|
||||
}
|
||||
strcpy(string, demo_input[2]);
|
||||
lmp->input->substitute(string, scratch, nstring, nscratch, 0);
|
||||
EXPECT_STREQ(string, "create_atoms 1 single 1.0 1.0 1.5");
|
||||
lmp->memory->destroy(string);
|
||||
lmp->memory->destroy(scratch);
|
||||
};
|
||||
} // namespace LAMMPS_NS
|
||||
|
||||
@ -1,8 +1,8 @@
|
||||
// unit tests for the LAMMPS base class
|
||||
|
||||
#include "lammps.h"
|
||||
#include <cstdio> // for stdin, stdout
|
||||
#include <mpi.h>
|
||||
#include <cstdio> // for stdin, stdout
|
||||
#include <string>
|
||||
|
||||
#include "gmock/gmock.h"
|
||||
@ -10,342 +10,326 @@
|
||||
|
||||
using ::testing::StartsWith;
|
||||
|
||||
namespace LAMMPS_NS
|
||||
{
|
||||
// test fixture for regular tests
|
||||
class LAMMPS_plain : public ::testing::Test {
|
||||
protected:
|
||||
LAMMPS *lmp;
|
||||
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)
|
||||
namespace LAMMPS_NS {
|
||||
// test fixture for regular tests
|
||||
class LAMMPS_plain : public ::testing::Test {
|
||||
protected:
|
||||
LAMMPS *lmp;
|
||||
LAMMPS_plain() : lmp(nullptr)
|
||||
{
|
||||
EXPECT_NE(lmp->memory, nullptr);
|
||||
EXPECT_NE(lmp->error, nullptr);
|
||||
EXPECT_NE(lmp->universe, nullptr);
|
||||
EXPECT_NE(lmp->input, nullptr);
|
||||
const char *args[] = {"LAMMPS_test"};
|
||||
char **argv = (char **)args;
|
||||
int argc = sizeof(args) / sizeof(char *);
|
||||
|
||||
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)");
|
||||
}
|
||||
int flag;
|
||||
MPI_Initialized(&flag);
|
||||
if (!flag) MPI_Init(&argc, &argv);
|
||||
}
|
||||
|
||||
TEST_F(LAMMPS_plain, TestStyles)
|
||||
~LAMMPS_plain() override { lmp = nullptr; }
|
||||
|
||||
void SetUp() override
|
||||
{
|
||||
// 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 *);
|
||||
const char *args[] = {"LAMMPS_test", "-log", "none", "-echo", "both", "-nocite"};
|
||||
char **argv = (char **)args;
|
||||
int argc = sizeof(args) / sizeof(char *);
|
||||
|
||||
::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();
|
||||
EXPECT_THAT(output,
|
||||
StartsWith("\nLarge-scale Atomic/Molecular Massively Parallel Simulator -"));
|
||||
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);
|
||||
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
|
||||
|
||||
@ -266,7 +266,7 @@ void generate_yaml_file(const char *outfile, const TestConfig &config)
|
||||
|
||||
// run_pos
|
||||
block.clear();
|
||||
auto x = lmp->atom->x;
|
||||
auto x = lmp->atom->x;
|
||||
for (int i = 1; i <= natoms; ++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]);
|
||||
@ -519,8 +519,8 @@ TEST(FixTimestep, plain)
|
||||
// rigid fixes need work to test properly with r-RESPA.
|
||||
// fix nve/limit cannot work with r-RESPA
|
||||
ifix = lmp->modify->find_fix("test");
|
||||
if (!utils::strmatch(lmp->modify->fix[ifix]->style, "^rigid")
|
||||
&& !utils::strmatch(lmp->modify->fix[ifix]->style, "^nve/limit")) {
|
||||
if (!utils::strmatch(lmp->modify->fix[ifix]->style, "^rigid") &&
|
||||
!utils::strmatch(lmp->modify->fix[ifix]->style, "^nve/limit")) {
|
||||
|
||||
if (!verbose) ::testing::internal::CaptureStdout();
|
||||
cleanup_lammps(lmp, test_config);
|
||||
|
||||
@ -12,9 +12,9 @@
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
#include "test_main.h"
|
||||
#include "pointers.h"
|
||||
#include "test_config.h"
|
||||
#include "test_config_reader.h"
|
||||
#include "pointers.h"
|
||||
#include "utils.h"
|
||||
#include "gmock/gmock.h"
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
@ -132,83 +132,82 @@ protected:
|
||||
|
||||
// default class Atom state
|
||||
struct AtomState {
|
||||
std::string atom_style = "atomic";
|
||||
bigint natoms = 0;
|
||||
int nlocal = 0;
|
||||
int nghost = 0;
|
||||
int nmax = 1;
|
||||
int tag_enable = 1;
|
||||
int molecular = Atom::ATOMIC;
|
||||
bigint nellipsoids = 0;
|
||||
bigint nlines = 0;
|
||||
bigint ntris = 0;
|
||||
bigint nbodies = 0;
|
||||
bigint nbonds = 0;
|
||||
bigint nangles = 0;
|
||||
bigint ndihedrals = 0;
|
||||
bigint nimpropers = 0;
|
||||
int ntypes = 0;
|
||||
int nbondtypes = 0;
|
||||
int nangletypes = 0;
|
||||
int ndihedraltypes = 0;
|
||||
int nimpropertypes = 0;
|
||||
int bond_per_atom = 0;
|
||||
int angle_per_atom = 0;
|
||||
int dihedral_per_atom = 0;
|
||||
int improper_per_atom = 0;
|
||||
int extra_bond_per_atom = 0;
|
||||
int extra_angle_per_atom = 0;
|
||||
std::string atom_style = "atomic";
|
||||
bigint natoms = 0;
|
||||
int nlocal = 0;
|
||||
int nghost = 0;
|
||||
int nmax = 1;
|
||||
int tag_enable = 1;
|
||||
int molecular = Atom::ATOMIC;
|
||||
bigint nellipsoids = 0;
|
||||
bigint nlines = 0;
|
||||
bigint ntris = 0;
|
||||
bigint nbodies = 0;
|
||||
bigint nbonds = 0;
|
||||
bigint nangles = 0;
|
||||
bigint ndihedrals = 0;
|
||||
bigint nimpropers = 0;
|
||||
int ntypes = 0;
|
||||
int nbondtypes = 0;
|
||||
int nangletypes = 0;
|
||||
int ndihedraltypes = 0;
|
||||
int nimpropertypes = 0;
|
||||
int bond_per_atom = 0;
|
||||
int angle_per_atom = 0;
|
||||
int dihedral_per_atom = 0;
|
||||
int improper_per_atom = 0;
|
||||
int extra_bond_per_atom = 0;
|
||||
int extra_angle_per_atom = 0;
|
||||
int extra_dihedral_per_atom = 0;
|
||||
int extra_improper_per_atom = 0;
|
||||
|
||||
int sphere_flag = 0;
|
||||
int ellipsoid_flag = 0;
|
||||
int line_flag = 0;
|
||||
int tri_flag = 0;
|
||||
int body_flag = 0;
|
||||
int peri_flag = 0;
|
||||
int electron_flag = 0;
|
||||
int wavepacket_flag = 0;
|
||||
int sph_flag = 0;
|
||||
int molecule_flag = 0;
|
||||
int molindex_flag = 0;
|
||||
int molatom_flag = 0;
|
||||
int q_flag = 0;
|
||||
int mu_flag = 0;
|
||||
int rmass_flag = 0;
|
||||
int radius_flag = 0;
|
||||
int omega_flag = 0;
|
||||
int torque_flag = 0;
|
||||
int angmom_flag = 0;
|
||||
int vfrac_flag = 0;
|
||||
int spin_flag = 0;
|
||||
int eradius_flag = 0;
|
||||
int ervel_flag = 0;
|
||||
int erforce_flag = 0;
|
||||
int cs_flag = 0;
|
||||
int csforce_flag = 0;
|
||||
int vforce_flag = 0;
|
||||
int ervelforce_flag = 0;
|
||||
int etag_flag = 0;
|
||||
int rho_flag = 0;
|
||||
int esph_flag = 0;
|
||||
int cv_flag = 0;
|
||||
int vest_flag = 0;
|
||||
int dpd_flag = 0;
|
||||
int edpd_flag = 0;
|
||||
int tdpd_flag = 0;
|
||||
int mesont_flag = 0;
|
||||
int sp_flag = 0;
|
||||
int x0_flag = 0;
|
||||
int smd_flag = 0;
|
||||
int damage_flag = 0;
|
||||
int contact_radius_flag = 0;
|
||||
int smd_data_9_flag = 0;
|
||||
int smd_stress_flag = 0;
|
||||
int eff_plastic_strain_flag = 0;
|
||||
int sphere_flag = 0;
|
||||
int ellipsoid_flag = 0;
|
||||
int line_flag = 0;
|
||||
int tri_flag = 0;
|
||||
int body_flag = 0;
|
||||
int peri_flag = 0;
|
||||
int electron_flag = 0;
|
||||
int wavepacket_flag = 0;
|
||||
int sph_flag = 0;
|
||||
int molecule_flag = 0;
|
||||
int molindex_flag = 0;
|
||||
int molatom_flag = 0;
|
||||
int q_flag = 0;
|
||||
int mu_flag = 0;
|
||||
int rmass_flag = 0;
|
||||
int radius_flag = 0;
|
||||
int omega_flag = 0;
|
||||
int torque_flag = 0;
|
||||
int angmom_flag = 0;
|
||||
int vfrac_flag = 0;
|
||||
int spin_flag = 0;
|
||||
int eradius_flag = 0;
|
||||
int ervel_flag = 0;
|
||||
int erforce_flag = 0;
|
||||
int cs_flag = 0;
|
||||
int csforce_flag = 0;
|
||||
int vforce_flag = 0;
|
||||
int ervelforce_flag = 0;
|
||||
int etag_flag = 0;
|
||||
int rho_flag = 0;
|
||||
int esph_flag = 0;
|
||||
int cv_flag = 0;
|
||||
int vest_flag = 0;
|
||||
int dpd_flag = 0;
|
||||
int edpd_flag = 0;
|
||||
int tdpd_flag = 0;
|
||||
int mesont_flag = 0;
|
||||
int sp_flag = 0;
|
||||
int x0_flag = 0;
|
||||
int smd_flag = 0;
|
||||
int damage_flag = 0;
|
||||
int contact_radius_flag = 0;
|
||||
int smd_data_9_flag = 0;
|
||||
int smd_stress_flag = 0;
|
||||
int eff_plastic_strain_flag = 0;
|
||||
int eff_plastic_strain_rate_flag = 0;
|
||||
double pdscale = 1.0;
|
||||
|
||||
double pdscale = 1.0;
|
||||
|
||||
int maxspecial = 1;
|
||||
|
||||
@ -217,48 +216,49 @@ struct AtomState {
|
||||
int nivector = 0;
|
||||
int ndvector = 0;
|
||||
|
||||
int nextra_grow = 0;
|
||||
int nextra_restart = 0;
|
||||
int nextra_border = 0;
|
||||
int nextra_grow_max = 0;
|
||||
int nextra_grow = 0;
|
||||
int nextra_restart = 0;
|
||||
int nextra_border = 0;
|
||||
int nextra_grow_max = 0;
|
||||
int nextra_restart_max = 0;
|
||||
int nextra_border_max = 0;
|
||||
int nextra_store = 0;
|
||||
int nextra_border_max = 0;
|
||||
int nextra_store = 0;
|
||||
|
||||
int map_style = Atom::MAP_NONE;
|
||||
int map_user = 0;
|
||||
int map_style = Atom::MAP_NONE;
|
||||
int map_user = 0;
|
||||
tagint map_tag_max = -1;
|
||||
|
||||
// properties X that aren't controlled by an equivalent X_flag
|
||||
bool has_type = true;
|
||||
bool has_mask = true;
|
||||
bool has_type = true;
|
||||
bool has_mask = true;
|
||||
bool has_image = true;
|
||||
bool has_x = true;
|
||||
bool has_v = true;
|
||||
bool has_f = true;
|
||||
bool has_x = true;
|
||||
bool has_v = true;
|
||||
bool has_f = true;
|
||||
|
||||
bool has_bonds = false;
|
||||
bool has_angles = false;
|
||||
bool has_bonds = false;
|
||||
bool has_angles = false;
|
||||
bool has_dihedral = false;
|
||||
bool has_improper = false;
|
||||
|
||||
bool has_iname = false;
|
||||
bool has_dname = false;
|
||||
bool has_mass = false;
|
||||
bool has_iname = false;
|
||||
bool has_dname = false;
|
||||
bool has_mass = false;
|
||||
bool has_mass_setflag = false;
|
||||
|
||||
bool has_nspecial = false;
|
||||
bool has_special = false;
|
||||
bool has_special = false;
|
||||
};
|
||||
|
||||
#define ASSERT_ARRAY_ALLOCATED(ptr, enabled) \
|
||||
if (enabled) { \
|
||||
ASSERT_NE(ptr, nullptr); \
|
||||
} else { \
|
||||
ASSERT_EQ(ptr, nullptr); \
|
||||
if (enabled) { \
|
||||
ASSERT_NE(ptr, nullptr); \
|
||||
} else { \
|
||||
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_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_dihedral_per_atom, expected.extra_dihedral_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->ellipsoid_flag, expected.ellipsoid_flag);
|
||||
ASSERT_EQ(atom->line_flag, expected.line_flag);
|
||||
@ -470,14 +470,14 @@ TEST_F(AtomStyleTest, atomic_is_default)
|
||||
{
|
||||
AtomState expected;
|
||||
expected.atom_style = "atomic";
|
||||
expected.molecular = Atom::ATOMIC;
|
||||
expected.molecular = Atom::ATOMIC;
|
||||
expected.tag_enable = 1;
|
||||
expected.has_type = true;
|
||||
expected.has_mask = true;
|
||||
expected.has_image = true;
|
||||
expected.has_x = true;
|
||||
expected.has_v = true;
|
||||
expected.has_f = true;
|
||||
expected.has_type = true;
|
||||
expected.has_mask = true;
|
||||
expected.has_image = true;
|
||||
expected.has_x = true;
|
||||
expected.has_v = true;
|
||||
expected.has_f = true;
|
||||
|
||||
ASSERT_ATOM_STATE_EQ(lmp->atom, expected);
|
||||
}
|
||||
@ -486,14 +486,14 @@ TEST_F(AtomStyleTest, atomic_after_charge)
|
||||
{
|
||||
AtomState expected;
|
||||
expected.atom_style = "atomic";
|
||||
expected.molecular = Atom::ATOMIC;
|
||||
expected.molecular = Atom::ATOMIC;
|
||||
expected.tag_enable = 1;
|
||||
expected.has_type = true;
|
||||
expected.has_mask = true;
|
||||
expected.has_image = true;
|
||||
expected.has_x = true;
|
||||
expected.has_v = true;
|
||||
expected.has_f = true;
|
||||
expected.has_type = true;
|
||||
expected.has_mask = true;
|
||||
expected.has_image = true;
|
||||
expected.has_x = true;
|
||||
expected.has_v = true;
|
||||
expected.has_f = true;
|
||||
|
||||
if (!verbose) ::testing::internal::CaptureStdout();
|
||||
lmp->input->one("atom_style charge");
|
||||
@ -702,15 +702,15 @@ TEST_F(AtomStyleTest, charge)
|
||||
|
||||
AtomState expected;
|
||||
expected.atom_style = "charge";
|
||||
expected.molecular = Atom::ATOMIC;
|
||||
expected.molecular = Atom::ATOMIC;
|
||||
expected.tag_enable = 1;
|
||||
expected.has_type = true;
|
||||
expected.has_image = true;
|
||||
expected.has_mask = true;
|
||||
expected.has_x = true;
|
||||
expected.has_v = true;
|
||||
expected.has_f = true;
|
||||
expected.q_flag = 1;
|
||||
expected.has_type = true;
|
||||
expected.has_image = true;
|
||||
expected.has_mask = true;
|
||||
expected.has_x = true;
|
||||
expected.has_v = true;
|
||||
expected.has_f = true;
|
||||
expected.q_flag = 1;
|
||||
ASSERT_ATOM_STATE_EQ(lmp->atom, expected);
|
||||
|
||||
if (!verbose) ::testing::internal::CaptureStdout();
|
||||
@ -878,20 +878,20 @@ TEST_F(AtomStyleTest, sphere)
|
||||
if (!verbose) ::testing::internal::GetCapturedStdout();
|
||||
|
||||
AtomState expected;
|
||||
expected.atom_style = "sphere";
|
||||
expected.molecular = Atom::ATOMIC;
|
||||
expected.tag_enable = 1;
|
||||
expected.atom_style = "sphere";
|
||||
expected.molecular = Atom::ATOMIC;
|
||||
expected.tag_enable = 1;
|
||||
expected.sphere_flag = 1;
|
||||
expected.rmass_flag = 1;
|
||||
expected.rmass_flag = 1;
|
||||
expected.radius_flag = 1;
|
||||
expected.omega_flag = 1;
|
||||
expected.omega_flag = 1;
|
||||
expected.torque_flag = 1;
|
||||
expected.has_type = true;
|
||||
expected.has_mask = true;
|
||||
expected.has_image = true;
|
||||
expected.has_x = true;
|
||||
expected.has_v = true;
|
||||
expected.has_f = true;
|
||||
expected.has_type = true;
|
||||
expected.has_mask = true;
|
||||
expected.has_image = true;
|
||||
expected.has_x = true;
|
||||
expected.has_v = true;
|
||||
expected.has_f = true;
|
||||
|
||||
ASSERT_ATOM_STATE_EQ(lmp->atom, expected);
|
||||
|
||||
@ -1049,19 +1049,19 @@ TEST_F(AtomStyleTest, ellipsoid)
|
||||
if (!verbose) ::testing::internal::GetCapturedStdout();
|
||||
|
||||
AtomState expected;
|
||||
expected.atom_style = "ellipsoid";
|
||||
expected.molecular = Atom::ATOMIC;
|
||||
expected.tag_enable = 1;
|
||||
expected.atom_style = "ellipsoid";
|
||||
expected.molecular = Atom::ATOMIC;
|
||||
expected.tag_enable = 1;
|
||||
expected.ellipsoid_flag = 1;
|
||||
expected.rmass_flag = 1;
|
||||
expected.angmom_flag = 1;
|
||||
expected.torque_flag = 1;
|
||||
expected.has_type = true;
|
||||
expected.has_mask = true;
|
||||
expected.has_image = true;
|
||||
expected.has_x = true;
|
||||
expected.has_v = true;
|
||||
expected.has_f = true;
|
||||
expected.rmass_flag = 1;
|
||||
expected.angmom_flag = 1;
|
||||
expected.torque_flag = 1;
|
||||
expected.has_type = true;
|
||||
expected.has_mask = true;
|
||||
expected.has_image = true;
|
||||
expected.has_x = true;
|
||||
expected.has_v = true;
|
||||
expected.has_f = true;
|
||||
|
||||
ASSERT_ATOM_STATE_EQ(lmp->atom, expected);
|
||||
|
||||
@ -1387,22 +1387,22 @@ TEST_F(AtomStyleTest, line)
|
||||
if (!verbose) ::testing::internal::GetCapturedStdout();
|
||||
|
||||
AtomState expected;
|
||||
expected.atom_style = "line";
|
||||
expected.molecular = Atom::ATOMIC;
|
||||
expected.tag_enable = 1;
|
||||
expected.sphere_flag = 1;
|
||||
expected.atom_style = "line";
|
||||
expected.molecular = Atom::ATOMIC;
|
||||
expected.tag_enable = 1;
|
||||
expected.sphere_flag = 1;
|
||||
expected.molecule_flag = 1;
|
||||
expected.line_flag = 1;
|
||||
expected.rmass_flag = 1;
|
||||
expected.radius_flag = 1;
|
||||
expected.omega_flag = 1;
|
||||
expected.torque_flag = 1;
|
||||
expected.has_type = true;
|
||||
expected.has_mask = true;
|
||||
expected.has_image = true;
|
||||
expected.has_x = true;
|
||||
expected.has_v = true;
|
||||
expected.has_f = true;
|
||||
expected.line_flag = 1;
|
||||
expected.rmass_flag = 1;
|
||||
expected.radius_flag = 1;
|
||||
expected.omega_flag = 1;
|
||||
expected.torque_flag = 1;
|
||||
expected.has_type = true;
|
||||
expected.has_mask = true;
|
||||
expected.has_image = true;
|
||||
expected.has_x = true;
|
||||
expected.has_v = true;
|
||||
expected.has_f = true;
|
||||
|
||||
ASSERT_ATOM_STATE_EQ(lmp->atom, expected);
|
||||
|
||||
@ -1657,23 +1657,23 @@ TEST_F(AtomStyleTest, tri)
|
||||
if (!verbose) ::testing::internal::GetCapturedStdout();
|
||||
|
||||
AtomState expected;
|
||||
expected.atom_style = "tri";
|
||||
expected.molecular = Atom::ATOMIC;
|
||||
expected.tag_enable = 1;
|
||||
expected.sphere_flag = 1;
|
||||
expected.atom_style = "tri";
|
||||
expected.molecular = Atom::ATOMIC;
|
||||
expected.tag_enable = 1;
|
||||
expected.sphere_flag = 1;
|
||||
expected.molecule_flag = 1;
|
||||
expected.tri_flag = 1;
|
||||
expected.rmass_flag = 1;
|
||||
expected.radius_flag = 1;
|
||||
expected.omega_flag = 1;
|
||||
expected.angmom_flag = 1;
|
||||
expected.torque_flag = 1;
|
||||
expected.has_type = true;
|
||||
expected.has_mask = true;
|
||||
expected.has_image = true;
|
||||
expected.has_x = true;
|
||||
expected.has_v = true;
|
||||
expected.has_f = true;
|
||||
expected.tri_flag = 1;
|
||||
expected.rmass_flag = 1;
|
||||
expected.radius_flag = 1;
|
||||
expected.omega_flag = 1;
|
||||
expected.angmom_flag = 1;
|
||||
expected.torque_flag = 1;
|
||||
expected.has_type = true;
|
||||
expected.has_mask = true;
|
||||
expected.has_image = true;
|
||||
expected.has_x = true;
|
||||
expected.has_v = true;
|
||||
expected.has_f = true;
|
||||
|
||||
ASSERT_ATOM_STATE_EQ(lmp->atom, expected);
|
||||
|
||||
@ -2061,20 +2061,20 @@ TEST_F(AtomStyleTest, body_nparticle)
|
||||
if (!verbose) ::testing::internal::GetCapturedStdout();
|
||||
|
||||
AtomState expected;
|
||||
expected.atom_style = "body";
|
||||
expected.molecular = Atom::ATOMIC;
|
||||
expected.tag_enable = 1;
|
||||
expected.body_flag = 1;
|
||||
expected.rmass_flag = 1;
|
||||
expected.atom_style = "body";
|
||||
expected.molecular = Atom::ATOMIC;
|
||||
expected.tag_enable = 1;
|
||||
expected.body_flag = 1;
|
||||
expected.rmass_flag = 1;
|
||||
expected.radius_flag = 1;
|
||||
expected.angmom_flag = 1;
|
||||
expected.torque_flag = 1;
|
||||
expected.has_type = true;
|
||||
expected.has_mask = true;
|
||||
expected.has_image = true;
|
||||
expected.has_x = true;
|
||||
expected.has_v = true;
|
||||
expected.has_f = true;
|
||||
expected.has_type = true;
|
||||
expected.has_mask = true;
|
||||
expected.has_image = true;
|
||||
expected.has_x = true;
|
||||
expected.has_v = true;
|
||||
expected.has_f = true;
|
||||
|
||||
ASSERT_ATOM_STATE_EQ(lmp->atom, expected);
|
||||
|
||||
@ -2631,22 +2631,22 @@ TEST_F(AtomStyleTest, template)
|
||||
if (!verbose) ::testing::internal::GetCapturedStdout();
|
||||
|
||||
AtomState expected;
|
||||
expected.atom_style = "template";
|
||||
expected.molecular = Atom::TEMPLATE;
|
||||
expected.nbondtypes = 2;
|
||||
expected.nangletypes = 2;
|
||||
expected.tag_enable = 1;
|
||||
expected.has_type = true;
|
||||
expected.has_mask = true;
|
||||
expected.has_image = true;
|
||||
expected.has_x = true;
|
||||
expected.has_v = true;
|
||||
expected.has_f = true;
|
||||
expected.atom_style = "template";
|
||||
expected.molecular = Atom::TEMPLATE;
|
||||
expected.nbondtypes = 2;
|
||||
expected.nangletypes = 2;
|
||||
expected.tag_enable = 1;
|
||||
expected.has_type = true;
|
||||
expected.has_mask = true;
|
||||
expected.has_image = true;
|
||||
expected.has_x = true;
|
||||
expected.has_v = true;
|
||||
expected.has_f = true;
|
||||
expected.molecule_flag = 1;
|
||||
expected.molindex_flag = 1;
|
||||
expected.molatom_flag = 1;
|
||||
expected.nmolecule = 2;
|
||||
expected.map_style = 3;
|
||||
expected.molatom_flag = 1;
|
||||
expected.nmolecule = 2;
|
||||
expected.map_style = 3;
|
||||
|
||||
ASSERT_ATOM_STATE_EQ(lmp->atom, expected);
|
||||
|
||||
@ -3027,23 +3027,23 @@ TEST_F(AtomStyleTest, template_charge)
|
||||
if (!verbose) ::testing::internal::GetCapturedStdout();
|
||||
|
||||
AtomState expected;
|
||||
expected.atom_style = "hybrid";
|
||||
expected.molecular = Atom::TEMPLATE;
|
||||
expected.nbondtypes = 2;
|
||||
expected.nangletypes = 2;
|
||||
expected.tag_enable = 1;
|
||||
expected.has_type = true;
|
||||
expected.has_mask = true;
|
||||
expected.has_image = true;
|
||||
expected.has_x = true;
|
||||
expected.has_v = true;
|
||||
expected.has_f = true;
|
||||
expected.atom_style = "hybrid";
|
||||
expected.molecular = Atom::TEMPLATE;
|
||||
expected.nbondtypes = 2;
|
||||
expected.nangletypes = 2;
|
||||
expected.tag_enable = 1;
|
||||
expected.has_type = true;
|
||||
expected.has_mask = true;
|
||||
expected.has_image = true;
|
||||
expected.has_x = true;
|
||||
expected.has_v = true;
|
||||
expected.has_f = true;
|
||||
expected.molecule_flag = 1;
|
||||
expected.molindex_flag = 1;
|
||||
expected.molatom_flag = 1;
|
||||
expected.q_flag = 1;
|
||||
expected.nmolecule = 2;
|
||||
expected.map_style = 3;
|
||||
expected.molatom_flag = 1;
|
||||
expected.q_flag = 1;
|
||||
expected.nmolecule = 2;
|
||||
expected.map_style = 3;
|
||||
|
||||
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->map_tag_max, 16);
|
||||
|
||||
|
||||
type = lmp->atom->type;
|
||||
molecule = lmp->atom->molecule;
|
||||
molindex = lmp->atom->molindex;
|
||||
@ -3456,20 +3455,20 @@ TEST_F(AtomStyleTest, bond)
|
||||
if (!verbose) ::testing::internal::GetCapturedStdout();
|
||||
|
||||
AtomState expected;
|
||||
expected.atom_style = "bond";
|
||||
expected.molecular = Atom::MOLECULAR;
|
||||
expected.tag_enable = 1;
|
||||
expected.atom_style = "bond";
|
||||
expected.molecular = Atom::MOLECULAR;
|
||||
expected.tag_enable = 1;
|
||||
expected.molecule_flag = 1;
|
||||
expected.has_type = true;
|
||||
expected.has_mask = true;
|
||||
expected.has_image = true;
|
||||
expected.has_x = true;
|
||||
expected.has_v = true;
|
||||
expected.has_f = true;
|
||||
expected.has_bonds = true;
|
||||
expected.has_nspecial = true;
|
||||
expected.has_special = true;
|
||||
expected.map_style = 3;
|
||||
expected.has_type = true;
|
||||
expected.has_mask = true;
|
||||
expected.has_image = true;
|
||||
expected.has_x = true;
|
||||
expected.has_v = true;
|
||||
expected.has_f = true;
|
||||
expected.has_bonds = true;
|
||||
expected.has_nspecial = true;
|
||||
expected.has_special = true;
|
||||
expected.map_style = 3;
|
||||
|
||||
ASSERT_ATOM_STATE_EQ(lmp->atom, expected);
|
||||
|
||||
@ -3804,21 +3803,21 @@ TEST_F(AtomStyleTest, angle)
|
||||
if (!verbose) ::testing::internal::GetCapturedStdout();
|
||||
|
||||
AtomState expected;
|
||||
expected.atom_style = "angle";
|
||||
expected.molecular = Atom::MOLECULAR;
|
||||
expected.tag_enable = 1;
|
||||
expected.atom_style = "angle";
|
||||
expected.molecular = Atom::MOLECULAR;
|
||||
expected.tag_enable = 1;
|
||||
expected.molecule_flag = 1;
|
||||
expected.has_type = true;
|
||||
expected.has_mask = true;
|
||||
expected.has_image = true;
|
||||
expected.has_x = true;
|
||||
expected.has_v = true;
|
||||
expected.has_f = true;
|
||||
expected.has_bonds = true;
|
||||
expected.has_angles = true;
|
||||
expected.has_nspecial = true;
|
||||
expected.has_special = true;
|
||||
expected.map_style = 3;
|
||||
expected.has_type = true;
|
||||
expected.has_mask = true;
|
||||
expected.has_image = true;
|
||||
expected.has_x = true;
|
||||
expected.has_v = true;
|
||||
expected.has_f = true;
|
||||
expected.has_bonds = true;
|
||||
expected.has_angles = true;
|
||||
expected.has_nspecial = true;
|
||||
expected.has_special = true;
|
||||
expected.map_style = 3;
|
||||
|
||||
ASSERT_ATOM_STATE_EQ(lmp->atom, expected);
|
||||
|
||||
@ -4164,28 +4163,28 @@ TEST_F(AtomStyleTest, full_ellipsoid)
|
||||
if (!verbose) ::testing::internal::GetCapturedStdout();
|
||||
|
||||
AtomState expected;
|
||||
expected.atom_style = "hybrid";
|
||||
expected.molecular = Atom::MOLECULAR;
|
||||
expected.tag_enable = 1;
|
||||
expected.molecule_flag = 1;
|
||||
expected.atom_style = "hybrid";
|
||||
expected.molecular = Atom::MOLECULAR;
|
||||
expected.tag_enable = 1;
|
||||
expected.molecule_flag = 1;
|
||||
expected.ellipsoid_flag = 1;
|
||||
expected.q_flag = 1;
|
||||
expected.rmass_flag = 1;
|
||||
expected.torque_flag = 1;
|
||||
expected.angmom_flag = 1;
|
||||
expected.has_type = true;
|
||||
expected.has_mask = true;
|
||||
expected.has_image = true;
|
||||
expected.has_x = true;
|
||||
expected.has_v = true;
|
||||
expected.has_f = true;
|
||||
expected.has_bonds = true;
|
||||
expected.has_angles = true;
|
||||
expected.has_dihedral = true;
|
||||
expected.has_improper = true;
|
||||
expected.has_nspecial = true;
|
||||
expected.has_special = true;
|
||||
expected.map_style = 3;
|
||||
expected.q_flag = 1;
|
||||
expected.rmass_flag = 1;
|
||||
expected.torque_flag = 1;
|
||||
expected.angmom_flag = 1;
|
||||
expected.has_type = true;
|
||||
expected.has_mask = true;
|
||||
expected.has_image = true;
|
||||
expected.has_x = true;
|
||||
expected.has_v = true;
|
||||
expected.has_f = true;
|
||||
expected.has_bonds = true;
|
||||
expected.has_angles = true;
|
||||
expected.has_dihedral = true;
|
||||
expected.has_improper = true;
|
||||
expected.has_nspecial = true;
|
||||
expected.has_special = true;
|
||||
expected.map_style = 3;
|
||||
|
||||
ASSERT_ATOM_STATE_EQ(lmp->atom, expected);
|
||||
|
||||
|
||||
@ -11,30 +11,33 @@
|
||||
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/systems/melt.h"
|
||||
#include "../testing/utils.h"
|
||||
#include "fmt/format.h"
|
||||
#include "utils.h"
|
||||
#include "gmock/gmock.h"
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
#include <string>
|
||||
|
||||
using ::testing::Eq;
|
||||
|
||||
char * BINARY2TXT_BINARY = nullptr;
|
||||
char *BINARY2TXT_BINARY = nullptr;
|
||||
|
||||
class DumpAtomTest : public MeltTest {
|
||||
std::string dump_style = "atom";
|
||||
|
||||
public:
|
||||
void enable_triclinic() {
|
||||
void enable_triclinic()
|
||||
{
|
||||
if (!verbose) ::testing::internal::CaptureStdout();
|
||||
command("change_box all triclinic");
|
||||
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();
|
||||
command(fmt::format("dump id all {} 1 {}", dump_style, dump_file));
|
||||
|
||||
@ -46,7 +49,9 @@ public:
|
||||
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();
|
||||
command(fmt::format("dump id0 all {} 1 {}", dump_style, text_file));
|
||||
command(fmt::format("dump id1 all {} 1 {}", dump_style, binary_file));
|
||||
@ -60,7 +65,8 @@ public:
|
||||
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();
|
||||
std::string cmdline = fmt::format("{} {}", BINARY2TXT_BINARY, binary_file);
|
||||
system(cmdline.c_str());
|
||||
@ -290,9 +296,9 @@ TEST_F(DumpAtomTest, triclinic_with_image_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";
|
||||
|
||||
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)
|
||||
{
|
||||
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";
|
||||
|
||||
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)
|
||||
{
|
||||
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";
|
||||
|
||||
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)
|
||||
{
|
||||
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";
|
||||
|
||||
enable_triclinic();
|
||||
@ -375,9 +381,9 @@ TEST_F(DumpAtomTest, binary_triclinic_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";
|
||||
|
||||
enable_triclinic();
|
||||
@ -397,9 +403,9 @@ TEST_F(DumpAtomTest, binary_triclinic_with_units_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";
|
||||
|
||||
enable_triclinic();
|
||||
@ -419,9 +425,9 @@ TEST_F(DumpAtomTest, binary_triclinic_with_time_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";
|
||||
|
||||
enable_triclinic();
|
||||
@ -501,8 +507,7 @@ TEST_F(DumpAtomTest, dump_modify_scale_invalid)
|
||||
command("dump id all atom 1 dump.txt");
|
||||
if (!verbose) ::testing::internal::GetCapturedStdout();
|
||||
|
||||
TEST_FAILURE(".*Illegal dump_modify command.*",
|
||||
command("dump_modify id scale true"););
|
||||
TEST_FAILURE(".*Illegal dump_modify command.*", command("dump_modify id scale true"););
|
||||
}
|
||||
|
||||
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");
|
||||
if (!verbose) ::testing::internal::GetCapturedStdout();
|
||||
|
||||
TEST_FAILURE(".*Illegal dump_modify command.*",
|
||||
command("dump_modify id image true"););
|
||||
TEST_FAILURE(".*Illegal dump_modify command.*", command("dump_modify id image true"););
|
||||
}
|
||||
|
||||
TEST_F(DumpAtomTest, dump_modify_invalid)
|
||||
@ -521,8 +525,7 @@ TEST_F(DumpAtomTest, dump_modify_invalid)
|
||||
command("dump id all atom 1 dump.txt");
|
||||
if (!verbose) ::testing::internal::GetCapturedStdout();
|
||||
|
||||
TEST_FAILURE(".*Illegal dump_modify command.*",
|
||||
command("dump_modify id true"););
|
||||
TEST_FAILURE(".*Illegal dump_modify command.*", command("dump_modify id true"););
|
||||
}
|
||||
|
||||
TEST_F(DumpAtomTest, write_dump)
|
||||
@ -547,7 +550,7 @@ TEST_F(DumpAtomTest, 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 dump_file = "write_dump_atom_run0_p0.melt.bin";
|
||||
|
||||
@ -11,30 +11,33 @@
|
||||
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/systems/melt.h"
|
||||
#include "../testing/utils.h"
|
||||
#include "fmt/format.h"
|
||||
#include "utils.h"
|
||||
#include "gmock/gmock.h"
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
#include <string>
|
||||
|
||||
char * GZIP_BINARY = nullptr;
|
||||
char *GZIP_BINARY = nullptr;
|
||||
|
||||
using ::testing::Eq;
|
||||
|
||||
class DumpAtomGZTest : public MeltTest {
|
||||
std::string dump_style = "atom";
|
||||
|
||||
public:
|
||||
void enable_triclinic() {
|
||||
void enable_triclinic()
|
||||
{
|
||||
if (!verbose) ::testing::internal::CaptureStdout();
|
||||
command("change_box all triclinic");
|
||||
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();
|
||||
command(fmt::format("dump id all {} 1 {}", dump_style, dump_file));
|
||||
|
||||
@ -46,7 +49,10 @@ public:
|
||||
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();
|
||||
command(fmt::format("dump id0 all {} 1 {}", dump_style, text_file));
|
||||
command(fmt::format("dump id1 all {} 1 {}", compression_style, compressed_file));
|
||||
@ -60,26 +66,27 @@ public:
|
||||
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();
|
||||
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());
|
||||
if (!verbose) ::testing::internal::GetCapturedStdout();
|
||||
return converted_file;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
//-------------------------------------------------------------------------------------------------
|
||||
// GZ compressed files
|
||||
//-------------------------------------------------------------------------------------------------
|
||||
|
||||
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";
|
||||
|
||||
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)
|
||||
{
|
||||
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";
|
||||
|
||||
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();
|
||||
|
||||
@ -124,12 +132,13 @@ TEST_F(DumpAtomGZTest, compressed_with_units_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";
|
||||
|
||||
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();
|
||||
|
||||
@ -147,9 +156,9 @@ TEST_F(DumpAtomGZTest, compressed_with_time_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";
|
||||
|
||||
enable_triclinic();
|
||||
@ -171,13 +180,14 @@ TEST_F(DumpAtomGZTest, compressed_triclinic_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";
|
||||
|
||||
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();
|
||||
|
||||
@ -195,13 +205,14 @@ TEST_F(DumpAtomGZTest, compressed_triclinic_with_units_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";
|
||||
|
||||
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();
|
||||
|
||||
@ -219,9 +230,9 @@ TEST_F(DumpAtomGZTest, compressed_triclinic_with_time_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";
|
||||
|
||||
enable_triclinic();
|
||||
|
||||
@ -11,30 +11,33 @@
|
||||
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/systems/melt.h"
|
||||
#include "../testing/utils.h"
|
||||
#include "fmt/format.h"
|
||||
#include "utils.h"
|
||||
#include "gmock/gmock.h"
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
#include <string>
|
||||
|
||||
char * ZSTD_BINARY = nullptr;
|
||||
char *ZSTD_BINARY = nullptr;
|
||||
|
||||
using ::testing::Eq;
|
||||
|
||||
class DumpAtomZSTDTest : public MeltTest {
|
||||
std::string dump_style = "atom";
|
||||
|
||||
public:
|
||||
void enable_triclinic() {
|
||||
void enable_triclinic()
|
||||
{
|
||||
if (!verbose) ::testing::internal::CaptureStdout();
|
||||
command("change_box all triclinic");
|
||||
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();
|
||||
command(fmt::format("dump id all {} 1 {}", dump_style, dump_file));
|
||||
|
||||
@ -46,7 +49,10 @@ public:
|
||||
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();
|
||||
command(fmt::format("dump id0 all {} 1 {}", dump_style, text_file));
|
||||
command(fmt::format("dump id1 all {} 1 {}", compression_style, compressed_file));
|
||||
@ -60,26 +66,27 @@ public:
|
||||
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();
|
||||
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());
|
||||
if (!verbose) ::testing::internal::GetCapturedStdout();
|
||||
return converted_file;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
//-------------------------------------------------------------------------------------------------
|
||||
// ZSTD compressed files
|
||||
//-------------------------------------------------------------------------------------------------
|
||||
|
||||
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";
|
||||
|
||||
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)
|
||||
{
|
||||
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";
|
||||
|
||||
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
|
||||
TearDown();
|
||||
@ -126,12 +134,13 @@ TEST_F(DumpAtomZSTDTest, compressed_with_units_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";
|
||||
|
||||
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
|
||||
TearDown();
|
||||
@ -150,9 +159,9 @@ TEST_F(DumpAtomZSTDTest, compressed_with_time_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";
|
||||
|
||||
enable_triclinic();
|
||||
@ -175,13 +184,14 @@ TEST_F(DumpAtomZSTDTest, compressed_triclinic_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";
|
||||
|
||||
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
|
||||
TearDown();
|
||||
@ -200,13 +210,14 @@ TEST_F(DumpAtomZSTDTest, compressed_triclinic_with_units_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";
|
||||
|
||||
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
|
||||
TearDown();
|
||||
@ -225,9 +236,9 @@ TEST_F(DumpAtomZSTDTest, compressed_triclinic_with_time_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";
|
||||
|
||||
enable_triclinic();
|
||||
|
||||
@ -11,20 +11,23 @@
|
||||
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/systems/melt.h"
|
||||
#include "../testing/utils.h"
|
||||
#include "fmt/format.h"
|
||||
#include "utils.h"
|
||||
#include "gmock/gmock.h"
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
using ::testing::Eq;
|
||||
|
||||
class DumpCfgTest : public MeltTest {
|
||||
std::string dump_style = "cfg";
|
||||
|
||||
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();
|
||||
command(fmt::format("dump id all {} 1 {} {}", dump_style, dump_file, fields));
|
||||
|
||||
@ -40,28 +43,26 @@ public:
|
||||
TEST_F(DumpCfgTest, invalid_options)
|
||||
{
|
||||
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)
|
||||
{
|
||||
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();
|
||||
command(fmt::format("dump id all cfg 1 {} {}", dump_file, fields));
|
||||
if (!verbose) ::testing::internal::GetCapturedStdout();
|
||||
|
||||
TEST_FAILURE(".*Dump cfg requires one snapshot per file.*",
|
||||
command("run 0");
|
||||
);
|
||||
TEST_FAILURE(".*Dump cfg requires one snapshot per file.*", command("run 0"););
|
||||
}
|
||||
|
||||
TEST_F(DumpCfgTest, run0)
|
||||
{
|
||||
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);
|
||||
|
||||
@ -75,7 +76,7 @@ TEST_F(DumpCfgTest, run0)
|
||||
TEST_F(DumpCfgTest, unwrap_run0)
|
||||
{
|
||||
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);
|
||||
|
||||
@ -89,7 +90,7 @@ TEST_F(DumpCfgTest, unwrap_run0)
|
||||
TEST_F(DumpCfgTest, no_buffer_run0)
|
||||
{
|
||||
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);
|
||||
|
||||
@ -103,7 +104,7 @@ TEST_F(DumpCfgTest, no_buffer_run0)
|
||||
TEST_F(DumpCfgTest, no_unwrap_no_buffer_run0)
|
||||
{
|
||||
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);
|
||||
|
||||
@ -114,7 +115,6 @@ TEST_F(DumpCfgTest, no_unwrap_no_buffer_run0)
|
||||
delete_file("dump_cfg_no_unwrap_no_buffer_run0.melt.cfg");
|
||||
}
|
||||
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
MPI_Init(&argc, &argv);
|
||||
|
||||
@ -11,23 +11,26 @@
|
||||
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/systems/melt.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;
|
||||
|
||||
class DumpCfgGZTest : public MeltTest {
|
||||
std::string dump_style = "cfg";
|
||||
|
||||
public:
|
||||
void generate_text_and_compressed_dump(std::string text_file, std::string compressed_file, std::string compression_style,
|
||||
std::string fields, 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 fields,
|
||||
std::string dump_modify_options, int ntimesteps)
|
||||
{
|
||||
if (!verbose) ::testing::internal::CaptureStdout();
|
||||
command(fmt::format("dump id0 all {} 1 {} {}", dump_style, text_file, fields));
|
||||
command(fmt::format("dump id1 all {} 1 {} {}", compression_style, compressed_file, fields));
|
||||
@ -41,10 +44,12 @@ public:
|
||||
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();
|
||||
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());
|
||||
if (!verbose) ::testing::internal::GetCapturedStdout();
|
||||
return converted_file;
|
||||
@ -53,13 +58,13 @@ public:
|
||||
|
||||
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 text_file = "dump_cfg_gz_text_run0.melt.cfg";
|
||||
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 text_file = "dump_cfg_gz_text_run0.melt.cfg";
|
||||
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";
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
|
||||
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 text_file = "dump_cfg_unwrap_gz_text_run0.melt.cfg";
|
||||
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 text_file = "dump_cfg_unwrap_gz_text_run0.melt.cfg";
|
||||
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";
|
||||
|
||||
generate_text_and_compressed_dump(text_files, compressed_files, "cfg/gz", fields, "", 0);
|
||||
|
||||
|
||||
@ -11,23 +11,26 @@
|
||||
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/systems/melt.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;
|
||||
|
||||
class DumpCfgZstdTest : public MeltTest {
|
||||
std::string dump_style = "cfg";
|
||||
|
||||
public:
|
||||
void generate_text_and_compressed_dump(std::string text_file, std::string compressed_file, std::string compression_style,
|
||||
std::string fields, 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 fields,
|
||||
std::string dump_modify_options, int ntimesteps)
|
||||
{
|
||||
if (!verbose) ::testing::internal::CaptureStdout();
|
||||
command(fmt::format("dump id0 all {} 1 {} {}", dump_style, text_file, fields));
|
||||
command(fmt::format("dump id1 all {} 1 {} {}", compression_style, compressed_file, fields));
|
||||
@ -41,10 +44,12 @@ public:
|
||||
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();
|
||||
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());
|
||||
if (!verbose) ::testing::internal::GetCapturedStdout();
|
||||
return converted_file;
|
||||
@ -53,13 +58,13 @@ public:
|
||||
|
||||
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 text_file = "dump_cfg_zstd_text_run0.melt.cfg";
|
||||
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 text_file = "dump_cfg_zstd_text_run0.melt.cfg";
|
||||
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";
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
|
||||
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 text_file = "dump_cfg_unwrap_zstd_text_run0.melt.cfg";
|
||||
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 text_file = "dump_cfg_unwrap_zstd_text_run0.melt.cfg";
|
||||
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";
|
||||
|
||||
generate_text_and_compressed_dump(text_files, compressed_files, "cfg/zstd", fields, "", 0);
|
||||
|
||||
|
||||
@ -11,28 +11,32 @@
|
||||
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/systems/melt.h"
|
||||
#include "../testing/utils.h"
|
||||
#include "fmt/format.h"
|
||||
#include "utils.h"
|
||||
#include "gmock/gmock.h"
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
using ::testing::Eq;
|
||||
|
||||
char * BINARY2TXT_BINARY = nullptr;
|
||||
char *BINARY2TXT_BINARY = nullptr;
|
||||
|
||||
class DumpCustomTest : public MeltTest {
|
||||
std::string dump_style = "custom";
|
||||
|
||||
public:
|
||||
void enable_triclinic() {
|
||||
void enable_triclinic()
|
||||
{
|
||||
if (!verbose) ::testing::internal::CaptureStdout();
|
||||
command("change_box all triclinic");
|
||||
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();
|
||||
command(fmt::format("dump id all {} 1 {} {}", dump_style, dump_file, fields));
|
||||
|
||||
@ -44,8 +48,10 @@ public:
|
||||
if (!verbose) ::testing::internal::GetCapturedStdout();
|
||||
}
|
||||
|
||||
void generate_text_and_binary_dump(std::string text_file, std::string binary_file, std::string fields,
|
||||
std::string dump_modify_options, int ntimesteps) {
|
||||
void generate_text_and_binary_dump(std::string text_file, std::string binary_file,
|
||||
std::string fields, std::string dump_modify_options,
|
||||
int ntimesteps)
|
||||
{
|
||||
if (!verbose) ::testing::internal::CaptureStdout();
|
||||
command(fmt::format("dump id0 all {} 1 {} {}", dump_style, text_file, fields));
|
||||
command(fmt::format("dump id1 all {} 1 {} {}", dump_style, binary_file, fields));
|
||||
@ -59,7 +65,8 @@ public:
|
||||
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();
|
||||
std::string cmdline = fmt::format("{} {}", BINARY2TXT_BINARY, binary_file);
|
||||
system(cmdline.c_str());
|
||||
@ -71,7 +78,8 @@ public:
|
||||
TEST_F(DumpCustomTest, run1)
|
||||
{
|
||||
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);
|
||||
|
||||
@ -88,7 +96,7 @@ TEST_F(DumpCustomTest, run1)
|
||||
TEST_F(DumpCustomTest, thresh_run0)
|
||||
{
|
||||
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);
|
||||
|
||||
@ -109,7 +117,7 @@ TEST_F(DumpCustomTest, compute_run0)
|
||||
if (!verbose) ::testing::internal::GetCapturedStdout();
|
||||
|
||||
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);
|
||||
|
||||
@ -130,7 +138,7 @@ TEST_F(DumpCustomTest, fix_run0)
|
||||
if (!verbose) ::testing::internal::GetCapturedStdout();
|
||||
|
||||
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);
|
||||
|
||||
@ -152,7 +160,7 @@ TEST_F(DumpCustomTest, custom_run0)
|
||||
if (!verbose) ::testing::internal::GetCapturedStdout();
|
||||
|
||||
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);
|
||||
|
||||
@ -168,9 +176,9 @@ TEST_F(DumpCustomTest, custom_run0)
|
||||
|
||||
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 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)
|
||||
{
|
||||
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();
|
||||
|
||||
@ -209,12 +217,12 @@ TEST_F(DumpCustomTest, 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 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();
|
||||
|
||||
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();
|
||||
|
||||
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);
|
||||
|
||||
ASSERT_FILE_EXISTS(dump_file);
|
||||
@ -253,7 +261,6 @@ TEST_F(DumpCustomTest, with_variable_run1)
|
||||
delete_file(dump_file);
|
||||
}
|
||||
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
MPI_Init(&argc, &argv);
|
||||
|
||||
@ -11,28 +11,32 @@
|
||||
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/systems/melt.h"
|
||||
#include "../testing/utils.h"
|
||||
#include "fmt/format.h"
|
||||
#include "utils.h"
|
||||
#include "gmock/gmock.h"
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
using ::testing::Eq;
|
||||
|
||||
char * GZIP_BINARY = nullptr;
|
||||
char *GZIP_BINARY = nullptr;
|
||||
|
||||
class DumpCustomGZTest : public MeltTest {
|
||||
std::string dump_style = "custom";
|
||||
|
||||
public:
|
||||
void enable_triclinic() {
|
||||
void enable_triclinic()
|
||||
{
|
||||
if (!verbose) ::testing::internal::CaptureStdout();
|
||||
command("change_box all triclinic");
|
||||
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();
|
||||
command(fmt::format("dump id all {} 1 {} {}", dump_style, dump_file, fields));
|
||||
|
||||
@ -44,8 +48,10 @@ public:
|
||||
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 fields, 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 fields,
|
||||
std::string dump_modify_options, int ntimesteps)
|
||||
{
|
||||
if (!verbose) ::testing::internal::CaptureStdout();
|
||||
command(fmt::format("dump id0 all {} 1 {} {}", dump_style, text_file, fields));
|
||||
command(fmt::format("dump id1 all {} 1 {} {}", compression_style, compressed_file, fields));
|
||||
@ -59,10 +65,12 @@ public:
|
||||
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();
|
||||
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());
|
||||
if (!verbose) ::testing::internal::GetCapturedStdout();
|
||||
return converted_file;
|
||||
@ -71,13 +79,14 @@ public:
|
||||
|
||||
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 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();
|
||||
|
||||
@ -95,15 +104,16 @@ TEST_F(DumpCustomGZTest, compressed_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 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();
|
||||
|
||||
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();
|
||||
|
||||
|
||||
@ -11,28 +11,32 @@
|
||||
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/systems/melt.h"
|
||||
#include "../testing/utils.h"
|
||||
#include "fmt/format.h"
|
||||
#include "utils.h"
|
||||
#include "gmock/gmock.h"
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
using ::testing::Eq;
|
||||
|
||||
char * ZSTD_BINARY = nullptr;
|
||||
char *ZSTD_BINARY = nullptr;
|
||||
|
||||
class DumpCustomZstdTest : public MeltTest {
|
||||
std::string dump_style = "custom";
|
||||
|
||||
public:
|
||||
void enable_triclinic() {
|
||||
void enable_triclinic()
|
||||
{
|
||||
if (!verbose) ::testing::internal::CaptureStdout();
|
||||
command("change_box all triclinic");
|
||||
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();
|
||||
command(fmt::format("dump id all {} 1 {} {}", dump_style, dump_file, fields));
|
||||
|
||||
@ -44,8 +48,10 @@ public:
|
||||
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 fields, 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 fields,
|
||||
std::string dump_modify_options, int ntimesteps)
|
||||
{
|
||||
if (!verbose) ::testing::internal::CaptureStdout();
|
||||
command(fmt::format("dump id0 all {} 1 {} {}", dump_style, text_file, fields));
|
||||
command(fmt::format("dump id1 all {} 1 {} {}", compression_style, compressed_file, fields));
|
||||
@ -59,10 +65,12 @@ public:
|
||||
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();
|
||||
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());
|
||||
if (!verbose) ::testing::internal::GetCapturedStdout();
|
||||
return converted_file;
|
||||
@ -71,13 +79,14 @@ public:
|
||||
|
||||
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 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();
|
||||
|
||||
@ -95,15 +104,16 @@ TEST_F(DumpCustomZstdTest, compressed_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 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();
|
||||
|
||||
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();
|
||||
|
||||
|
||||
@ -11,23 +11,26 @@
|
||||
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/systems/melt.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;
|
||||
|
||||
class DumpLocalGZTest : public MeltTest {
|
||||
std::string dump_style = "local";
|
||||
|
||||
public:
|
||||
void generate_text_and_compressed_dump(std::string text_file, std::string compressed_file, std::string compression_style,
|
||||
std::string fields, 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 fields,
|
||||
std::string dump_modify_options, int ntimesteps)
|
||||
{
|
||||
if (!verbose) ::testing::internal::CaptureStdout();
|
||||
command(fmt::format("dump id0 all {} 1 {} {}", dump_style, text_file, fields));
|
||||
command(fmt::format("dump id1 all {} 1 {} {}", compression_style, compressed_file, fields));
|
||||
@ -41,10 +44,12 @@ public:
|
||||
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();
|
||||
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());
|
||||
if (!verbose) ::testing::internal::GetCapturedStdout();
|
||||
return converted_file;
|
||||
@ -53,17 +58,17 @@ public:
|
||||
|
||||
TEST_F(DumpLocalGZTest, compressed_run0)
|
||||
{
|
||||
if(!GZIP_BINARY) GTEST_SKIP();
|
||||
if (!GZIP_BINARY) GTEST_SKIP();
|
||||
|
||||
if (!verbose) ::testing::internal::CaptureStdout();
|
||||
command("compute comp all pair/local dist eng");
|
||||
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 text_file = "dump_local_gz_text_run0.melt.local";
|
||||
auto compressed_file = "dump_local_gz_compressed_run0.melt.local.gz";
|
||||
auto fields = "index c_comp[1]";
|
||||
auto text_file = "dump_local_gz_text_run0.melt.local";
|
||||
auto compressed_file = "dump_local_gz_compressed_run0.melt.local.gz";
|
||||
auto fields = "index c_comp[1]";
|
||||
|
||||
generate_text_and_compressed_dump(text_files, compressed_files, "local/gz", fields, "", 0);
|
||||
|
||||
|
||||
@ -11,23 +11,26 @@
|
||||
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/systems/melt.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;
|
||||
|
||||
class DumpLocalGZTest : public MeltTest {
|
||||
std::string dump_style = "local";
|
||||
|
||||
public:
|
||||
void generate_text_and_compressed_dump(std::string text_file, std::string compressed_file, std::string compression_style,
|
||||
std::string fields, 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 fields,
|
||||
std::string dump_modify_options, int ntimesteps)
|
||||
{
|
||||
if (!verbose) ::testing::internal::CaptureStdout();
|
||||
command(fmt::format("dump id0 all {} 1 {} {}", dump_style, text_file, fields));
|
||||
command(fmt::format("dump id1 all {} 1 {} {}", compression_style, compressed_file, fields));
|
||||
@ -41,10 +44,12 @@ public:
|
||||
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();
|
||||
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());
|
||||
if (!verbose) ::testing::internal::GetCapturedStdout();
|
||||
return converted_file;
|
||||
@ -53,17 +58,17 @@ public:
|
||||
|
||||
TEST_F(DumpLocalGZTest, compressed_run0)
|
||||
{
|
||||
if(!ZSTD_BINARY) GTEST_SKIP();
|
||||
if (!ZSTD_BINARY) GTEST_SKIP();
|
||||
|
||||
if (!verbose) ::testing::internal::CaptureStdout();
|
||||
command("compute comp all pair/local dist eng");
|
||||
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 text_file = "dump_local_zstd_text_run0.melt.local";
|
||||
auto compressed_file = "dump_local_zstd_compressed_run0.melt.local.zst";
|
||||
auto fields = "index c_comp[1]";
|
||||
auto text_file = "dump_local_zstd_text_run0.melt.local";
|
||||
auto compressed_file = "dump_local_zstd_compressed_run0.melt.local.zst";
|
||||
auto fields = "index c_comp[1]";
|
||||
|
||||
generate_text_and_compressed_dump(text_files, compressed_files, "local/zstd", fields, "", 0);
|
||||
|
||||
|
||||
@ -11,23 +11,26 @@
|
||||
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/systems/melt.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;
|
||||
|
||||
class DumpXYZGZTest : public MeltTest {
|
||||
std::string dump_style = "xyz";
|
||||
|
||||
public:
|
||||
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();
|
||||
command(fmt::format("dump id0 all {} 1 {}", dump_style, text_file));
|
||||
command(fmt::format("dump id1 all {} 1 {}", compression_style, compressed_file));
|
||||
@ -41,10 +44,12 @@ public:
|
||||
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();
|
||||
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());
|
||||
if (!verbose) ::testing::internal::GetCapturedStdout();
|
||||
return converted_file;
|
||||
@ -53,12 +58,12 @@ public:
|
||||
|
||||
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 text_file = "dump_xyz_gz_text_run0.melt.xyz";
|
||||
auto compressed_file = "dump_xyz_gz_compressed_run0.melt.xyz.gz";
|
||||
auto text_file = "dump_xyz_gz_text_run0.melt.xyz";
|
||||
auto compressed_file = "dump_xyz_gz_compressed_run0.melt.xyz.gz";
|
||||
|
||||
generate_text_and_compressed_dump(text_files, compressed_files, "xyz/gz", "", 0);
|
||||
|
||||
|
||||
@ -11,23 +11,26 @@
|
||||
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/systems/melt.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;
|
||||
|
||||
class DumpXYZGZTest : public MeltTest {
|
||||
std::string dump_style = "xyz";
|
||||
|
||||
public:
|
||||
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();
|
||||
command(fmt::format("dump id0 all {} 1 {}", dump_style, text_file));
|
||||
command(fmt::format("dump id1 all {} 1 {}", compression_style, compressed_file));
|
||||
@ -41,10 +44,12 @@ public:
|
||||
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();
|
||||
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());
|
||||
if (!verbose) ::testing::internal::GetCapturedStdout();
|
||||
return converted_file;
|
||||
@ -53,12 +58,12 @@ public:
|
||||
|
||||
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 text_file = "dump_xyz_zstd_text_run0.melt.xyz";
|
||||
auto compressed_file = "dump_xyz_zstd_compressed_run0.melt.xyz.zst";
|
||||
auto text_file = "dump_xyz_zstd_text_run0.melt.xyz";
|
||||
auto compressed_file = "dump_xyz_zstd_compressed_run0.melt.xyz.zst";
|
||||
|
||||
generate_text_and_compressed_dump(text_files, compressed_files, "xyz/zstd", "", 0);
|
||||
|
||||
|
||||
@ -650,15 +650,14 @@ TEST_F(PairUnitConvertTest, table_real2metal)
|
||||
|
||||
double 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;
|
||||
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;
|
||||
for (int i = 0; i < 4; ++i)
|
||||
for (int j = 0; j < 3; ++j)
|
||||
EXPECT_NEAR(1.0/ev_convert * fold[i][j], f[i][j],
|
||||
fabs(f[i][j] * rel_error));
|
||||
EXPECT_NEAR(1.0 / ev_convert * fold[i][j], f[i][j], fabs(f[i][j] * rel_error));
|
||||
}
|
||||
|
||||
TEST_F(PairUnitConvertTest, tersoff)
|
||||
|
||||
@ -31,8 +31,8 @@
|
||||
|
||||
#include <cstring>
|
||||
#include <iostream>
|
||||
#include <vector>
|
||||
#include <mpi.h>
|
||||
#include <vector>
|
||||
|
||||
#if defined(OMPI_MAJOR_VERSION)
|
||||
const bool have_openmpi = true;
|
||||
|
||||
@ -1,65 +1,70 @@
|
||||
// unit tests for issuing command to a LAMMPS instance through the Fortran wrapper
|
||||
|
||||
#include "lammps.h"
|
||||
#include <cstdio> // for stdin, stdout
|
||||
#include <mpi.h>
|
||||
#include <cstdio> // for stdin, stdout
|
||||
#include <string>
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
// prototypes for fortran reverse wrapper functions
|
||||
extern "C" {
|
||||
void *f_lammps_with_args();
|
||||
void f_lammps_close();
|
||||
void f_lammps_file();
|
||||
void f_lammps_command();
|
||||
void f_lammps_commands_list();
|
||||
void f_lammps_commands_string();
|
||||
double f_lammps_get_natoms();
|
||||
void *f_lammps_with_args();
|
||||
void f_lammps_close();
|
||||
void f_lammps_file();
|
||||
void f_lammps_command();
|
||||
void f_lammps_commands_list();
|
||||
void f_lammps_commands_string();
|
||||
double f_lammps_get_natoms();
|
||||
}
|
||||
|
||||
class LAMMPS_commands : public ::testing::Test
|
||||
{
|
||||
class LAMMPS_commands : public ::testing::Test {
|
||||
protected:
|
||||
LAMMPS_NS::LAMMPS *lmp;
|
||||
LAMMPS_commands() {};
|
||||
~LAMMPS_commands() override {};
|
||||
LAMMPS_commands(){};
|
||||
~LAMMPS_commands() override{};
|
||||
|
||||
void SetUp() override {
|
||||
void SetUp() override
|
||||
{
|
||||
::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();
|
||||
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();
|
||||
f_lammps_close();
|
||||
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;
|
||||
}
|
||||
};
|
||||
|
||||
TEST_F(LAMMPS_commands, from_file) {
|
||||
EXPECT_EQ(f_lammps_get_natoms(),0);
|
||||
TEST_F(LAMMPS_commands, from_file)
|
||||
{
|
||||
EXPECT_EQ(f_lammps_get_natoms(), 0);
|
||||
f_lammps_file();
|
||||
EXPECT_EQ(f_lammps_get_natoms(),2);
|
||||
EXPECT_EQ(f_lammps_get_natoms(), 2);
|
||||
};
|
||||
|
||||
TEST_F(LAMMPS_commands, from_line) {
|
||||
EXPECT_EQ(f_lammps_get_natoms(),0);
|
||||
TEST_F(LAMMPS_commands, from_line)
|
||||
{
|
||||
EXPECT_EQ(f_lammps_get_natoms(), 0);
|
||||
f_lammps_command();
|
||||
EXPECT_EQ(f_lammps_get_natoms(),1);
|
||||
EXPECT_EQ(f_lammps_get_natoms(), 1);
|
||||
};
|
||||
|
||||
TEST_F(LAMMPS_commands, from_list) {
|
||||
EXPECT_EQ(f_lammps_get_natoms(),0);
|
||||
TEST_F(LAMMPS_commands, from_list)
|
||||
{
|
||||
EXPECT_EQ(f_lammps_get_natoms(), 0);
|
||||
f_lammps_commands_list();
|
||||
EXPECT_EQ(f_lammps_get_natoms(),2);
|
||||
EXPECT_EQ(f_lammps_get_natoms(), 2);
|
||||
};
|
||||
|
||||
TEST_F(LAMMPS_commands, from_string) {
|
||||
EXPECT_EQ(f_lammps_get_natoms(),0);
|
||||
TEST_F(LAMMPS_commands, from_string)
|
||||
{
|
||||
EXPECT_EQ(f_lammps_get_natoms(), 0);
|
||||
f_lammps_commands_string();
|
||||
EXPECT_EQ(f_lammps_get_natoms(),2);
|
||||
EXPECT_EQ(f_lammps_get_natoms(), 2);
|
||||
};
|
||||
|
||||
@ -1,33 +1,34 @@
|
||||
// unit tests for the LAMMPS base class
|
||||
|
||||
#include "lammps.h"
|
||||
#include <cstdio> // for stdin, stdout
|
||||
#include <mpi.h>
|
||||
#include <cstdio> // for stdin, stdout
|
||||
#include <string>
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
// prototypes for fortran reverse wrapper functions
|
||||
extern "C" {
|
||||
void *f_lammps_open_no_args();
|
||||
void *f_lammps_open_with_args();
|
||||
void *f_lammps_no_mpi_no_args();
|
||||
void *f_lammps_no_mpi_with_args();
|
||||
void f_lammps_close();
|
||||
int f_lammps_get_comm();
|
||||
void *f_lammps_open_no_args();
|
||||
void *f_lammps_open_with_args();
|
||||
void *f_lammps_no_mpi_no_args();
|
||||
void *f_lammps_no_mpi_with_args();
|
||||
void f_lammps_close();
|
||||
int f_lammps_get_comm();
|
||||
}
|
||||
|
||||
TEST(open_no_mpi, no_args) {
|
||||
TEST(open_no_mpi, no_args)
|
||||
{
|
||||
::testing::internal::CaptureStdout();
|
||||
int mpi_init=0;
|
||||
int mpi_init = 0;
|
||||
MPI_Initialized(&mpi_init);
|
||||
EXPECT_EQ(mpi_init,0);
|
||||
void *handle = f_lammps_no_mpi_no_args();
|
||||
EXPECT_EQ(mpi_init, 0);
|
||||
void *handle = f_lammps_no_mpi_no_args();
|
||||
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;
|
||||
MPI_Initialized(&mpi_init);
|
||||
EXPECT_NE(mpi_init,0);
|
||||
EXPECT_NE(mpi_init, 0);
|
||||
EXPECT_EQ(lmp->world, MPI_COMM_WORLD);
|
||||
EXPECT_EQ(lmp->infile, stdin);
|
||||
EXPECT_EQ(lmp->screen, stdout);
|
||||
@ -35,14 +36,15 @@ TEST(open_no_mpi, no_args) {
|
||||
::testing::internal::CaptureStdout();
|
||||
f_lammps_close();
|
||||
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();
|
||||
void *handle = f_lammps_no_mpi_with_args();
|
||||
void *handle = f_lammps_no_mpi_with_args();
|
||||
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;
|
||||
EXPECT_EQ(lmp->infile, stdin);
|
||||
EXPECT_EQ(lmp->screen, stdout);
|
||||
@ -53,17 +55,18 @@ TEST(open_no_mpi, with_args) {
|
||||
::testing::internal::CaptureStdout();
|
||||
f_lammps_close();
|
||||
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();
|
||||
void *handle = f_lammps_open_no_args();
|
||||
void *handle = f_lammps_open_no_args();
|
||||
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;
|
||||
|
||||
int f_comm = f_lammps_get_comm();
|
||||
int f_comm = f_lammps_get_comm();
|
||||
MPI_Comm mycomm = MPI_Comm_f2c(f_comm);
|
||||
EXPECT_EQ(lmp->world, mycomm);
|
||||
EXPECT_EQ(lmp->infile, stdin);
|
||||
@ -72,17 +75,18 @@ TEST(fortran_open, no_args) {
|
||||
::testing::internal::CaptureStdout();
|
||||
f_lammps_close();
|
||||
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();
|
||||
void *handle = f_lammps_open_with_args();
|
||||
void *handle = f_lammps_open_with_args();
|
||||
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;
|
||||
|
||||
int f_comm = f_lammps_get_comm();
|
||||
int f_comm = f_lammps_get_comm();
|
||||
MPI_Comm mycomm = MPI_Comm_f2c(f_comm);
|
||||
EXPECT_EQ(lmp->world, mycomm);
|
||||
EXPECT_EQ(lmp->infile, stdin);
|
||||
@ -93,5 +97,5 @@ TEST(fortran_open, with_args) {
|
||||
::testing::internal::CaptureStdout();
|
||||
f_lammps_close();
|
||||
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:");
|
||||
}
|
||||
|
||||
@ -32,13 +32,13 @@ bool verbose = false;
|
||||
using LAMMPS_NS::utils::split_words;
|
||||
|
||||
namespace LAMMPS_NS {
|
||||
using ::testing::StrEq;
|
||||
using ::testing::MatchesRegex;
|
||||
using ::testing::StrEq;
|
||||
|
||||
class PythonPackageTest : public ::testing::Test {
|
||||
protected:
|
||||
LAMMPS *lmp;
|
||||
Info *info;
|
||||
Info *info;
|
||||
|
||||
void SetUp() override
|
||||
{
|
||||
@ -74,7 +74,7 @@ protected:
|
||||
|
||||
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
|
||||
if (!verbose) ::testing::internal::CaptureStdout();
|
||||
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.*"));
|
||||
}
|
||||
|
||||
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();
|
||||
lmp->input->one("variable sq python square");
|
||||
lmp->input->one("variable val index 1.5");
|
||||
|
||||
@ -41,31 +41,26 @@ using ::testing::MatchesRegex;
|
||||
// whether to print verbose output (i.e. not capturing LAMMPS screen output).
|
||||
bool verbose = false;
|
||||
|
||||
|
||||
class LAMMPSTest : public ::testing::Test {
|
||||
public:
|
||||
void command(const std::string &line) {
|
||||
lmp->input->one(line.c_str());
|
||||
}
|
||||
void command(const std::string &line) { lmp->input->one(line.c_str()); }
|
||||
|
||||
protected:
|
||||
const char * testbinary = "LAMMPSTest";
|
||||
const char *testbinary = "LAMMPSTest";
|
||||
LAMMPS *lmp;
|
||||
|
||||
void SetUp() override
|
||||
{
|
||||
const char *args[] = { testbinary, "-log", "none", "-echo", "screen", "-nocite"};
|
||||
char **argv = (char **)args;
|
||||
int argc = sizeof(args) / sizeof(char *);
|
||||
const char *args[] = {testbinary, "-log", "none", "-echo", "screen", "-nocite"};
|
||||
char **argv = (char **)args;
|
||||
int argc = sizeof(args) / sizeof(char *);
|
||||
if (!verbose) ::testing::internal::CaptureStdout();
|
||||
lmp = new LAMMPS(argc, argv, MPI_COMM_WORLD);
|
||||
InitSystem();
|
||||
if (!verbose) ::testing::internal::GetCapturedStdout();
|
||||
}
|
||||
|
||||
|
||||
virtual void InitSystem() {
|
||||
}
|
||||
virtual void InitSystem() {}
|
||||
|
||||
void TearDown() override
|
||||
{
|
||||
@ -76,5 +71,4 @@ protected:
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
@ -17,7 +17,8 @@
|
||||
|
||||
class MeltTest : public LAMMPSTest {
|
||||
protected:
|
||||
virtual void InitSystem() override {
|
||||
virtual void InitSystem() override
|
||||
{
|
||||
command("units lj");
|
||||
command("atom_style atomic");
|
||||
command("atom_modify map yes");
|
||||
@ -34,7 +35,7 @@ protected:
|
||||
command("pair_coeff 1 1 1.0 1.0 2.5");
|
||||
|
||||
command("neighbor 0.3 bin");
|
||||
command("neigh_modify every 20 delay 0 check no");
|
||||
command("neigh_modify every 20 delay 0 check no");
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
@ -13,12 +13,12 @@
|
||||
#ifndef TEST_EXTENSIONS__H
|
||||
#define TEST_EXTENSIONS__H
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <iostream>
|
||||
#include <fstream>
|
||||
#include <sys/types.h>
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
#include <sys/stat.h>
|
||||
#include <sys/types.h>
|
||||
#include <vector>
|
||||
|
||||
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;
|
||||
|
||||
while (std::getline(afile, lineA)) {
|
||||
if(!std::getline(bfile, lineB)) return false;
|
||||
if(lineA != lineB) return false;
|
||||
if (!std::getline(bfile, lineB)) return false;
|
||||
if (lineA != lineB) return false;
|
||||
}
|
||||
|
||||
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::ifstream infile(filename);
|
||||
std::string line;
|
||||
@ -62,7 +63,8 @@ static std::vector<std::string> read_lines(const std::string &filename) {
|
||||
return lines;
|
||||
}
|
||||
|
||||
static bool file_exists(const std::string &filename) {
|
||||
static bool file_exists(const std::string &filename)
|
||||
{
|
||||
struct stat result;
|
||||
return stat(filename.c_str(), &result) == 0;
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -19,329 +19,333 @@
|
||||
|
||||
using namespace LAMMPS_NS;
|
||||
|
||||
TEST(MyPage, int) {
|
||||
TEST(MyPage, int)
|
||||
{
|
||||
MyPage<int> p;
|
||||
|
||||
// default init. maxchunk=1, pagesize=1024
|
||||
int rv = p.init();
|
||||
ASSERT_EQ(rv,0);
|
||||
ASSERT_EQ(rv, 0);
|
||||
|
||||
ASSERT_EQ(p.ndatum,0);
|
||||
ASSERT_EQ(p.nchunk,0);
|
||||
ASSERT_EQ(p.ndatum, 0);
|
||||
ASSERT_EQ(p.nchunk, 0);
|
||||
|
||||
int *iptr = p.vget();
|
||||
// second call to vget() should give same pointer without vgot()
|
||||
ASSERT_EQ(iptr,p.vget());
|
||||
ASSERT_EQ(iptr, p.vget());
|
||||
p.vgot(1);
|
||||
++iptr;
|
||||
ASSERT_EQ(0,p.status());
|
||||
ASSERT_EQ(p.ndatum,1);
|
||||
ASSERT_EQ(p.nchunk,1);
|
||||
ASSERT_EQ(iptr,p.vget());
|
||||
ASSERT_EQ(0, p.status());
|
||||
ASSERT_EQ(p.ndatum, 1);
|
||||
ASSERT_EQ(p.nchunk, 1);
|
||||
ASSERT_EQ(iptr, p.vget());
|
||||
// use too large chunk size
|
||||
p.vgot(2);
|
||||
ASSERT_EQ(1,p.status());
|
||||
ASSERT_EQ(1, p.status());
|
||||
|
||||
p.reset();
|
||||
ASSERT_EQ(p.ndatum,0);
|
||||
ASSERT_EQ(p.nchunk,0);
|
||||
ASSERT_EQ(p.ndatum, 0);
|
||||
ASSERT_EQ(p.nchunk, 0);
|
||||
|
||||
iptr = p.vget();
|
||||
p.vgot(1);
|
||||
++iptr;
|
||||
ASSERT_EQ(iptr,p.get());
|
||||
ASSERT_EQ(iptr, p.get());
|
||||
++iptr;
|
||||
ASSERT_EQ(iptr,p.get(1));
|
||||
ASSERT_EQ(p.ndatum,3);
|
||||
ASSERT_EQ(p.nchunk,3);
|
||||
ASSERT_EQ(iptr, p.get(1));
|
||||
ASSERT_EQ(p.ndatum, 3);
|
||||
ASSERT_EQ(p.nchunk, 3);
|
||||
|
||||
// restart with custom init. maxchunk=16, pagesize=256
|
||||
rv = p.init(16,64,2);
|
||||
ASSERT_EQ(rv,0);
|
||||
rv = p.init(16, 64, 2);
|
||||
ASSERT_EQ(rv, 0);
|
||||
|
||||
ASSERT_EQ(p.ndatum,0);
|
||||
ASSERT_EQ(p.nchunk,0);
|
||||
ASSERT_EQ(p.ndatum, 0);
|
||||
ASSERT_EQ(p.nchunk, 0);
|
||||
|
||||
iptr = p.vget();
|
||||
// second call to vget() should give same pointer without vgot()
|
||||
ASSERT_EQ(iptr,p.vget());
|
||||
ASSERT_EQ(iptr, p.vget());
|
||||
p.vgot(16);
|
||||
iptr += 16;
|
||||
ASSERT_EQ(0,p.status());
|
||||
ASSERT_EQ(p.ndatum,16);
|
||||
ASSERT_EQ(p.nchunk,1);
|
||||
ASSERT_EQ(0, p.status());
|
||||
ASSERT_EQ(p.ndatum, 16);
|
||||
ASSERT_EQ(p.nchunk, 1);
|
||||
|
||||
// use too large chunk size
|
||||
ASSERT_EQ(iptr,p.vget());
|
||||
ASSERT_EQ(iptr, p.vget());
|
||||
p.vgot(32);
|
||||
ASSERT_EQ(1,p.status());
|
||||
ASSERT_EQ(1, p.status());
|
||||
|
||||
p.reset();
|
||||
ASSERT_EQ(0,p.status());
|
||||
ASSERT_EQ(p.ndatum,0);
|
||||
ASSERT_EQ(p.nchunk,0);
|
||||
ASSERT_EQ(0, p.status());
|
||||
ASSERT_EQ(p.ndatum, 0);
|
||||
ASSERT_EQ(p.nchunk, 0);
|
||||
|
||||
iptr = p.vget();
|
||||
p.vgot(16);
|
||||
iptr = p.vget();
|
||||
p.vgot(4);
|
||||
iptr += 4;
|
||||
ASSERT_EQ(iptr,p.get());
|
||||
ASSERT_EQ(iptr, p.get());
|
||||
++iptr;
|
||||
ASSERT_EQ(iptr,p.get(16));
|
||||
ASSERT_DOUBLE_EQ(p.size(),(double)sizeof(int)*128.0);
|
||||
ASSERT_EQ(p.ndatum,37);
|
||||
ASSERT_EQ(p.nchunk,4);
|
||||
ASSERT_EQ(iptr, p.get(16));
|
||||
ASSERT_DOUBLE_EQ(p.size(), (double)sizeof(int) * 128.0);
|
||||
ASSERT_EQ(p.ndatum, 37);
|
||||
ASSERT_EQ(p.nchunk, 4);
|
||||
p.get(16);
|
||||
p.get(16);
|
||||
// allocation on the same page
|
||||
iptr = p.get(16);
|
||||
iptr += 16;
|
||||
ASSERT_EQ(iptr,p.get(16));
|
||||
ASSERT_EQ(iptr, p.get(16));
|
||||
// allocation on different pages
|
||||
p.get(16);
|
||||
iptr += 16;
|
||||
ASSERT_NE(iptr,p.get(16));
|
||||
ASSERT_DOUBLE_EQ(p.size(),(double)sizeof(int)*256.0);
|
||||
ASSERT_EQ(p.ndatum,133);
|
||||
ASSERT_EQ(p.nchunk,10);
|
||||
ASSERT_NE(iptr, p.get(16));
|
||||
ASSERT_DOUBLE_EQ(p.size(), (double)sizeof(int) * 256.0);
|
||||
ASSERT_EQ(p.ndatum, 133);
|
||||
ASSERT_EQ(p.nchunk, 10);
|
||||
}
|
||||
|
||||
TEST(MyPage, double) {
|
||||
TEST(MyPage, double)
|
||||
{
|
||||
MyPage<double> p;
|
||||
|
||||
// default init. maxchunk=1, pagesize=1024
|
||||
int rv = p.init();
|
||||
ASSERT_EQ(rv,0);
|
||||
ASSERT_EQ(rv, 0);
|
||||
|
||||
ASSERT_EQ(p.ndatum,0);
|
||||
ASSERT_EQ(p.nchunk,0);
|
||||
ASSERT_EQ(p.ndatum, 0);
|
||||
ASSERT_EQ(p.nchunk, 0);
|
||||
|
||||
double *iptr = p.vget();
|
||||
// second call to vget() should give same pointer without vgot()
|
||||
ASSERT_EQ(iptr,p.vget());
|
||||
ASSERT_EQ(iptr, p.vget());
|
||||
p.vgot(1);
|
||||
++iptr;
|
||||
ASSERT_EQ(0,p.status());
|
||||
ASSERT_EQ(p.ndatum,1);
|
||||
ASSERT_EQ(p.nchunk,1);
|
||||
ASSERT_EQ(iptr,p.vget());
|
||||
ASSERT_EQ(0, p.status());
|
||||
ASSERT_EQ(p.ndatum, 1);
|
||||
ASSERT_EQ(p.nchunk, 1);
|
||||
ASSERT_EQ(iptr, p.vget());
|
||||
// use too large chunk size
|
||||
p.vgot(2);
|
||||
ASSERT_EQ(1,p.status());
|
||||
ASSERT_EQ(1, p.status());
|
||||
|
||||
p.reset();
|
||||
ASSERT_EQ(p.ndatum,0);
|
||||
ASSERT_EQ(p.nchunk,0);
|
||||
ASSERT_EQ(p.ndatum, 0);
|
||||
ASSERT_EQ(p.nchunk, 0);
|
||||
|
||||
iptr = p.vget();
|
||||
p.vgot(1);
|
||||
++iptr;
|
||||
ASSERT_EQ(iptr,p.get());
|
||||
ASSERT_EQ(iptr, p.get());
|
||||
++iptr;
|
||||
ASSERT_EQ(iptr,p.get(1));
|
||||
ASSERT_EQ(p.ndatum,3);
|
||||
ASSERT_EQ(p.nchunk,3);
|
||||
ASSERT_EQ(iptr, p.get(1));
|
||||
ASSERT_EQ(p.ndatum, 3);
|
||||
ASSERT_EQ(p.nchunk, 3);
|
||||
|
||||
// restart with custom init. maxchunk=16, pagesize=256
|
||||
rv = p.init(16,64,2);
|
||||
ASSERT_EQ(rv,0);
|
||||
rv = p.init(16, 64, 2);
|
||||
ASSERT_EQ(rv, 0);
|
||||
|
||||
ASSERT_EQ(p.ndatum,0);
|
||||
ASSERT_EQ(p.nchunk,0);
|
||||
ASSERT_EQ(p.ndatum, 0);
|
||||
ASSERT_EQ(p.nchunk, 0);
|
||||
|
||||
iptr = p.vget();
|
||||
// second call to vget() should give same pointer without vgot()
|
||||
ASSERT_EQ(iptr,p.vget());
|
||||
ASSERT_EQ(iptr, p.vget());
|
||||
p.vgot(16);
|
||||
iptr += 16;
|
||||
ASSERT_EQ(0,p.status());
|
||||
ASSERT_EQ(p.ndatum,16);
|
||||
ASSERT_EQ(p.nchunk,1);
|
||||
ASSERT_EQ(0, p.status());
|
||||
ASSERT_EQ(p.ndatum, 16);
|
||||
ASSERT_EQ(p.nchunk, 1);
|
||||
|
||||
// use too large chunk size
|
||||
ASSERT_EQ(iptr,p.vget());
|
||||
ASSERT_EQ(iptr, p.vget());
|
||||
p.vgot(32);
|
||||
ASSERT_EQ(1,p.status());
|
||||
ASSERT_EQ(1, p.status());
|
||||
|
||||
p.reset();
|
||||
ASSERT_EQ(0,p.status());
|
||||
ASSERT_EQ(p.ndatum,0);
|
||||
ASSERT_EQ(p.nchunk,0);
|
||||
ASSERT_EQ(0, p.status());
|
||||
ASSERT_EQ(p.ndatum, 0);
|
||||
ASSERT_EQ(p.nchunk, 0);
|
||||
|
||||
iptr = p.vget();
|
||||
p.vgot(16);
|
||||
iptr = p.vget();
|
||||
p.vgot(4);
|
||||
iptr += 4;
|
||||
ASSERT_EQ(iptr,p.get());
|
||||
ASSERT_EQ(iptr, p.get());
|
||||
++iptr;
|
||||
ASSERT_EQ(iptr,p.get(16));
|
||||
ASSERT_DOUBLE_EQ(p.size(),(double)sizeof(double)*128.0);
|
||||
ASSERT_EQ(p.ndatum,37);
|
||||
ASSERT_EQ(p.nchunk,4);
|
||||
ASSERT_EQ(iptr, p.get(16));
|
||||
ASSERT_DOUBLE_EQ(p.size(), (double)sizeof(double) * 128.0);
|
||||
ASSERT_EQ(p.ndatum, 37);
|
||||
ASSERT_EQ(p.nchunk, 4);
|
||||
p.get(16);
|
||||
p.get(16);
|
||||
// allocation on the same page
|
||||
iptr = p.get(16);
|
||||
iptr += 16;
|
||||
ASSERT_EQ(iptr,p.get(16));
|
||||
ASSERT_EQ(iptr, p.get(16));
|
||||
// allocation on different pages
|
||||
p.get(16);
|
||||
iptr += 16;
|
||||
ASSERT_NE(iptr,p.get(16));
|
||||
ASSERT_DOUBLE_EQ(p.size(),(double)sizeof(double)*256.0);
|
||||
ASSERT_EQ(p.ndatum,133);
|
||||
ASSERT_EQ(p.nchunk,10);
|
||||
ASSERT_NE(iptr, p.get(16));
|
||||
ASSERT_DOUBLE_EQ(p.size(), (double)sizeof(double) * 256.0);
|
||||
ASSERT_EQ(p.ndatum, 133);
|
||||
ASSERT_EQ(p.nchunk, 10);
|
||||
}
|
||||
|
||||
TEST(MyPage, bigint) {
|
||||
TEST(MyPage, bigint)
|
||||
{
|
||||
MyPage<bigint> p;
|
||||
|
||||
// default init. maxchunk=1, pagesize=1024
|
||||
int rv = p.init();
|
||||
ASSERT_EQ(rv,0);
|
||||
ASSERT_EQ(rv, 0);
|
||||
|
||||
ASSERT_EQ(p.ndatum,0);
|
||||
ASSERT_EQ(p.nchunk,0);
|
||||
ASSERT_EQ(p.ndatum, 0);
|
||||
ASSERT_EQ(p.nchunk, 0);
|
||||
|
||||
bigint *iptr = p.vget();
|
||||
// second call to vget() should give same pointer without vgot()
|
||||
ASSERT_EQ(iptr,p.vget());
|
||||
ASSERT_EQ(iptr, p.vget());
|
||||
p.vgot(1);
|
||||
++iptr;
|
||||
ASSERT_EQ(0,p.status());
|
||||
ASSERT_EQ(p.ndatum,1);
|
||||
ASSERT_EQ(p.nchunk,1);
|
||||
ASSERT_EQ(iptr,p.vget());
|
||||
ASSERT_EQ(0, p.status());
|
||||
ASSERT_EQ(p.ndatum, 1);
|
||||
ASSERT_EQ(p.nchunk, 1);
|
||||
ASSERT_EQ(iptr, p.vget());
|
||||
// use too large chunk size
|
||||
p.vgot(2);
|
||||
ASSERT_EQ(1,p.status());
|
||||
ASSERT_EQ(1, p.status());
|
||||
|
||||
p.reset();
|
||||
ASSERT_EQ(p.ndatum,0);
|
||||
ASSERT_EQ(p.nchunk,0);
|
||||
ASSERT_EQ(p.ndatum, 0);
|
||||
ASSERT_EQ(p.nchunk, 0);
|
||||
|
||||
iptr = p.vget();
|
||||
p.vgot(1);
|
||||
++iptr;
|
||||
ASSERT_EQ(iptr,p.get());
|
||||
ASSERT_EQ(iptr, p.get());
|
||||
++iptr;
|
||||
ASSERT_EQ(iptr,p.get(1));
|
||||
ASSERT_EQ(p.ndatum,3);
|
||||
ASSERT_EQ(p.nchunk,3);
|
||||
ASSERT_EQ(iptr, p.get(1));
|
||||
ASSERT_EQ(p.ndatum, 3);
|
||||
ASSERT_EQ(p.nchunk, 3);
|
||||
|
||||
// restart with custom init. maxchunk=16, pagesize=256
|
||||
rv = p.init(16,64,2);
|
||||
ASSERT_EQ(rv,0);
|
||||
rv = p.init(16, 64, 2);
|
||||
ASSERT_EQ(rv, 0);
|
||||
|
||||
ASSERT_EQ(p.ndatum,0);
|
||||
ASSERT_EQ(p.nchunk,0);
|
||||
ASSERT_EQ(p.ndatum, 0);
|
||||
ASSERT_EQ(p.nchunk, 0);
|
||||
|
||||
iptr = p.vget();
|
||||
// second call to vget() should give same pointer without vgot()
|
||||
ASSERT_EQ(iptr,p.vget());
|
||||
ASSERT_EQ(iptr, p.vget());
|
||||
p.vgot(16);
|
||||
iptr += 16;
|
||||
ASSERT_EQ(0,p.status());
|
||||
ASSERT_EQ(p.ndatum,16);
|
||||
ASSERT_EQ(p.nchunk,1);
|
||||
ASSERT_EQ(0, p.status());
|
||||
ASSERT_EQ(p.ndatum, 16);
|
||||
ASSERT_EQ(p.nchunk, 1);
|
||||
|
||||
// use too large chunk size
|
||||
ASSERT_EQ(iptr,p.vget());
|
||||
ASSERT_EQ(iptr, p.vget());
|
||||
p.vgot(32);
|
||||
ASSERT_EQ(1,p.status());
|
||||
ASSERT_EQ(1, p.status());
|
||||
|
||||
p.reset();
|
||||
ASSERT_EQ(0,p.status());
|
||||
ASSERT_EQ(p.ndatum,0);
|
||||
ASSERT_EQ(p.nchunk,0);
|
||||
ASSERT_EQ(0, p.status());
|
||||
ASSERT_EQ(p.ndatum, 0);
|
||||
ASSERT_EQ(p.nchunk, 0);
|
||||
|
||||
iptr = p.vget();
|
||||
p.vgot(16);
|
||||
iptr = p.vget();
|
||||
p.vgot(4);
|
||||
iptr += 4;
|
||||
ASSERT_EQ(iptr,p.get());
|
||||
ASSERT_EQ(iptr, p.get());
|
||||
++iptr;
|
||||
ASSERT_EQ(iptr,p.get(16));
|
||||
ASSERT_DOUBLE_EQ(p.size(),(double)sizeof(bigint)*128.0);
|
||||
ASSERT_EQ(p.ndatum,37);
|
||||
ASSERT_EQ(p.nchunk,4);
|
||||
ASSERT_EQ(iptr, p.get(16));
|
||||
ASSERT_DOUBLE_EQ(p.size(), (double)sizeof(bigint) * 128.0);
|
||||
ASSERT_EQ(p.ndatum, 37);
|
||||
ASSERT_EQ(p.nchunk, 4);
|
||||
p.get(16);
|
||||
p.get(16);
|
||||
// allocation on the same page
|
||||
iptr = p.get(16);
|
||||
iptr += 16;
|
||||
ASSERT_EQ(iptr,p.get(16));
|
||||
ASSERT_EQ(iptr, p.get(16));
|
||||
// allocation on different pages
|
||||
p.get(16);
|
||||
iptr += 16;
|
||||
ASSERT_NE(iptr,p.get(16));
|
||||
ASSERT_DOUBLE_EQ(p.size(),(double)sizeof(bigint)*256.0);
|
||||
ASSERT_EQ(p.ndatum,133);
|
||||
ASSERT_EQ(p.nchunk,10);
|
||||
ASSERT_NE(iptr, p.get(16));
|
||||
ASSERT_DOUBLE_EQ(p.size(), (double)sizeof(bigint) * 256.0);
|
||||
ASSERT_EQ(p.ndatum, 133);
|
||||
ASSERT_EQ(p.nchunk, 10);
|
||||
}
|
||||
|
||||
TEST(MyPoolChunk, int) {
|
||||
TEST(MyPoolChunk, int)
|
||||
{
|
||||
// defaults to minchunk=1, maxchunk=1, nbin=1, chunksperpage=1024, pagedelta=1
|
||||
MyPoolChunk<int> p;
|
||||
|
||||
ASSERT_EQ(p.ndatum,0);
|
||||
ASSERT_EQ(p.nchunk,0);
|
||||
ASSERT_EQ(p.size(),0.0);
|
||||
ASSERT_EQ(p.ndatum, 0);
|
||||
ASSERT_EQ(p.nchunk, 0);
|
||||
ASSERT_EQ(p.size(), 0.0);
|
||||
|
||||
int idx=~0x0000;
|
||||
int idx = ~0x0000;
|
||||
int *iptr = p.get(idx);
|
||||
ASSERT_NE(iptr,nullptr);
|
||||
ASSERT_EQ(idx,0);
|
||||
ASSERT_NE(iptr, nullptr);
|
||||
ASSERT_EQ(idx, 0);
|
||||
|
||||
iptr = p.get(1,idx);
|
||||
ASSERT_NE(iptr,nullptr);
|
||||
ASSERT_EQ(idx,1);
|
||||
iptr = p.get(1, idx);
|
||||
ASSERT_NE(iptr, nullptr);
|
||||
ASSERT_EQ(idx, 1);
|
||||
// we have only one page allocated
|
||||
ASSERT_EQ(p.size(),1024*sizeof(int)+1024*sizeof(int)+sizeof(void *)+sizeof(int));
|
||||
ASSERT_EQ(p.ndatum,2);
|
||||
ASSERT_EQ(p.nchunk,2);
|
||||
ASSERT_EQ(p.size(), 1024 * sizeof(int) + 1024 * sizeof(int) + sizeof(void *) + sizeof(int));
|
||||
ASSERT_EQ(p.ndatum, 2);
|
||||
ASSERT_EQ(p.nchunk, 2);
|
||||
|
||||
p.put(0);
|
||||
ASSERT_EQ(p.ndatum,1);
|
||||
ASSERT_EQ(p.nchunk,1);
|
||||
ASSERT_EQ(p.ndatum, 1);
|
||||
ASSERT_EQ(p.nchunk, 1);
|
||||
|
||||
iptr = p.get(2,idx);
|
||||
ASSERT_EQ(iptr,nullptr);
|
||||
ASSERT_EQ(p.status(),3);
|
||||
ASSERT_EQ(p.ndatum,1);
|
||||
ASSERT_EQ(p.nchunk,1);
|
||||
iptr = p.get(2, idx);
|
||||
ASSERT_EQ(iptr, nullptr);
|
||||
ASSERT_EQ(p.status(), 3);
|
||||
ASSERT_EQ(p.ndatum, 1);
|
||||
ASSERT_EQ(p.nchunk, 1);
|
||||
}
|
||||
|
||||
TEST(MyPoolChunk, double) {
|
||||
TEST(MyPoolChunk, double)
|
||||
{
|
||||
// defaults to minchunk=1, maxchunk=1, nbin=1, chunksperpage=1024, pagedelta=1
|
||||
MyPoolChunk<double> p;
|
||||
|
||||
ASSERT_EQ(p.ndatum,0);
|
||||
ASSERT_EQ(p.nchunk,0);
|
||||
ASSERT_EQ(p.size(),0.0);
|
||||
ASSERT_EQ(p.ndatum, 0);
|
||||
ASSERT_EQ(p.nchunk, 0);
|
||||
ASSERT_EQ(p.size(), 0.0);
|
||||
|
||||
int idx=~0x0000;
|
||||
int idx = ~0x0000;
|
||||
double *dptr = p.get(idx);
|
||||
ASSERT_NE(dptr,nullptr);
|
||||
ASSERT_EQ(idx,0);
|
||||
ASSERT_NE(dptr, nullptr);
|
||||
ASSERT_EQ(idx, 0);
|
||||
|
||||
dptr = p.get(1,idx);
|
||||
ASSERT_NE(dptr,nullptr);
|
||||
ASSERT_EQ(idx,1);
|
||||
dptr = p.get(1, idx);
|
||||
ASSERT_NE(dptr, nullptr);
|
||||
ASSERT_EQ(idx, 1);
|
||||
// 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);
|
||||
ASSERT_EQ(p.ndatum,1);
|
||||
ASSERT_EQ(p.nchunk,1);
|
||||
ASSERT_EQ(p.ndatum, 1);
|
||||
ASSERT_EQ(p.nchunk, 1);
|
||||
|
||||
dptr = p.get(2,idx);
|
||||
ASSERT_EQ(dptr,nullptr);
|
||||
ASSERT_EQ(p.status(),3);
|
||||
ASSERT_EQ(p.ndatum,1);
|
||||
ASSERT_EQ(p.nchunk,1);
|
||||
dptr = p.get(2, idx);
|
||||
ASSERT_EQ(dptr, nullptr);
|
||||
ASSERT_EQ(p.status(), 3);
|
||||
ASSERT_EQ(p.ndatum, 1);
|
||||
ASSERT_EQ(p.nchunk, 1);
|
||||
}
|
||||
|
||||
|
||||
@ -158,13 +158,15 @@ TEST(ValueTokenizer, valid_double_with_exponential)
|
||||
ASSERT_DOUBLE_EQ(values.next_double(), 3.14e22);
|
||||
}
|
||||
|
||||
TEST(ValueTokenizer, contains) {
|
||||
TEST(ValueTokenizer, contains)
|
||||
{
|
||||
ValueTokenizer values("test word");
|
||||
ASSERT_TRUE(values.contains("test"));
|
||||
ASSERT_TRUE(values.contains("word"));
|
||||
}
|
||||
|
||||
TEST(ValueTokenizer, not_contains) {
|
||||
TEST(ValueTokenizer, not_contains)
|
||||
{
|
||||
ValueTokenizer values("test word");
|
||||
ASSERT_FALSE(values.contains("test2"));
|
||||
}
|
||||
|
||||
@ -27,7 +27,7 @@ using ::testing::Eq;
|
||||
using ::testing::StrEq;
|
||||
|
||||
#if !defined(FLERR)
|
||||
#define FLERR __FILE__,__LINE__
|
||||
#define FLERR __FILE__, __LINE__
|
||||
#endif
|
||||
|
||||
TEST(Utils, trim)
|
||||
@ -373,11 +373,11 @@ TEST(Utils, bounds_case1)
|
||||
|
||||
nlo = nhi = -1;
|
||||
utils::bounds(FLERR, "9", 0, 10, nlo, nhi, nullptr);
|
||||
ASSERT_EQ(nlo,9);
|
||||
ASSERT_EQ(nhi,9);
|
||||
ASSERT_EQ(nlo, 9);
|
||||
ASSERT_EQ(nhi, 9);
|
||||
utils::bounds(FLERR, "1", 1, 10, nlo, nhi, nullptr);
|
||||
ASSERT_EQ(nlo,1);
|
||||
ASSERT_EQ(nhi,1);
|
||||
ASSERT_EQ(nlo, 1);
|
||||
ASSERT_EQ(nhi, 1);
|
||||
}
|
||||
|
||||
TEST(Utils, bounds_case2)
|
||||
@ -386,11 +386,11 @@ TEST(Utils, bounds_case2)
|
||||
|
||||
nlo = nhi = -1;
|
||||
utils::bounds(FLERR, "*", 0, 10, nlo, nhi, nullptr);
|
||||
ASSERT_EQ(nlo,0);
|
||||
ASSERT_EQ(nhi,10);
|
||||
ASSERT_EQ(nlo, 0);
|
||||
ASSERT_EQ(nhi, 10);
|
||||
utils::bounds(FLERR, "*", -10, 5, nlo, nhi, nullptr);
|
||||
ASSERT_EQ(nlo,-10);
|
||||
ASSERT_EQ(nhi,5);
|
||||
ASSERT_EQ(nlo, -10);
|
||||
ASSERT_EQ(nhi, 5);
|
||||
}
|
||||
|
||||
TEST(Utils, bounds_case3)
|
||||
@ -399,11 +399,11 @@ TEST(Utils, bounds_case3)
|
||||
|
||||
nlo = nhi = -1;
|
||||
utils::bounds(FLERR, "2*", 0, 10, nlo, nhi, nullptr);
|
||||
ASSERT_EQ(nlo,2);
|
||||
ASSERT_EQ(nhi,10);
|
||||
ASSERT_EQ(nlo, 2);
|
||||
ASSERT_EQ(nhi, 10);
|
||||
utils::bounds(FLERR, "3*", -10, 5, nlo, nhi, nullptr);
|
||||
ASSERT_EQ(nlo,3);
|
||||
ASSERT_EQ(nhi,5);
|
||||
ASSERT_EQ(nlo, 3);
|
||||
ASSERT_EQ(nhi, 5);
|
||||
}
|
||||
|
||||
TEST(Utils, bounds_case4)
|
||||
@ -412,11 +412,11 @@ TEST(Utils, bounds_case4)
|
||||
|
||||
nlo = nhi = -1;
|
||||
utils::bounds(FLERR, "*2", 0, 10, nlo, nhi, nullptr);
|
||||
ASSERT_EQ(nlo,0);
|
||||
ASSERT_EQ(nhi,2);
|
||||
ASSERT_EQ(nlo, 0);
|
||||
ASSERT_EQ(nhi, 2);
|
||||
utils::bounds(FLERR, "*3", -10, 5, nlo, nhi, nullptr);
|
||||
ASSERT_EQ(nlo,-10);
|
||||
ASSERT_EQ(nhi,3);
|
||||
ASSERT_EQ(nlo, -10);
|
||||
ASSERT_EQ(nhi, 3);
|
||||
}
|
||||
|
||||
TEST(Utils, bounds_case5)
|
||||
@ -425,11 +425,11 @@ TEST(Utils, bounds_case5)
|
||||
|
||||
nlo = nhi = -1;
|
||||
utils::bounds(FLERR, "2*5", 0, 10, nlo, nhi, nullptr);
|
||||
ASSERT_EQ(nlo,2);
|
||||
ASSERT_EQ(nhi,5);
|
||||
ASSERT_EQ(nlo, 2);
|
||||
ASSERT_EQ(nhi, 5);
|
||||
utils::bounds(FLERR, "-2*3", -10, 5, nlo, nhi, nullptr);
|
||||
ASSERT_EQ(nlo,-2);
|
||||
ASSERT_EQ(nhi,3);
|
||||
ASSERT_EQ(nlo, -2);
|
||||
ASSERT_EQ(nhi, 3);
|
||||
}
|
||||
|
||||
TEST(Utils, boundsbig_case1)
|
||||
@ -438,11 +438,11 @@ TEST(Utils, boundsbig_case1)
|
||||
|
||||
nlo = nhi = -1;
|
||||
utils::bounds(FLERR, "9", 0, 10, nlo, nhi, nullptr);
|
||||
ASSERT_EQ(nlo,9);
|
||||
ASSERT_EQ(nhi,9);
|
||||
ASSERT_EQ(nlo, 9);
|
||||
ASSERT_EQ(nhi, 9);
|
||||
utils::bounds(FLERR, "1", 1, 10, nlo, nhi, nullptr);
|
||||
ASSERT_EQ(nlo,1);
|
||||
ASSERT_EQ(nhi,1);
|
||||
ASSERT_EQ(nlo, 1);
|
||||
ASSERT_EQ(nhi, 1);
|
||||
}
|
||||
|
||||
TEST(Utils, boundsbig_case2)
|
||||
@ -451,11 +451,11 @@ TEST(Utils, boundsbig_case2)
|
||||
|
||||
nlo = nhi = -1;
|
||||
utils::bounds(FLERR, "*", 0, 10, nlo, nhi, nullptr);
|
||||
ASSERT_EQ(nlo,0);
|
||||
ASSERT_EQ(nhi,10);
|
||||
ASSERT_EQ(nlo, 0);
|
||||
ASSERT_EQ(nhi, 10);
|
||||
utils::bounds(FLERR, "*", -10, 5, nlo, nhi, nullptr);
|
||||
ASSERT_EQ(nlo,-10);
|
||||
ASSERT_EQ(nhi,5);
|
||||
ASSERT_EQ(nlo, -10);
|
||||
ASSERT_EQ(nhi, 5);
|
||||
}
|
||||
|
||||
TEST(Utils, boundsbig_case3)
|
||||
@ -464,11 +464,11 @@ TEST(Utils, boundsbig_case3)
|
||||
|
||||
nlo = nhi = -1;
|
||||
utils::bounds(FLERR, "2*", 0, 10, nlo, nhi, nullptr);
|
||||
ASSERT_EQ(nlo,2);
|
||||
ASSERT_EQ(nhi,10);
|
||||
ASSERT_EQ(nlo, 2);
|
||||
ASSERT_EQ(nhi, 10);
|
||||
utils::bounds(FLERR, "3*", -10, 5, nlo, nhi, nullptr);
|
||||
ASSERT_EQ(nlo,3);
|
||||
ASSERT_EQ(nhi,5);
|
||||
ASSERT_EQ(nlo, 3);
|
||||
ASSERT_EQ(nhi, 5);
|
||||
}
|
||||
|
||||
TEST(Utils, boundsbig_case4)
|
||||
@ -477,11 +477,11 @@ TEST(Utils, boundsbig_case4)
|
||||
|
||||
nlo = nhi = -1;
|
||||
utils::bounds(FLERR, "*2", 0, 10, nlo, nhi, nullptr);
|
||||
ASSERT_EQ(nlo,0);
|
||||
ASSERT_EQ(nhi,2);
|
||||
ASSERT_EQ(nlo, 0);
|
||||
ASSERT_EQ(nhi, 2);
|
||||
utils::bounds(FLERR, "*3", -10, 5, nlo, nhi, nullptr);
|
||||
ASSERT_EQ(nlo,-10);
|
||||
ASSERT_EQ(nhi,3);
|
||||
ASSERT_EQ(nlo, -10);
|
||||
ASSERT_EQ(nhi, 3);
|
||||
}
|
||||
|
||||
TEST(Utils, boundsbig_case5)
|
||||
@ -490,11 +490,11 @@ TEST(Utils, boundsbig_case5)
|
||||
|
||||
nlo = nhi = -1;
|
||||
utils::bounds(FLERR, "2*5", 0, 10, nlo, nhi, nullptr);
|
||||
ASSERT_EQ(nlo,2);
|
||||
ASSERT_EQ(nhi,5);
|
||||
ASSERT_EQ(nlo, 2);
|
||||
ASSERT_EQ(nhi, 5);
|
||||
utils::bounds(FLERR, "-2*3", -10, 5, nlo, nhi, nullptr);
|
||||
ASSERT_EQ(nlo,-2);
|
||||
ASSERT_EQ(nhi,3);
|
||||
ASSERT_EQ(nlo, -2);
|
||||
ASSERT_EQ(nhi, 3);
|
||||
}
|
||||
|
||||
TEST(Utils, guesspath)
|
||||
@ -628,19 +628,18 @@ TEST(Utils, timespec2seconds_hhmmss)
|
||||
ASSERT_DOUBLE_EQ(utils::timespec2seconds("2:10:45"), 7845.0);
|
||||
}
|
||||
|
||||
|
||||
TEST(Utils, date2num)
|
||||
{
|
||||
ASSERT_EQ(utils::date2num("1Jan05"),20050101);
|
||||
ASSERT_EQ(utils::date2num("10Feb2005"),20050210);
|
||||
ASSERT_EQ(utils::date2num("02Mar10"),20100302);
|
||||
ASSERT_EQ(utils::date2num(" 5Apr1900"),19000405);
|
||||
ASSERT_EQ(utils::date2num("10May22 "),20220510);
|
||||
ASSERT_EQ(utils::date2num("1 Jun 05"),20050601);
|
||||
ASSERT_EQ(utils::date2num("10 Jul 2005"),20050710);
|
||||
ASSERT_EQ(utils::date2num("02 Aug 10"),20100802);
|
||||
ASSERT_EQ(utils::date2num(" 5 September 99"),20990905);
|
||||
ASSERT_EQ(utils::date2num("10October22 "),20221010);
|
||||
ASSERT_EQ(utils::date2num("30November 02"),20021130);
|
||||
ASSERT_EQ(utils::date2num("31December100"),1001231);
|
||||
ASSERT_EQ(utils::date2num("1Jan05"), 20050101);
|
||||
ASSERT_EQ(utils::date2num("10Feb2005"), 20050210);
|
||||
ASSERT_EQ(utils::date2num("02Mar10"), 20100302);
|
||||
ASSERT_EQ(utils::date2num(" 5Apr1900"), 19000405);
|
||||
ASSERT_EQ(utils::date2num("10May22 "), 20220510);
|
||||
ASSERT_EQ(utils::date2num("1 Jun 05"), 20050601);
|
||||
ASSERT_EQ(utils::date2num("10 Jul 2005"), 20050710);
|
||||
ASSERT_EQ(utils::date2num("02 Aug 10"), 20100802);
|
||||
ASSERT_EQ(utils::date2num(" 5 September 99"), 20990905);
|
||||
ASSERT_EQ(utils::date2num("10October22 "), 20221010);
|
||||
ASSERT_EQ(utils::date2num("30November 02"), 20021130);
|
||||
ASSERT_EQ(utils::date2num("31December100"), 1001231);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user