Unverified Commit 416467a1 authored by Axel Kohlmeyer's avatar Axel Kohlmeyer
Browse files

update reset_mol_ids tests for the latest changes

parent fd95fc98

unittest/commands/test_reset_ids.cpp

+295 −54
Original line number Diff line number Diff line
@@ -160,58 +160,58 @@ TEST_F(ResetIDsTest, DeletePlusAtomID) 
    ASSERT_EQ(lmp->atom->natoms, 23);

    ASSERT_EQ(lmp->atom->map_tag_max, 26);



    EXPECT_EQ(molid[GETIDX(1)], 1);

    EXPECT_EQ(molid[GETIDX(2)], 1);

    EXPECT_EQ(molid[GETIDX(3)], 1);

    EXPECT_EQ(molid[GETIDX(4)], 1);

    EXPECT_EQ(molid[GETIDX(5)], 1);

    EXPECT_EQ(molid[GETIDX(6)], 1);

    EXPECT_EQ(molid[GETIDX(7)], 1);

    EXPECT_EQ(molid[GETIDX(8)], 1);

    EXPECT_EQ(molid[GETIDX(9)], 1);

    EXPECT_EQ(molid[GETIDX(10)], 1);

    EXPECT_EQ(molid[GETIDX(11)], 1);

    EXPECT_EQ(molid[GETIDX(12)], 1);

    EXPECT_EQ(molid[GETIDX(13)], 1);

    EXPECT_EQ(molid[GETIDX(14)], 1);

    EXPECT_EQ(molid[GETIDX(15)], 1);

    EXPECT_EQ(molid[GETIDX(16)], 1);

    EXPECT_EQ(molid[GETIDX(17)], 1);

    EXPECT_EQ(molid[GETIDX(18)], 2);

    EXPECT_EQ(molid[GETIDX(19)], 2);

    EXPECT_EQ(molid[GETIDX(20)], 2);

    EXPECT_EQ(molid[GETIDX(24)], 3);

    EXPECT_EQ(molid[GETIDX(25)], 3);

    EXPECT_EQ(molid[GETIDX(26)], 3);

    ASSERT_EQ(molid[GETIDX(1)], 1);

    ASSERT_EQ(molid[GETIDX(2)], 1);

    ASSERT_EQ(molid[GETIDX(3)], 1);

    ASSERT_EQ(molid[GETIDX(4)], 1);

    ASSERT_EQ(molid[GETIDX(5)], 1);

    ASSERT_EQ(molid[GETIDX(6)], 1);

    ASSERT_EQ(molid[GETIDX(7)], 1);

    ASSERT_EQ(molid[GETIDX(8)], 1);

    ASSERT_EQ(molid[GETIDX(9)], 1);

    ASSERT_EQ(molid[GETIDX(10)], 1);

    ASSERT_EQ(molid[GETIDX(11)], 1);

    ASSERT_EQ(molid[GETIDX(12)], 1);

    ASSERT_EQ(molid[GETIDX(13)], 1);

    ASSERT_EQ(molid[GETIDX(14)], 1);

    ASSERT_EQ(molid[GETIDX(15)], 1);

    ASSERT_EQ(molid[GETIDX(16)], 1);

    ASSERT_EQ(molid[GETIDX(17)], 1);

    ASSERT_EQ(molid[GETIDX(18)], 2);

    ASSERT_EQ(molid[GETIDX(19)], 2);

    ASSERT_EQ(molid[GETIDX(20)], 2);

    ASSERT_EQ(molid[GETIDX(24)], 3);

    ASSERT_EQ(molid[GETIDX(25)], 3);

    ASSERT_EQ(molid[GETIDX(26)], 3);



    // now also check and reset the atom ids



    EXPECT_GE(GETIDX(1), 0);

    EXPECT_GE(GETIDX(2), 0);

    EXPECT_GE(GETIDX(3), 0);

    EXPECT_GE(GETIDX(4), 0);

    EXPECT_GE(GETIDX(5), 0);

    EXPECT_GE(GETIDX(6), 0);

    EXPECT_GE(GETIDX(7), 0);

    EXPECT_GE(GETIDX(8), 0);

    EXPECT_GE(GETIDX(9), 0);

    EXPECT_GE(GETIDX(10), 0);

    EXPECT_GE(GETIDX(11), 0);

    EXPECT_GE(GETIDX(12), 0);

    EXPECT_GE(GETIDX(13), 0);

    EXPECT_GE(GETIDX(14), 0);

    EXPECT_GE(GETIDX(15), 0);

    EXPECT_GE(GETIDX(16), 0);

    EXPECT_GE(GETIDX(17), 0);

    EXPECT_GE(GETIDX(18), 0);

    EXPECT_GE(GETIDX(19), 0);

    EXPECT_GE(GETIDX(20), 0);

    EXPECT_EQ(GETIDX(21), -1);

    EXPECT_EQ(GETIDX(22), -1);

    EXPECT_EQ(GETIDX(23), -1);

    EXPECT_GE(GETIDX(24), 0);

    EXPECT_GE(GETIDX(25), 0);

    EXPECT_GE(GETIDX(26), 0);

    ASSERT_GE(GETIDX(1), 0);

    ASSERT_GE(GETIDX(2), 0);

    ASSERT_GE(GETIDX(3), 0);

    ASSERT_GE(GETIDX(4), 0);

    ASSERT_GE(GETIDX(5), 0);

    ASSERT_GE(GETIDX(6), 0);

    ASSERT_GE(GETIDX(7), 0);

    ASSERT_GE(GETIDX(8), 0);

    ASSERT_GE(GETIDX(9), 0);

    ASSERT_GE(GETIDX(10), 0);

    ASSERT_GE(GETIDX(11), 0);

    ASSERT_GE(GETIDX(12), 0);

    ASSERT_GE(GETIDX(13), 0);

    ASSERT_GE(GETIDX(14), 0);

    ASSERT_GE(GETIDX(15), 0);

    ASSERT_GE(GETIDX(16), 0);

    ASSERT_GE(GETIDX(17), 0);

    ASSERT_GE(GETIDX(18), 0);

    ASSERT_GE(GETIDX(19), 0);

    ASSERT_GE(GETIDX(20), 0);

    ASSERT_EQ(GETIDX(21), -1);

    ASSERT_EQ(GETIDX(22), -1);

    ASSERT_EQ(GETIDX(23), -1);

    ASSERT_GE(GETIDX(24), 0);

    ASSERT_GE(GETIDX(25), 0);

    ASSERT_GE(GETIDX(26), 0);



    if (!verbose) ::testing::internal::CaptureStdout();

    lmp->input->one("reset_atom_ids");
