From 569a000e6bfb2fb9a188ed18241573d79fdc7bb4 Mon Sep 17 00:00:00 2001 From: Axel Kohlmeyer Date: Wed, 18 Nov 2020 18:27:20 -0500 Subject: [PATCH] reformat unittest sources with clang-format --- unittest/commands/test_reset_ids.cpp | 338 ++--- unittest/commands/test_simple_commands.cpp | 6 +- unittest/cplusplus/test_input_class.cpp | 178 ++- unittest/cplusplus/test_lammps_class.cpp | 642 +++++---- unittest/force-styles/test_fix_timestep.cpp | 6 +- unittest/force-styles/test_main.cpp | 2 +- unittest/formats/test_atom_styles.cpp | 525 ++++---- unittest/formats/test_dump_atom.cpp | 63 +- unittest/formats/test_dump_atom_gz.cpp | 69 +- unittest/formats/test_dump_atom_zstd.cpp | 69 +- unittest/formats/test_dump_cfg.cpp | 32 +- unittest/formats/test_dump_cfg_gz.cpp | 44 +- unittest/formats/test_dump_cfg_zstd.cpp | 44 +- unittest/formats/test_dump_custom.cpp | 57 +- unittest/formats/test_dump_custom_gz.cpp | 48 +- unittest/formats/test_dump_custom_zstd.cpp | 48 +- unittest/formats/test_dump_local_gz.cpp | 33 +- unittest/formats/test_dump_local_zstd.cpp | 33 +- unittest/formats/test_dump_xyz_gz.cpp | 31 +- unittest/formats/test_dump_xyz_zstd.cpp | 31 +- unittest/formats/test_pair_unit_convert.cpp | 7 +- .../formats/test_potential_file_reader.cpp | 2 +- unittest/fortran/wrap_commands.cpp | 63 +- unittest/fortran/wrap_create.cpp | 60 +- unittest/python/test_python_package.cpp | 10 +- unittest/testing/core.h | 18 +- unittest/testing/systems/melt.h | 5 +- unittest/testing/utils.h | 18 +- unittest/utils/test_math_eigen_impl.cpp | 1182 ++++++++--------- unittest/utils/test_mempool.cpp | 316 ++--- unittest/utils/test_tokenizer.cpp | 6 +- unittest/utils/test_utils.cpp | 107 +- 32 files changed, 2022 insertions(+), 2071 deletions(-) diff --git a/unittest/commands/test_reset_ids.cpp b/unittest/commands/test_reset_ids.cpp index 12ed50a2d5..71a68a0a00 100644 --- a/unittest/commands/test_reset_ids.cpp +++ b/unittest/commands/test_reset_ids.cpp @@ -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) diff --git a/unittest/commands/test_simple_commands.cpp b/unittest/commands/test_simple_commands.cpp index 0226524429..7abe5cc957 100644 --- a/unittest/commands/test_simple_commands.cpp +++ b/unittest/commands/test_simple_commands.cpp @@ -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")); diff --git a/unittest/cplusplus/test_input_class.cpp b/unittest/cplusplus/test_input_class.cpp index 1c7796b46d..db11a91d88 100644 --- a/unittest/cplusplus/test_input_class.cpp +++ b/unittest/cplusplus/test_input_class.cpp @@ -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 #include #include -#include #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 diff --git a/unittest/cplusplus/test_lammps_class.cpp b/unittest/cplusplus/test_lammps_class.cpp index d81c1271ed..c20cdf336a 100644 --- a/unittest/cplusplus/test_lammps_class.cpp +++ b/unittest/cplusplus/test_lammps_class.cpp @@ -1,8 +1,8 @@ // unit tests for the LAMMPS base class #include "lammps.h" +#include // for stdin, stdout #include -#include // for stdin, stdout #include #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 diff --git a/unittest/force-styles/test_fix_timestep.cpp b/unittest/force-styles/test_fix_timestep.cpp index 121d709fc2..e4b0fa6e02 100644 --- a/unittest/force-styles/test_fix_timestep.cpp +++ b/unittest/force-styles/test_fix_timestep.cpp @@ -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); diff --git a/unittest/force-styles/test_main.cpp b/unittest/force-styles/test_main.cpp index 596416ec61..69a2b96822 100644 --- a/unittest/force-styles/test_main.cpp +++ b/unittest/force-styles/test_main.cpp @@ -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" diff --git a/unittest/formats/test_atom_styles.cpp b/unittest/formats/test_atom_styles.cpp index 3ceff53b78..cb3f7d79a4 100644 --- a/unittest/formats/test_atom_styles.cpp +++ b/unittest/formats/test_atom_styles.cpp @@ -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); diff --git a/unittest/formats/test_dump_atom.cpp b/unittest/formats/test_dump_atom.cpp index e99a72fb44..2472aabf2d 100644 --- a/unittest/formats/test_dump_atom.cpp +++ b/unittest/formats/test_dump_atom.cpp @@ -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 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"; diff --git a/unittest/formats/test_dump_atom_gz.cpp b/unittest/formats/test_dump_atom_gz.cpp index 64e3aed088..c8f2eb500c 100644 --- a/unittest/formats/test_dump_atom_gz.cpp +++ b/unittest/formats/test_dump_atom_gz.cpp @@ -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 -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(); diff --git a/unittest/formats/test_dump_atom_zstd.cpp b/unittest/formats/test_dump_atom_zstd.cpp index 8bb979c9b2..41c2fd3c79 100644 --- a/unittest/formats/test_dump_atom_zstd.cpp +++ b/unittest/formats/test_dump_atom_zstd.cpp @@ -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 -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(); diff --git a/unittest/formats/test_dump_cfg.cpp b/unittest/formats/test_dump_cfg.cpp index 0e45961bc5..a7f331a0d0 100644 --- a/unittest/formats/test_dump_cfg.cpp +++ b/unittest/formats/test_dump_cfg.cpp @@ -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); diff --git a/unittest/formats/test_dump_cfg_gz.cpp b/unittest/formats/test_dump_cfg_gz.cpp index bdc73c7811..ced307dc0a 100644 --- a/unittest/formats/test_dump_cfg_gz.cpp +++ b/unittest/formats/test_dump_cfg_gz.cpp @@ -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); diff --git a/unittest/formats/test_dump_cfg_zstd.cpp b/unittest/formats/test_dump_cfg_zstd.cpp index 02ff11c27a..c13a3d5eaf 100644 --- a/unittest/formats/test_dump_cfg_zstd.cpp +++ b/unittest/formats/test_dump_cfg_zstd.cpp @@ -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); diff --git a/unittest/formats/test_dump_custom.cpp b/unittest/formats/test_dump_custom.cpp index 61594070e3..dee27d9f0d 100644 --- a/unittest/formats/test_dump_custom.cpp +++ b/unittest/formats/test_dump_custom.cpp @@ -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); diff --git a/unittest/formats/test_dump_custom_gz.cpp b/unittest/formats/test_dump_custom_gz.cpp index de9ffc2232..67c9b535aa 100644 --- a/unittest/formats/test_dump_custom_gz.cpp +++ b/unittest/formats/test_dump_custom_gz.cpp @@ -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(); diff --git a/unittest/formats/test_dump_custom_zstd.cpp b/unittest/formats/test_dump_custom_zstd.cpp index fc3ef5e9a7..40328d5592 100644 --- a/unittest/formats/test_dump_custom_zstd.cpp +++ b/unittest/formats/test_dump_custom_zstd.cpp @@ -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(); diff --git a/unittest/formats/test_dump_local_gz.cpp b/unittest/formats/test_dump_local_gz.cpp index 4ffdcf9ce4..6ae25ae33d 100644 --- a/unittest/formats/test_dump_local_gz.cpp +++ b/unittest/formats/test_dump_local_gz.cpp @@ -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); diff --git a/unittest/formats/test_dump_local_zstd.cpp b/unittest/formats/test_dump_local_zstd.cpp index 364a66c6be..4a15baf4ca 100644 --- a/unittest/formats/test_dump_local_zstd.cpp +++ b/unittest/formats/test_dump_local_zstd.cpp @@ -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); diff --git a/unittest/formats/test_dump_xyz_gz.cpp b/unittest/formats/test_dump_xyz_gz.cpp index f8a3e711f3..aef54b4820 100644 --- a/unittest/formats/test_dump_xyz_gz.cpp +++ b/unittest/formats/test_dump_xyz_gz.cpp @@ -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); diff --git a/unittest/formats/test_dump_xyz_zstd.cpp b/unittest/formats/test_dump_xyz_zstd.cpp index 8767f1efd1..ce0b4ed143 100644 --- a/unittest/formats/test_dump_xyz_zstd.cpp +++ b/unittest/formats/test_dump_xyz_zstd.cpp @@ -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); diff --git a/unittest/formats/test_pair_unit_convert.cpp b/unittest/formats/test_pair_unit_convert.cpp index 3e3dd0acaa..712e6ff50c 100644 --- a/unittest/formats/test_pair_unit_convert.cpp +++ b/unittest/formats/test_pair_unit_convert.cpp @@ -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) diff --git a/unittest/formats/test_potential_file_reader.cpp b/unittest/formats/test_potential_file_reader.cpp index 38cbbcf950..4279c8d1a7 100644 --- a/unittest/formats/test_potential_file_reader.cpp +++ b/unittest/formats/test_potential_file_reader.cpp @@ -31,8 +31,8 @@ #include #include -#include #include +#include #if defined(OMPI_MAJOR_VERSION) const bool have_openmpi = true; diff --git a/unittest/fortran/wrap_commands.cpp b/unittest/fortran/wrap_commands.cpp index 493e7c4590..bdf38144c5 100644 --- a/unittest/fortran/wrap_commands.cpp +++ b/unittest/fortran/wrap_commands.cpp @@ -1,65 +1,70 @@ // unit tests for issuing command to a LAMMPS instance through the Fortran wrapper #include "lammps.h" +#include // for stdin, stdout #include -#include // for stdin, stdout #include #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); }; diff --git a/unittest/fortran/wrap_create.cpp b/unittest/fortran/wrap_create.cpp index 37443aba64..04a62e4040 100644 --- a/unittest/fortran/wrap_create.cpp +++ b/unittest/fortran/wrap_create.cpp @@ -1,33 +1,34 @@ // unit tests for the LAMMPS base class #include "lammps.h" +#include // for stdin, stdout #include -#include // for stdin, stdout #include #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:"); } diff --git a/unittest/python/test_python_package.cpp b/unittest/python/test_python_package.cpp index a47c9910ed..d8ab860c26 100644 --- a/unittest/python/test_python_package.cpp +++ b/unittest/python/test_python_package.cpp @@ -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"); diff --git a/unittest/testing/core.h b/unittest/testing/core.h index aaaf65c44f..5852f7fd06 100644 --- a/unittest/testing/core.h +++ b/unittest/testing/core.h @@ -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 diff --git a/unittest/testing/systems/melt.h b/unittest/testing/systems/melt.h index 9410b6ea77..4189a6b771 100644 --- a/unittest/testing/systems/melt.h +++ b/unittest/testing/systems/melt.h @@ -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"); } }; diff --git a/unittest/testing/utils.h b/unittest/testing/utils.h index f99856d921..39a11a3e12 100644 --- a/unittest/testing/utils.h +++ b/unittest/testing/utils.h @@ -13,12 +13,12 @@ #ifndef TEST_EXTENSIONS__H #define TEST_EXTENSIONS__H -#include -#include -#include #include -#include +#include +#include #include +#include +#include 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 read_lines(const std::string &filename) { +static std::vector read_lines(const std::string &filename) +{ std::vector lines; std::ifstream infile(filename); std::string line; @@ -62,7 +63,8 @@ static std::vector 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; } diff --git a/unittest/utils/test_math_eigen_impl.cpp b/unittest/utils/test_math_eigen_impl.cpp index 3ff60c2eb6..895a35080c 100644 --- a/unittest/utils/test_math_eigen_impl.cpp +++ b/unittest/utils/test_math_eigen_impl.cpp @@ -1,197 +1,166 @@ // THIS FILE USED TO BE EASY TO READ until I added "#if defined" statements. // (They were added to test for many different kinds of array formats.) -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include #include "math_eigen_impl.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include -using std::cout; +using std::array; using std::cerr; +using std::cout; using std::endl; using std::setprecision; using std::vector; -using std::array; using namespace MathEigen; - // This code works with various types of C++ matrices (for example, // double **, vector> array,5>). // I use "#if defined" statements to test different matrix types. // For some of these (eg. array,5>), the size of the matrix // must be known at compile time. I specify that size now. #if defined USE_ARRAY_OF_ARRAYS -const int NF=5; //(the array size must be known at compile time) +const int NF = 5; //(the array size must be known at compile time) #elif defined USE_C_FIXED_SIZE_ARRAYS -const int NF=5; //(the array size must be known at compile time) +const int NF = 5; //(the array size must be known at compile time) #endif - // @brief Are two numbers "similar"? -template -inline static bool Similar(Scalar a, Scalar b, - Scalar eps=1.0e-06, - Scalar ratio=1.0e-06, - Scalar ratio_denom=1.0) +template +inline static bool Similar(Scalar a, Scalar b, Scalar eps = 1.0e-06, Scalar ratio = 1.0e-06, + Scalar ratio_denom = 1.0) { - return ((std::abs(a-b)<=std::abs(eps)) - || - (std::abs(ratio_denom)*std::abs(a-b) - <= - std::abs(ratio)*0.5*(std::abs(a)+std::abs(b)))); + return ((std::abs(a - b) <= std::abs(eps)) || + (std::abs(ratio_denom) * std::abs(a - b) <= + std::abs(ratio) * 0.5 * (std::abs(a) + std::abs(b)))); } /// @brief Are two vectors (containing n numbers) similar? -template -inline static bool SimilarVec(Vector a, Vector b, int n, - Scalar eps=1.0e-06, - Scalar ratio=1.0e-06, - Scalar ratio_denom=1.0) +template +inline static bool SimilarVec(Vector a, Vector b, int n, Scalar eps = 1.0e-06, + Scalar ratio = 1.0e-06, Scalar ratio_denom = 1.0) { - for (int i = 0; i < n; i++) - if (not Similar(a[i], b[i], eps, ratio, ratio_denom)) - return false; - return true; + for (int i = 0; i < n; i++) + if (not Similar(a[i], b[i], eps, ratio, ratio_denom)) return false; + return true; } /// @brief Are two vectors (or their reflections) similar? -template -inline static bool SimilarVecUnsigned(Vector a, Vector b, int n, - Scalar eps=1.0e-06, - Scalar ratio=1.0e-06, - Scalar ratio_denom=1.0) +template +inline static bool SimilarVecUnsigned(Vector a, Vector b, int n, Scalar eps = 1.0e-06, + Scalar ratio = 1.0e-06, Scalar ratio_denom = 1.0) { - if (SimilarVec(a, b, n, eps)) - return true; - else { - for (int i = 0; i < n; i++) - if (not Similar(a[i], -b[i], eps, ratio, ratio_denom)) - return false; - return true; - } + if (SimilarVec(a, b, n, eps)) + return true; + else { + for (int i = 0; i < n; i++) + if (not Similar(a[i], -b[i], eps, ratio, ratio_denom)) return false; + return true; + } } - /// @brief Multiply two matrices A and B, store the result in C. (C = AB). -template +template void mmult(ConstMatrix A, // -void -SortRows(Vector eval, - Matrix evec, - int n, - bool sort_decreasing=true, - bool sort_abs=false) +/// This is the same as the Jacobi::SortRows(), but that function is private. +template +void SortRows(Vector eval, Matrix evec, int n, bool sort_decreasing = true, bool sort_abs = false) { - for (int i = 0; i < n-1; i++) { - int i_max = i; - for (int j = i+1; j < n; j++) { - if (sort_decreasing) { - if (sort_abs) { //sort by absolute value? - if (std::abs(eval[j]) > std::abs(eval[i_max])) - i_max = j; + for (int i = 0; i < n - 1; i++) { + int i_max = i; + for (int j = i + 1; j < n; j++) { + if (sort_decreasing) { + if (sort_abs) { // sort by absolute value? + if (std::abs(eval[j]) > std::abs(eval[i_max])) i_max = j; + } else if (eval[j] > eval[i_max]) + i_max = j; + } else { + if (sort_abs) { // sort by absolute value? + if (std::abs(eval[j]) < std::abs(eval[i_max])) i_max = j; + } else if (eval[j] < eval[i_max]) + i_max = j; + } } - else if (eval[j] > eval[i_max]) - i_max = j; - } - else { - if (sort_abs) { //sort by absolute value? - if (std::abs(eval[j]) < std::abs(eval[i_max])) - i_max = j; - } - else if (eval[j] < eval[i_max]) - i_max = j; - } + std::swap(eval[i], eval[i_max]); // sort "eval" + for (int k = 0; k < n; k++) + std::swap(evec[i][k], evec[i_max][k]); // sort "evec" } - std::swap(eval[i], eval[i_max]); // sort "eval" - for (int k = 0; k < n; k++) - std::swap(evec[i][k], evec[i_max][k]); // sort "evec" - } } - - /// @brief Generate a random orthonormal n x n matrix -template -void GenRandOrth(Matrix R, - int n, - std::default_random_engine &rand_generator) +template +void GenRandOrth(Matrix R, int n, std::default_random_engine &rand_generator) { - std::normal_distribution gaussian_distribution(0,1); - std::vector v(n); + std::normal_distribution gaussian_distribution(0, 1); + std::vector v(n); - for (int i = 0; i < n; i++) { - // Generate a vector, "v", in a random direction subject to the constraint - // that it is orthogonal to the first i-1 rows-vectors of the R matrix. - Scalar rsq = 0.0; - while (rsq == 0.0) { - // Generate a vector in a random direction - // (This works because we are using a normal (Gaussian) distribution) - for (int j = 0; j < n; j++) - v[j] = gaussian_distribution(rand_generator); + for (int i = 0; i < n; i++) { + // Generate a vector, "v", in a random direction subject to the constraint + // that it is orthogonal to the first i-1 rows-vectors of the R matrix. + Scalar rsq = 0.0; + while (rsq == 0.0) { + // Generate a vector in a random direction + // (This works because we are using a normal (Gaussian) distribution) + for (int j = 0; j < n; j++) + v[j] = gaussian_distribution(rand_generator); - //Now subtract from v, the projection of v onto the first i-1 rows of R. - //This will produce a vector which is orthogonal to these i-1 row-vectors. - //(They are already normalized and orthogonal to each other.) - for (int k = 0; k < i; k++) { - Scalar v_dot_Rk = 0.0; - for (int j = 0; j < n; j++) - v_dot_Rk += v[j] * R[k][j]; + // Now subtract from v, the projection of v onto the first i-1 rows of R. + // This will produce a vector which is orthogonal to these i-1 row-vectors. + //(They are already normalized and orthogonal to each other.) + for (int k = 0; k < i; k++) { + Scalar v_dot_Rk = 0.0; + for (int j = 0; j < n; j++) + v_dot_Rk += v[j] * R[k][j]; + for (int j = 0; j < n; j++) + v[j] -= v_dot_Rk * R[k][j]; + } + // check if it is linearly independent of the other vectors and non-zero + rsq = 0.0; + for (int j = 0; j < n; j++) + rsq += v[j] * v[j]; + } + // Now normalize the vector + Scalar r_inv = 1.0 / std::sqrt(rsq); for (int j = 0; j < n; j++) - v[j] -= v_dot_Rk * R[k][j]; - } - // check if it is linearly independent of the other vectors and non-zero - rsq = 0.0; - for (int j = 0; j < n; j++) - rsq += v[j]*v[j]; - } - // Now normalize the vector - Scalar r_inv = 1.0 / std::sqrt(rsq); - for (int j = 0; j < n; j++) - v[j] *= r_inv; - // Now copy this vector to the i'th row of R - for (int j = 0; j < n; j++) - R[i][j] = v[j]; - } //for (int i = 0; i < n; i++) -} //void GenRandOrth() - - + v[j] *= r_inv; + // Now copy this vector to the i'th row of R + for (int j = 0; j < n; j++) + R[i][j] = v[j]; + } // for (int i = 0; i < n; i++) +} // void GenRandOrth() /// @brief Generate a random symmetric n x n matrix, M. /// This function generates random numbers for the eigenvalues ("evals_known") @@ -207,560 +176,473 @@ void GenRandOrth(Matrix R, /// and eigenvectors calculated by Jacobi::Diagonalize() template -void GenRandSymm(Matrix M, // random_real01; - std::normal_distribution gaussian_distribution(0, max_eval_size); - bool use_log_uniform_distribution = false; - if (min_eval_size > 0.0) - use_log_uniform_distribution = true; - #if defined USE_VECTOR_OF_VECTORS - vector > D(n, vector(n)); - vector > tmp(n, vector(n)); - #elif defined USE_ARRAY_OF_ARRAYS - array, NF> D; - array, NF> tmp; - #elif defined USE_C_FIXED_SIZE_ARRAYS - Scalar D[NF][NF], tmp[NF][NF]; - #else - #define USE_C_POINTER_TO_POINTERS - Scalar **D, **tmp; - Alloc2D(n, n, &D); - Alloc2D(n, n, &tmp); - #endif + assert(n_degeneracy <= n); + std::uniform_real_distribution random_real01; + std::normal_distribution gaussian_distribution(0, max_eval_size); + bool use_log_uniform_distribution = false; + if (min_eval_size > 0.0) use_log_uniform_distribution = true; +#if defined USE_VECTOR_OF_VECTORS + vector> D(n, vector(n)); + vector> tmp(n, vector(n)); +#elif defined USE_ARRAY_OF_ARRAYS + array, NF> D; + array, NF> tmp; +#elif defined USE_C_FIXED_SIZE_ARRAYS + Scalar D[NF][NF], tmp[NF][NF]; +#else +#define USE_C_POINTER_TO_POINTERS + Scalar **D, **tmp; + Alloc2D(n, n, &D); + Alloc2D(n, n, &tmp); +#endif - // Randomly generate the eigenvalues - for (int i = 0; i < n; i++) { - if (use_log_uniform_distribution) { - // Use a "log-uniform distribution" (a.k.a. "reciprocal distribution") - // (This is a way to specify numbers with a precise range of magnitudes.) - assert((min_eval_size > 0.0) && (max_eval_size > 0.0)); - Scalar log_min = std::log(std::abs(min_eval_size)); - Scalar log_max = std::log(std::abs(max_eval_size)); - Scalar log_eval = (log_min + random_real01(rand_generator)*(log_max-log_min)); - evals[i] = std::exp(log_eval); - // also consider both positive and negative eigenvalues: - if (random_real01(rand_generator) < 0.5) - evals[i] = -evals[i]; + // Randomly generate the eigenvalues + for (int i = 0; i < n; i++) { + if (use_log_uniform_distribution) { + // Use a "log-uniform distribution" (a.k.a. "reciprocal distribution") + // (This is a way to specify numbers with a precise range of magnitudes.) + assert((min_eval_size > 0.0) && (max_eval_size > 0.0)); + Scalar log_min = std::log(std::abs(min_eval_size)); + Scalar log_max = std::log(std::abs(max_eval_size)); + Scalar log_eval = (log_min + random_real01(rand_generator) * (log_max - log_min)); + evals[i] = std::exp(log_eval); + // also consider both positive and negative eigenvalues: + if (random_real01(rand_generator) < 0.5) evals[i] = -evals[i]; + } else { + evals[i] = gaussian_distribution(rand_generator); + } } - else { - evals[i] = gaussian_distribution(rand_generator); - } - } - // Does the user want us to force some of the eigenvalues to be the same? - if (n_degeneracy > 1) { - int *permutation = new int[n]; //a random permutation from 0...n-1 + // Does the user want us to force some of the eigenvalues to be the same? + if (n_degeneracy > 1) { + int *permutation = new int[n]; // a random permutation from 0...n-1 + for (int i = 0; i < n; i++) + permutation[i] = i; + std::shuffle(permutation, permutation + n, rand_generator); + for (int i = 1; i < n_degeneracy; i++) // set the first n_degeneracy to same + evals[permutation[i]] = evals[permutation[0]]; + delete[] permutation; + } + + // D is a diagonal matrix whose diagonal elements are the eigenvalues for (int i = 0; i < n; i++) - permutation[i] = i; - std::shuffle(permutation, permutation+n, rand_generator); - for (int i = 1; i < n_degeneracy; i++) //set the first n_degeneracy to same - evals[permutation[i]] = evals[permutation[0]]; - delete [] permutation; - } + for (int j = 0; j < n; j++) + D[i][j] = ((i == j) ? evals[i] : 0.0); - // D is a diagonal matrix whose diagonal elements are the eigenvalues - for (int i = 0; i < n; i++) - for (int j = 0; j < n; j++) - D[i][j] = ((i == j) ? evals[i] : 0.0); + // Now randomly generate the (transpose of) the "evecs" matrix + GenRandOrth(evecs, n, rand_generator); //(will transpose it later) - // Now randomly generate the (transpose of) the "evecs" matrix - GenRandOrth(evecs, n, rand_generator); //(will transpose it later) +// Construct the test matrix, M, where M = Rt * D * R - // Construct the test matrix, M, where M = Rt * D * R +// Original code: +// mmult(evecs, D, tmp, n); // <--> tmp = Rt * D +// Unfortunately, C++ guesses the types incorrectly. Must manually specify: +// #ifdefs making the code ugly again: +#if defined USE_VECTOR_OF_VECTORS + mmult> &, const vector> &> +#elif defined USE_ARRAY_OF_ARRAYS + mmult, NF> &, const array, NF> &> +#elif defined USE_C_FIXED_SIZE_ARRAYS + mmult +#else + mmult +#endif + (evecs, D, tmp, n); - // Original code: - //mmult(evecs, D, tmp, n); // <--> tmp = Rt * D - // Unfortunately, C++ guesses the types incorrectly. Must manually specify: - // #ifdefs making the code ugly again: - #if defined USE_VECTOR_OF_VECTORS - mmult >&, const vector >&> - #elif defined USE_ARRAY_OF_ARRAYS - mmult,NF>&, const array,NF>&> - #elif defined USE_C_FIXED_SIZE_ARRAYS - mmult - #else - mmult - #endif - (evecs, D, tmp, n); + for (int i = 0; i < n - 1; i++) + for (int j = i + 1; j < n; j++) + std::swap(evecs[i][j], evecs[j][i]); // transpose "evecs" - for (int i = 0; i < n-1; i++) - for (int j = i+1; j < n; j++) - std::swap(evecs[i][j], evecs[j][i]); //transpose "evecs" +// Original code: +// mmult(tmp, evecs, M, n); +// Unfortunately, C++ guesses the types incorrectly. Must manually specify: +// #ifdefs making the code ugly again: +#if defined USE_VECTOR_OF_VECTORS + mmult> &, const vector> &> +#elif defined USE_ARRAY_OF_ARRAYS + mmult, NF> &, const array, NF> &> +#elif defined USE_C_FIXED_SIZE_ARRAYS + mmult +#else + mmult +#endif + (tmp, evecs, M, n); + // at this point M = Rt*D*R (where "R"="evecs") - // Original code: - //mmult(tmp, evecs, M, n); - // Unfortunately, C++ guesses the types incorrectly. Must manually specify: - // #ifdefs making the code ugly again: - #if defined USE_VECTOR_OF_VECTORS - mmult >&, const vector >&> - #elif defined USE_ARRAY_OF_ARRAYS - mmult,NF>&, const array,NF>&> - #elif defined USE_C_FIXED_SIZE_ARRAYS - mmult - #else - mmult - #endif - (tmp, evecs, M, n); - //at this point M = Rt*D*R (where "R"="evecs") - - #if defined USE_C_POINTER_TO_POINTERS - Dealloc2D(&D); - Dealloc2D(&tmp); - #endif +#if defined USE_C_POINTER_TO_POINTERS + Dealloc2D(&D); + Dealloc2D(&tmp); +#endif } // GenRandSymm() - - template -void TestJacobi(int n, // &, vector> &, const vector> &> + ecalc(n); - #if defined USE_VECTOR_OF_VECTORS + // allocate the matrix, eigenvalues, eigenvectors + vector> M(n, vector(n)); + vector> evecs(n, vector(n)); + vector> evecs_known(n, vector(n)); + vector evals(n); + vector evals_known(n); + vector test_evec(n); - Jacobi&, - vector >&, - const vector >& > ecalc(n); +#elif defined USE_ARRAY_OF_ARRAYS - // allocate the matrix, eigenvalues, eigenvectors - vector > M(n, vector(n)); - vector > evecs(n, vector(n)); - vector > evecs_known(n, vector(n)); - vector evals(n); - vector evals_known(n); - vector test_evec(n); + n = NF; + cout << "Testing std::array (fixed size).\n" + "(Ignoring first argument, and setting matrix size to " + << n << ")" << endl; - #elif defined USE_ARRAY_OF_ARRAYS + Jacobi &, array, NF> &, + const array, NF> &> + ecalc(n); - n = NF; - cout << "Testing std::array (fixed size).\n" - "(Ignoring first argument, and setting matrix size to " << n << ")" << endl; + // allocate the matrix, eigenvalues, eigenvectors + array, NF> M; + array, NF> evecs; + array, NF> evecs_known; + array evals; + array evals_known; + array test_evec; - Jacobi&, - array, NF>&, - const array, NF>&> ecalc(n); +#elif defined USE_C_FIXED_SIZE_ARRAYS - // allocate the matrix, eigenvalues, eigenvectors - array, NF> M; - array, NF> evecs; - array, NF> evecs_known; - array evals; - array evals_known; - array test_evec; + n = NF; + cout << "Testing C fixed size arrays.\n" + "(Ignoring first argument, and setting matrix size to " + << n << ")" << endl; + Jacobi ecalc(n); - #elif defined USE_C_FIXED_SIZE_ARRAYS + // allocate the matrix, eigenvalues, eigenvectors + Scalar M[NF][NF]; + Scalar evecs[NF][NF]; + Scalar evecs_known[NF][NF]; + Scalar evals[NF]; + Scalar evals_known[NF]; + Scalar test_evec[NF]; - n = NF; - cout << "Testing C fixed size arrays.\n" - "(Ignoring first argument, and setting matrix size to " << n << ")" << endl; - Jacobi ecalc(n); +#else - // allocate the matrix, eigenvalues, eigenvectors - Scalar M[NF][NF]; - Scalar evecs[NF][NF]; - Scalar evecs_known[NF][NF]; - Scalar evals[NF]; - Scalar evals_known[NF]; - Scalar test_evec[NF]; +#define USE_C_POINTER_TO_POINTERS - #else + // Note: Normally, you would just use this to instantiate Jacobi: + // Jacobi ecalc(n); + // ------------------------- + // ..but since Jacobi manages its own memory using new and delete, I also want + // to test that the copy constructors, copy operators, and destructors work. + // The following lines do this: + Jacobi ecalc_test_mem1(n); + Jacobi ecalc_test_mem2(2); + // test the = operator + ecalc_test_mem2 = ecalc_test_mem1; + // test the copy constructor + Jacobi ecalc(ecalc_test_mem2); + // allocate the matrix, eigenvalues, eigenvectors + Scalar **M, **evecs, **evecs_known; + Alloc2D(n, n, &M); + Alloc2D(n, n, &evecs); + Alloc2D(n, n, &evecs_known); + Scalar *evals = new Scalar[n]; + Scalar *evals_known = new Scalar[n]; + Scalar *test_evec = new Scalar[n]; - #define USE_C_POINTER_TO_POINTERS +#endif - // Note: Normally, you would just use this to instantiate Jacobi: - // Jacobi ecalc(n); - // ------------------------- - // ..but since Jacobi manages its own memory using new and delete, I also want - // to test that the copy constructors, copy operators, and destructors work. - // The following lines do this: - Jacobi ecalc_test_mem1(n); - Jacobi ecalc_test_mem2(2); - // test the = operator - ecalc_test_mem2 = ecalc_test_mem1; - // test the copy constructor - Jacobi ecalc(ecalc_test_mem2); - // allocate the matrix, eigenvalues, eigenvectors - Scalar **M, **evecs, **evecs_known; - Alloc2D(n, n, &M); - Alloc2D(n, n, &evecs); - Alloc2D(n, n, &evecs_known); - Scalar *evals = new Scalar[n]; - Scalar *evals_known = new Scalar[n]; - Scalar *test_evec = new Scalar[n]; + // -------------------------------------------------------------------- + // Now, generate random matrices and test Jacobi::Diagonalize() on them. + // -------------------------------------------------------------------- - #endif + for (int imat = 0; imat < n_matrices; imat++) { + // Create a randomly generated symmetric matrix. + // This function generates random numbers for the eigenvalues ("evals_known") + // as well as the eigenvectors ("evecs_known"), and uses them to generate M. - // -------------------------------------------------------------------- - // Now, generate random matrices and test Jacobi::Diagonalize() on them. - // -------------------------------------------------------------------- +#if defined USE_VECTOR_OF_VECTORS + GenRandSymm &, vector> &> +#elif defined USE_ARRAY_OF_ARRAYS + GenRandSymm &, array, NF> &> +#elif defined USE_C_FIXED_SIZE_ARRAYS + GenRandSymm +#else + GenRandSymm +#endif + (M, n, evals_known, evecs_known, rand_generator, min_eval_size, max_eval_size, + n_degeneracy); - for(int imat = 0; imat < n_matrices; imat++) { - - // Create a randomly generated symmetric matrix. - //This function generates random numbers for the eigenvalues ("evals_known") - //as well as the eigenvectors ("evecs_known"), and uses them to generate M. - - #if defined USE_VECTOR_OF_VECTORS - GenRandSymm&, vector >&> - #elif defined USE_ARRAY_OF_ARRAYS - GenRandSymm&, array,NF>&> - #elif defined USE_C_FIXED_SIZE_ARRAYS - GenRandSymm - #else - GenRandSymm - #endif - (M, - n, - evals_known, - evecs_known, - rand_generator, - min_eval_size, - max_eval_size, - n_degeneracy); - - // Sort the matrix evals and eigenvector rows: - // Original code: - //SortRows(evals_known, evecs_known, n); - // Unfortunately, C++ guesses the types incorrectly. Must use #ifdefs again: - #if defined USE_VECTOR_OF_VECTORS - SortRows&, vector >&> - #elif defined USE_ARRAY_OF_ARRAYS - SortRows&, array,NF>&> - #elif defined USE_C_FIXED_SIZE_ARRAYS - SortRows - #else - SortRows - #endif +// Sort the matrix evals and eigenvector rows: +// Original code: +// SortRows(evals_known, evecs_known, n); +// Unfortunately, C++ guesses the types incorrectly. Must use #ifdefs again: +#if defined USE_VECTOR_OF_VECTORS + SortRows &, vector> &> +#elif defined USE_ARRAY_OF_ARRAYS + SortRows &, array, NF> &> +#elif defined USE_C_FIXED_SIZE_ARRAYS + SortRows +#else + SortRows +#endif (evals_known, evecs_known, n); + if (n_matrices == 1) { + cout << "Eigenvalues (after sorting):\n"; + for (int i = 0; i < n; i++) + cout << evals_known[i] << " "; + cout << "\n"; + cout << "Eigenvectors (rows) which are known in advance:\n"; + for (int i = 0; i < n; i++) { + for (int j = 0; j < n; j++) + cout << evecs_known[i][j] << " "; + cout << "\n"; + } + cout + << " (The eigenvectors calculated by Jacobi::Diagonalize() should match these.)\n"; + } - if (n_matrices == 1) { - cout << "Eigenvalues (after sorting):\n"; - for (int i = 0; i < n; i++) - cout << evals_known[i] << " "; - cout << "\n"; - cout << "Eigenvectors (rows) which are known in advance:\n"; - for (int i = 0; i < n; i++) { - for (int j = 0; j < n; j++) - cout << evecs_known[i][j] << " "; - cout << "\n"; - } - cout << " (The eigenvectors calculated by Jacobi::Diagonalize() should match these.)\n"; + for (int i_test = 0; i_test < n_tests_per_matrix; i_test++) { + + if (test_code_coverage) { + +// test SORT_INCREASING_ABS_EVALS: +#if defined USE_VECTOR_OF_VECTORS + ecalc.Diagonalize( + M, evals, evecs, + Jacobi &, vector> &, + const vector> &>::SORT_INCREASING_ABS_EVALS); +#elif defined USE_ARRAY_OF_ARRAYS + ecalc.Diagonalize( + M, evals, evecs, + Jacobi &, array, NF> &, + const array, NF> &>::SORT_INCREASING_ABS_EVALS); +#elif defined USE_C_FIXED_SIZE_ARRAYS + ecalc.Diagonalize(M, evals, evecs, + Jacobi::SORT_INCREASING_ABS_EVALS); +#else + ecalc.Diagonalize(M, evals, evecs, + Jacobi::SORT_INCREASING_ABS_EVALS); +#endif + + for (int i = 1; i < n; i++) + assert(std::abs(evals[i - 1]) <= std::abs(evals[i])); + +// test SORT_DECREASING_ABS_EVALS: +#if defined USE_VECTOR_OF_VECTORS + ecalc.Diagonalize( + M, evals, evecs, + Jacobi &, vector> &, + const vector> &>::SORT_DECREASING_ABS_EVALS); +#elif defined USE_ARRAY_OF_ARRAYS + ecalc.Diagonalize( + M, evals, evecs, + Jacobi &, array, NF> &, + const array, NF> &>::SORT_DECREASING_ABS_EVALS); +#elif defined USE_C_FIXED_SIZE_ARRAYS + ecalc.Diagonalize(M, evals, evecs, + Jacobi::SORT_DECREASING_ABS_EVALS); +#else + ecalc.Diagonalize(M, evals, evecs, + Jacobi::SORT_DECREASING_ABS_EVALS); +#endif + + for (int i = 1; i < n; i++) + assert(std::abs(evals[i - 1]) >= std::abs(evals[i])); + +// test SORT_INCREASING_EVALS: +#if defined USE_VECTOR_OF_VECTORS + ecalc.Diagonalize(M, evals, evecs, + Jacobi &, vector> &, + const vector> &>::SORT_INCREASING_EVALS); +#elif defined USE_ARRAY_OF_ARRAYS + ecalc.Diagonalize( + M, evals, evecs, + Jacobi &, array, NF> &, + const array, NF> &>::SORT_INCREASING_EVALS); +#elif defined USE_C_FIXED_SIZE_ARRAYS + ecalc.Diagonalize(M, evals, evecs, + Jacobi::SORT_INCREASING_EVALS); +#else + ecalc.Diagonalize(M, evals, evecs, + Jacobi::SORT_INCREASING_EVALS); +#endif + for (int i = 1; i < n; i++) + assert(evals[i - 1] <= evals[i]); + +// test DO_NOT_SORT +#if defined USE_VECTOR_OF_VECTORS + ecalc.Diagonalize(M, evals, evecs, + Jacobi &, vector> &, + const vector> &>::DO_NOT_SORT); +#elif defined USE_ARRAY_OF_ARRAYS + ecalc.Diagonalize( + M, evals, evecs, + Jacobi &, array, NF> &, + const array, NF> &>::DO_NOT_SORT); +#elif defined USE_C_FIXED_SIZE_ARRAYS + ecalc.Diagonalize( + M, evals, evecs, + Jacobi::DO_NOT_SORT); +#else + ecalc.Diagonalize( + M, evals, evecs, + Jacobi::DO_NOT_SORT); +#endif + + } // if (test_code_coverage) + + // Now (finally) calculate the eigenvalues and eigenvectors + int n_sweeps = ecalc.Diagonalize(M, evals, evecs); + + if ((n_matrices == 1) && (i_test == 0)) { + cout << "Jacobi::Diagonalize() ran for " << n_sweeps << " iters (sweeps).\n"; + cout << "Eigenvalues calculated by Jacobi::Diagonalize()\n"; + for (int i = 0; i < n; i++) + cout << evals[i] << " "; + cout << "\n"; + cout << "Eigenvectors (rows) calculated by Jacobi::Diagonalize()\n"; + for (int i = 0; i < n; i++) { + for (int j = 0; j < n; j++) + cout << evecs[i][j] << " "; + cout << "\n"; + } + } + + assert(SimilarVec(evals, evals_known, n, eps * max_eval_size, eps)); + // Check that each eigenvector satisfies Mv = λv + // <--> Σ_b M[a][b]*evecs[i][b] = evals[i]*evecs[i][b] (for all a) + for (int i = 0; i < n; i++) { + for (int a = 0; a < n; a++) { + test_evec[a] = 0.0; + for (int b = 0; b < n; b++) + test_evec[a] += M[a][b] * evecs[i][b]; + assert(Similar(test_evec[a], evals[i] * evecs[i][a], + eps, // tolerance (absolute difference) + eps * max_eval_size, // tolerance ratio (numerator) + evals_known[i] // tolerance ration (denominator) + )); + } + } + + } // for (int i_test = 0; i_test < n_tests_per_matrix; i++) + + } // for(int imat = 0; imat < n_matrices; imat++) { + +#if defined USE_C_POINTER_TO_POINTERS + Dealloc2D(&M); + Dealloc2D(&evecs); + Dealloc2D(&evecs_known); + delete[] evals; + delete[] evals_known; + delete[] test_evec; +#endif + +} // TestJacobi() + +int main(int argc, char **argv) +{ + int n_size = 2; + int n_matr = 1; + double emin = 0.0; + double emax = 1.0; + int n_tests = 1; + int n_degeneracy = 1; + unsigned seed = 0; + + if (argc <= 1) { + cerr << "Error: This program requires at least 1 argument.\n" + "\n" + "Description: Run Jacobi::Diagonalize() on randomly generated matrices.\n" + "\n" + "Arguments: n_size [n_matr emin emax n_degeneracy n_tests seed eps]\n" + " n_size = the size of the matrices\n" + " (NOTE: The remaining arguments are optional.)\n" + " n_matr = the number of randomly generated matrices to test\n" + " emin = the smallest possible eigenvalue magnitude (eg. 1e-05)\n" + " emax = the largest possible eigenvalue magnitude (>0 eg. 1e+05)\n" + " (NOTE: If emin=0, a normal distribution is used centered at 0.\n" + " Otherwise a log-uniform distribution is used from emin to emax.)\n" + " n_degeneracy = the number of repeated eigenvalues (1 disables, default)\n" + " n_tests = the number of times the eigenvalues and eigenvectors\n" + " are calculated for EACH matrix. By default this is 1.\n" + " (Increase this to at least 20 if you plan to use this\n" + " program for benchmarking (speed testing), because the time\n" + " needed for generating a random matrix is not negligible.)\n" + " (IF THIS NUMBER IS 0, it will test CODE-COVERAGE instead.)\n" + " seed = the seed used by the random number \"rand_generator\".\n" + " (If this number is 0, which is the default, the system\n" + " clock is used to choose a random seed.)\n" + " eps = the tolerance. The difference between eigenvalues and their\n" + " true value, cannot exceed this (multiplied by the eigenvalue\n" + " of maximum magnitude). Similarly, the difference between\n" + " the eigenvectors after multiplication by the matrix and by\n" + " and after multiplication by the eigenvalue, cannot exceed\n" + " eps*maximum_eigenvalue/eigenvalue. The default value is\n" + " 1.0e-06 (which works well for double precision numbers).\n" + << endl; + return 1; } - for (int i_test = 0; i_test < n_tests_per_matrix; i_test++) { + n_size = std::stoi(argv[1]); + if (argc > 2) n_matr = std::stoi(argv[2]); + if (argc > 3) emin = std::stof(argv[3]); + if (argc > 4) emax = std::stof(argv[4]); + if (argc > 5) n_degeneracy = std::stoi(argv[5]); + if (argc > 6) n_tests = std::stoi(argv[6]); + if (argc > 7) seed = std::stoi(argv[7]); + double eps = 1.0e-06; + if (argc > 8) eps = std::stof(argv[8]); - if (test_code_coverage) { + TestJacobi(n_size, n_matr, emin, emax, n_tests, n_degeneracy, seed, eps); - // test SORT_INCREASING_ABS_EVALS: - #if defined USE_VECTOR_OF_VECTORS - ecalc.Diagonalize(M, - evals, - evecs, - Jacobi&, - vector >&, - const vector >& >::SORT_INCREASING_ABS_EVALS); - #elif defined USE_ARRAY_OF_ARRAYS - ecalc.Diagonalize(M, - evals, - evecs, - Jacobi&, - array,NF>&, - const array,NF>&>::SORT_INCREASING_ABS_EVALS); - #elif defined USE_C_FIXED_SIZE_ARRAYS - ecalc.Diagonalize(M, - evals, - evecs, - Jacobi::SORT_INCREASING_ABS_EVALS); - #else - ecalc.Diagonalize(M, - evals, - evecs, - Jacobi::SORT_INCREASING_ABS_EVALS); - #endif - - for (int i = 1; i < n; i++) - assert(std::abs(evals[i-1])<=std::abs(evals[i])); - - // test SORT_DECREASING_ABS_EVALS: - #if defined USE_VECTOR_OF_VECTORS - ecalc.Diagonalize(M, - evals, - evecs, - Jacobi&, - vector >&, - const vector >& >::SORT_DECREASING_ABS_EVALS); - #elif defined USE_ARRAY_OF_ARRAYS - ecalc.Diagonalize(M, - evals, - evecs, - Jacobi&, - array,NF>&, - const array,NF>&>::SORT_DECREASING_ABS_EVALS); - #elif defined USE_C_FIXED_SIZE_ARRAYS - ecalc.Diagonalize(M, - evals, - evecs, - Jacobi::SORT_DECREASING_ABS_EVALS); - #else - ecalc.Diagonalize(M, - evals, - evecs, - Jacobi::SORT_DECREASING_ABS_EVALS); - #endif - - for (int i = 1; i < n; i++) - assert(std::abs(evals[i-1])>=std::abs(evals[i])); - - // test SORT_INCREASING_EVALS: - #if defined USE_VECTOR_OF_VECTORS - ecalc.Diagonalize(M, - evals, - evecs, - Jacobi&, - vector >&, - const vector >& >::SORT_INCREASING_EVALS); - #elif defined USE_ARRAY_OF_ARRAYS - ecalc.Diagonalize(M, - evals, - evecs, - Jacobi&, - array,NF>&, - const array,NF>&>::SORT_INCREASING_EVALS); - #elif defined USE_C_FIXED_SIZE_ARRAYS - ecalc.Diagonalize(M, - evals, - evecs, - Jacobi::SORT_INCREASING_EVALS); - #else - ecalc.Diagonalize(M, - evals, - evecs, - Jacobi::SORT_INCREASING_EVALS); - #endif - for (int i = 1; i < n; i++) - assert(evals[i-1] <= evals[i]); - - // test DO_NOT_SORT - #if defined USE_VECTOR_OF_VECTORS - ecalc.Diagonalize(M, - evals, - evecs, - Jacobi&, - vector >&, - const vector >& >::DO_NOT_SORT); - #elif defined USE_ARRAY_OF_ARRAYS - ecalc.Diagonalize(M, - evals, - evecs, - Jacobi&, - array,NF>&, - const array,NF>&>::DO_NOT_SORT); - #elif defined USE_C_FIXED_SIZE_ARRAYS - ecalc.Diagonalize(M, - evals, - evecs, - Jacobi::DO_NOT_SORT); - #else - ecalc.Diagonalize(M, - evals, - evecs, - Jacobi::DO_NOT_SORT); - #endif - - } //if (test_code_coverage) - - - // Now (finally) calculate the eigenvalues and eigenvectors - int n_sweeps = ecalc.Diagonalize(M, evals, evecs); - - if ((n_matrices == 1) && (i_test == 0)) { - cout <<"Jacobi::Diagonalize() ran for "< Σ_b M[a][b]*evecs[i][b] = evals[i]*evecs[i][b] (for all a) - for (int i = 0; i < n; i++) { - for (int a = 0; a < n; a++) { - test_evec[a] = 0.0; - for (int b = 0; b < n; b++) - test_evec[a] += M[a][b] * evecs[i][b]; - assert(Similar(test_evec[a], - evals[i] * evecs[i][a], - eps, // tolerance (absolute difference) - eps*max_eval_size, // tolerance ratio (numerator) - evals_known[i] // tolerance ration (denominator) - )); - } - } - - } //for (int i_test = 0; i_test < n_tests_per_matrix; i++) - - } //for(int imat = 0; imat < n_matrices; imat++) { - - #if defined USE_C_POINTER_TO_POINTERS - Dealloc2D(&M); - Dealloc2D(&evecs); - Dealloc2D(&evecs_known); - delete [] evals; - delete [] evals_known; - delete [] test_evec; - #endif - -} //TestJacobi() - - -int main(int argc, char **argv) { - int n_size = 2; - int n_matr = 1; - double emin = 0.0; - double emax = 1.0; - int n_tests = 1; - int n_degeneracy = 1; - unsigned seed = 0; - - if (argc <= 1) { - cerr << - "Error: This program requires at least 1 argument.\n" - "\n" - "Description: Run Jacobi::Diagonalize() on randomly generated matrices.\n" - "\n" - "Arguments: n_size [n_matr emin emax n_degeneracy n_tests seed eps]\n" - " n_size = the size of the matrices\n" - " (NOTE: The remaining arguments are optional.)\n" - " n_matr = the number of randomly generated matrices to test\n" - " emin = the smallest possible eigenvalue magnitude (eg. 1e-05)\n" - " emax = the largest possible eigenvalue magnitude (>0 eg. 1e+05)\n" - " (NOTE: If emin=0, a normal distribution is used centered at 0.\n" - " Otherwise a log-uniform distribution is used from emin to emax.)\n" - " n_degeneracy = the number of repeated eigenvalues (1 disables, default)\n" - " n_tests = the number of times the eigenvalues and eigenvectors\n" - " are calculated for EACH matrix. By default this is 1.\n" - " (Increase this to at least 20 if you plan to use this\n" - " program for benchmarking (speed testing), because the time\n" - " needed for generating a random matrix is not negligible.)\n" - " (IF THIS NUMBER IS 0, it will test CODE-COVERAGE instead.)\n" - " seed = the seed used by the random number \"rand_generator\".\n" - " (If this number is 0, which is the default, the system\n" - " clock is used to choose a random seed.)\n" - " eps = the tolerance. The difference between eigenvalues and their\n" - " true value, cannot exceed this (multiplied by the eigenvalue\n" - " of maximum magnitude). Similarly, the difference between\n" - " the eigenvectors after multiplication by the matrix and by\n" - " and after multiplication by the eigenvalue, cannot exceed\n" - " eps*maximum_eigenvalue/eigenvalue. The default value is\n" - " 1.0e-06 (which works well for double precision numbers).\n" - << endl; - return 1; - } - - n_size = std::stoi(argv[1]); - if (argc > 2) - n_matr = std::stoi(argv[2]); - if (argc > 3) - emin = std::stof(argv[3]); - if (argc > 4) - emax = std::stof(argv[4]); - if (argc > 5) - n_degeneracy = std::stoi(argv[5]); - if (argc > 6) - n_tests = std::stoi(argv[6]); - if (argc > 7) - seed = std::stoi(argv[7]); - double eps = 1.0e-06; - if (argc > 8) - eps = std::stof(argv[8]); - - TestJacobi(n_size, n_matr, emin, emax, n_tests, n_degeneracy, seed, eps); - - cout << "test passed\n" << endl; - return EXIT_SUCCESS; + cout << "test passed\n" << endl; + return EXIT_SUCCESS; } diff --git a/unittest/utils/test_mempool.cpp b/unittest/utils/test_mempool.cpp index c3032e8a96..5ee809c422 100644 --- a/unittest/utils/test_mempool.cpp +++ b/unittest/utils/test_mempool.cpp @@ -19,329 +19,333 @@ using namespace LAMMPS_NS; -TEST(MyPage, int) { +TEST(MyPage, int) +{ MyPage 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 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 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 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 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); } - diff --git a/unittest/utils/test_tokenizer.cpp b/unittest/utils/test_tokenizer.cpp index c5b0a7ea69..74eeaac832 100644 --- a/unittest/utils/test_tokenizer.cpp +++ b/unittest/utils/test_tokenizer.cpp @@ -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")); } diff --git a/unittest/utils/test_utils.cpp b/unittest/utils/test_utils.cpp index 2c3da7b9df..da5c100b65 100644 --- a/unittest/utils/test_utils.cpp +++ b/unittest/utils/test_utils.cpp @@ -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); }