@@ -219,12 +219,253 @@ TEST_F(ResetIDsTest, DeletePlusAtomID) 


    ASSERT_EQ(lmp->atom->map_tag_max, 23);

    for (int i = 1; i <= 23; ++i)

        EXPECT_GE(GETIDX(i), 0);

        ASSERT_GE(GETIDX(i), 0);

}



// TEST_FAILURE(lmp->input->one("reset_mol_ids all"););

// ASSERT_THAT(mesg, MatchesRegex(".*ERROR: Unknown command.*"));

TEST_F(ResetIDsTest, PartialOffset)

{

    if (lmp->atom->natoms == 0) GTEST_SKIP();



    auto molid = lmp->atom->molecule;



    // delete two water molecules

    if (!verbose) ::testing::internal::CaptureStdout();

    lmp->input->one("group allwater molecule 3:6");

    lmp->input->one("group nowater subtract all allwater");

    lmp->input->one("reset_mol_ids allwater offset 4");

    if (!verbose) ::testing::internal::GetCapturedStdout();

    ASSERT_EQ(lmp->atom->natoms, 29);

    ASSERT_EQ(lmp->atom->map_tag_max, 29);



    ASSERT_EQ(molid[GETIDX(1)], 1);

    ASSERT_EQ(molid[GETIDX(2)], 1);

    ASSERT_EQ(molid[GETIDX(3)], 1);

    ASSERT_EQ(molid[GETIDX(4)], 1);

    ASSERT_EQ(molid[GETIDX(5)], 1);

    ASSERT_EQ(molid[GETIDX(6)], 1);

    ASSERT_EQ(molid[GETIDX(7)], 1);

    ASSERT_EQ(molid[GETIDX(8)], 2);

    ASSERT_EQ(molid[GETIDX(9)], 2);

    ASSERT_EQ(molid[GETIDX(10)], 2);

    ASSERT_EQ(molid[GETIDX(11)], 2);

    ASSERT_EQ(molid[GETIDX(12)], 2);

    ASSERT_EQ(molid[GETIDX(13)], 2);

    ASSERT_EQ(molid[GETIDX(14)], 2);

    ASSERT_EQ(molid[GETIDX(15)], 2);

    ASSERT_EQ(molid[GETIDX(16)], 2);

    ASSERT_EQ(molid[GETIDX(17)], 2);

    ASSERT_EQ(molid[GETIDX(18)], 5);

    ASSERT_EQ(molid[GETIDX(19)], 5);

    ASSERT_EQ(molid[GETIDX(20)], 5);

    ASSERT_EQ(molid[GETIDX(21)], 6);

    ASSERT_EQ(molid[GETIDX(22)], 6);

    ASSERT_EQ(molid[GETIDX(23)], 6);

    ASSERT_EQ(molid[GETIDX(24)], 7);

    ASSERT_EQ(molid[GETIDX(25)], 7);

    ASSERT_EQ(molid[GETIDX(26)], 7);

    ASSERT_EQ(molid[GETIDX(27)], 8);

    ASSERT_EQ(molid[GETIDX(28)], 8);

    ASSERT_EQ(molid[GETIDX(29)], 8);



    if (!verbose) ::testing::internal::CaptureStdout();

    lmp->input->one("reset_mol_ids nowater offset 0");

    if (!verbose) ::testing::internal::GetCapturedStdout();



    ASSERT_EQ(molid[GETIDX(1)], 1);

    ASSERT_EQ(molid[GETIDX(2)], 1);

    ASSERT_EQ(molid[GETIDX(3)], 1);

    ASSERT_EQ(molid[GETIDX(4)], 1);

    ASSERT_EQ(molid[GETIDX(5)], 1);

    ASSERT_EQ(molid[GETIDX(6)], 1);

    ASSERT_EQ(molid[GETIDX(7)], 1);

    ASSERT_EQ(molid[GETIDX(8)], 1);

    ASSERT_EQ(molid[GETIDX(9)], 1);

    ASSERT_EQ(molid[GETIDX(10)], 1);

    ASSERT_EQ(molid[GETIDX(11)], 1);

    ASSERT_EQ(molid[GETIDX(12)], 1);

    ASSERT_EQ(molid[GETIDX(13)], 1);

    ASSERT_EQ(molid[GETIDX(14)], 1);

    ASSERT_EQ(molid[GETIDX(15)], 1);

    ASSERT_EQ(molid[GETIDX(16)], 1);

    ASSERT_EQ(molid[GETIDX(17)], 1);

    ASSERT_EQ(molid[GETIDX(18)], 5);

    ASSERT_EQ(molid[GETIDX(19)], 5);

    ASSERT_EQ(molid[GETIDX(20)], 5);

    ASSERT_EQ(molid[GETIDX(21)], 6);

    ASSERT_EQ(molid[GETIDX(22)], 6);

    ASSERT_EQ(molid[GETIDX(23)], 6);

    ASSERT_EQ(molid[GETIDX(24)], 7);

    ASSERT_EQ(molid[GETIDX(25)], 7);

    ASSERT_EQ(molid[GETIDX(26)], 7);

    ASSERT_EQ(molid[GETIDX(27)], 8);

    ASSERT_EQ(molid[GETIDX(28)], 8);

    ASSERT_EQ(molid[GETIDX(29)], 8);

}



TEST_F(ResetIDsTest, DeleteAdd)

{

    if (lmp->atom->natoms == 0) GTEST_SKIP();



    auto molid = lmp->atom->molecule;



    // delete two water molecules

    if (!verbose) ::testing::internal::CaptureStdout();

    lmp->input->one("group allwater molecule 3:6");

    lmp->input->one("group twowater molecule 4:6:2");

    lmp->input->one("group nowater subtract all allwater");

    lmp->input->one("delete_atoms group twowater compress no bond yes mol yes");

    lmp->input->one("reset_mol_ids allwater offset auto");

    if (!verbose) ::testing::internal::GetCapturedStdout();

    ASSERT_EQ(lmp->atom->natoms, 23);

    ASSERT_EQ(lmp->atom->map_tag_max, 26);



    ASSERT_EQ(molid[GETIDX(1)], 1);

    ASSERT_EQ(molid[GETIDX(2)], 1);

    ASSERT_EQ(molid[GETIDX(3)], 1);

    ASSERT_EQ(molid[GETIDX(4)], 1);

    ASSERT_EQ(molid[GETIDX(5)], 1);

    ASSERT_EQ(molid[GETIDX(6)], 1);

    ASSERT_EQ(molid[GETIDX(7)], 1);

    ASSERT_EQ(molid[GETIDX(8)], 2);

    ASSERT_EQ(molid[GETIDX(9)], 2);

    ASSERT_EQ(molid[GETIDX(10)], 2);

    ASSERT_EQ(molid[GETIDX(11)], 2);

    ASSERT_EQ(molid[GETIDX(12)], 2);

    ASSERT_EQ(molid[GETIDX(13)], 2);

    ASSERT_EQ(molid[GETIDX(14)], 2);

    ASSERT_EQ(molid[GETIDX(15)], 2);

    ASSERT_EQ(molid[GETIDX(16)], 2);

    ASSERT_EQ(molid[GETIDX(17)], 2);

    ASSERT_EQ(molid[GETIDX(18)], 3);

    ASSERT_EQ(molid[GETIDX(19)], 3);

    ASSERT_EQ(molid[GETIDX(20)], 3);

    ASSERT_EQ(molid[GETIDX(24)], 4);

    ASSERT_EQ(molid[GETIDX(25)], 4);

    ASSERT_EQ(molid[GETIDX(26)], 4);



    // now also check and reset the atom ids



    ASSERT_GE(GETIDX(1), 0);

    ASSERT_GE(GETIDX(2), 0);

    ASSERT_GE(GETIDX(3), 0);

    ASSERT_GE(GETIDX(4), 0);

    ASSERT_GE(GETIDX(5), 0);

    ASSERT_GE(GETIDX(6), 0);

    ASSERT_GE(GETIDX(7), 0);

    ASSERT_GE(GETIDX(8), 0);

    ASSERT_GE(GETIDX(9), 0);

    ASSERT_GE(GETIDX(10), 0);

    ASSERT_GE(GETIDX(11), 0);

    ASSERT_GE(GETIDX(12), 0);

    ASSERT_GE(GETIDX(13), 0);

    ASSERT_GE(GETIDX(14), 0);

    ASSERT_GE(GETIDX(15), 0);

    ASSERT_GE(GETIDX(16), 0);

    ASSERT_GE(GETIDX(17), 0);

    ASSERT_GE(GETIDX(18), 0);

    ASSERT_GE(GETIDX(19), 0);

    ASSERT_GE(GETIDX(20), 0);

    ASSERT_EQ(GETIDX(21), -1);

    ASSERT_EQ(GETIDX(22), -1);

    ASSERT_EQ(GETIDX(23), -1);

    ASSERT_GE(GETIDX(24), 0);

    ASSERT_GE(GETIDX(25), 0);

    ASSERT_GE(GETIDX(26), 0);



    if (!verbose) ::testing::internal::CaptureStdout();

    lmp->input->one("reset_atom_ids sort yes");

    if (!verbose) ::testing::internal::GetCapturedStdout();



    ASSERT_EQ(lmp->atom->map_tag_max, 23);

    for (int i = 1; i <= 23; ++i)

        ASSERT_GE(GETIDX(i), 0);



    if (!verbose) ::testing::internal::CaptureStdout();

    lmp->input->one("reset_mol_ids nowater offset 1");

    if (!verbose) ::testing::internal::GetCapturedStdout();



    EXPECT_EQ(molid[GETIDX(1)], 2);

    EXPECT_EQ(molid[GETIDX(2)], 2);

    EXPECT_EQ(molid[GETIDX(3)], 2);

    EXPECT_EQ(molid[GETIDX(4)], 2);

    EXPECT_EQ(molid[GETIDX(5)], 2);

    EXPECT_EQ(molid[GETIDX(6)], 2);

    EXPECT_EQ(molid[GETIDX(7)], 2);

    EXPECT_EQ(molid[GETIDX(8)], 2);

    EXPECT_EQ(molid[GETIDX(9)], 2);

    EXPECT_EQ(molid[GETIDX(10)], 2);

    EXPECT_EQ(molid[GETIDX(11)], 2);

    EXPECT_EQ(molid[GETIDX(12)], 2);

    EXPECT_EQ(molid[GETIDX(13)], 3);

    EXPECT_EQ(molid[GETIDX(14)], 3);

    EXPECT_EQ(molid[GETIDX(15)], 3);

    EXPECT_EQ(molid[GETIDX(16)], 2);

    EXPECT_EQ(molid[GETIDX(17)], 2);

    EXPECT_EQ(molid[GETIDX(18)], 2);

    EXPECT_EQ(molid[GETIDX(19)], 2);

    EXPECT_EQ(molid[GETIDX(20)], 2);

    EXPECT_EQ(molid[GETIDX(21)], 4);

    EXPECT_EQ(molid[GETIDX(22)], 4);

    EXPECT_EQ(molid[GETIDX(23)], 4);



    if (!verbose) ::testing::internal::CaptureStdout();

    lmp->input->one("create_atoms 1 single 0.0 0.0 0.0");

    lmp->input->one("create_atoms 2 single 1.0 0.0 0.0");

    lmp->input->one("create_atoms 3 single 2.0 0.0 0.0");

    lmp->input->one("create_atoms 4 single 3.0 0.0 0.0");

    lmp->input->one("reset_mol_ids all");

    if (!verbose) ::testing::internal::GetCapturedStdout();

    EXPECT_EQ(lmp->atom->natoms, 27);

    EXPECT_EQ(lmp->atom->map_tag_max, 27);



    EXPECT_EQ(molid[GETIDX(21)], 3);

    EXPECT_EQ(molid[GETIDX(22)], 3);

    EXPECT_EQ(molid[GETIDX(23)], 3);

    EXPECT_EQ(molid[GETIDX(24)], 4);

    EXPECT_EQ(molid[GETIDX(25)], 5);

    EXPECT_EQ(molid[GETIDX(26)], 6);

    EXPECT_EQ(molid[GETIDX(27)], 7);



    if (!verbose) ::testing::internal::CaptureStdout();

    lmp->input->one("reset_mol_ids all singlezero");

    if (!verbose) ::testing::internal::GetCapturedStdout();



    EXPECT_EQ(molid[GETIDX(21)], 3);

    EXPECT_EQ(molid[GETIDX(22)], 3);

    EXPECT_EQ(molid[GETIDX(23)], 3);

    EXPECT_EQ(molid[GETIDX(24)], 0);

    EXPECT_EQ(molid[GETIDX(25)], 0);

    EXPECT_EQ(molid[GETIDX(26)], 0);

    EXPECT_EQ(molid[GETIDX(27)], 0);

}



TEST_F(ResetIDsTest, DeathTests)

{

    ::testing::internal::CaptureStdout();

    TEST_FAILURE(lmp->input->one("reset_mol_ids"););

    auto mesg = ::testing::internal::GetCapturedStdout();

    ASSERT_THAT(mesg, MatchesRegex(".*ERROR: Illegal reset_mol_ids command.*"));



    ::testing::internal::CaptureStdout();

    TEST_FAILURE(lmp->input->one("reset_mol_ids all offset 1 1"););

    mesg = ::testing::internal::GetCapturedStdout();

    ASSERT_THAT(mesg, MatchesRegex(".*ERROR: Illegal reset_mol_ids command.*"));



    ::testing::internal::CaptureStdout();

    TEST_FAILURE(lmp->input->one("reset_mol_ids all offset -2"););

    mesg = ::testing::internal::GetCapturedStdout();

    ASSERT_THAT(mesg, MatchesRegex(".*ERROR: Illegal reset_mol_ids command.*"));



    ::testing::internal::CaptureStdout();

    TEST_FAILURE(lmp->input->one("reset_mol_ids all offset xxx"););

    mesg = ::testing::internal::GetCapturedStdout();

    ASSERT_THAT(mesg, MatchesRegex(".*ERROR on proc 0: Expected integer.*"));



    ::testing::internal::CaptureStdout();

    TEST_FAILURE(lmp->input->one("reset_mol_ids all offset"););

    mesg = ::testing::internal::GetCapturedStdout();

    ASSERT_THAT(mesg, MatchesRegex(".*ERROR: Illegal reset_mol_ids command.*"));

}

} // namespace LAMMPS_NS



int main(int argc, char **argv)

CRA Git | Maintained and supported by SUSTech CRA and CCSE