Python md_common.silent_remove函数代码示例

 def testCheckCharge(self):
     try:
         with capture_stdout(main, ["-c", CHECK_CHARGE_INI]) as output:
             self.assertFalse("total charge" in output)
     finally:
         silent_remove(VMD_OUT)
         silent_remove(WATER_OUT)

 def testDefInp(self):
     try:
         with capture_stdout(main, ["-f", DEF_INPUT]) as output:
             self.assertTrue(GOOD_OUT in output)
             self.assertFalse(diff_lines(CSV_OUT, GOOD_CSV_OUT))
     finally:
         silent_remove(CSV_OUT, disable=DISABLE_REMOVE)

 def testDefInp(self):
     try:
         with capture_stdout(main, ["-f", DEF_INPUT, "-c", DEF_INI]) as output:
             self.assertTrue("Keeping 2 of 4 rows based on filtering criteria" in output)
         self.assertFalse(diff_lines(CSV_OUT, GOOD_CSV_OUT))
     finally:
         silent_remove(CSV_OUT)

 def testTplDumpMismatch(self):
     try:
         with capture_stderr(evbdump2data.main, ["-c", TPL_DUMP_MISMATCH_INI]) as output:
             self.assertTrue("listed number of atoms (214084) does not equal the number of atoms in the "
                             "template data file (1429)" in output)
     finally:
         silent_remove(REPROD_TPL)

 def testIncompDump(self):
     try:
         with capture_stderr(main, ["-c", INCOMP_DUMP_INI_PATH]) as output:
             self.assertTrue("WARNING" in output)
         self.assertFalse(diff_lines(DEF_GOFR_INCOMP_OUT, GOOD_HO_GOFR_OUT_PATH))
     finally:
         silent_remove(DEF_GOFR_INCOMP_OUT, disable=DISABLE_REMOVE)

 def testMaxTimestepsCalcHIJ(self):
     try:
         with capture_stdout(main, ["-c", HIJ_INI]) as output:
             self.assertTrue("Reached the maximum timesteps" in output)
         self.assertFalse(diff_lines(HIJ_OUT, GOOD_HIJ_OUT))
     finally:
         silent_remove(HIJ_OUT, disable=DISABLE_REMOVE)

 def testGlu(self):
     try:
         data2pdb.main(["-c", GLU_INI])
         self.assertFalse(diff_lines(GLU_OUT, GOOD_GLU_OUT))
     finally:
         silent_remove(PDB_TPL_OUT)
         silent_remove(GLU_OUT)

 def testDefInp(self):
     test_input = ["-c", DEF_INI, "-f", DEF_INPUT]
     try:
         main(test_input)
         self.assertFalse(diff_lines(DEF_OUT, GOOD_OUT))
     finally:
         silent_remove(DEF_OUT, disable=DISABLE_REMOVE)

 def testWaterMolCombine(self):
     # Should skip the timestep with only 1 state
     try:
         main(["-c", WATER_MOL_COMB_INI])
         self.assertFalse(diff_lines(WATER_MOL_COMB_OUT, GOOD_WATER_MOL_COMB_OUT))
     finally:
         silent_remove(WATER_MOL_COMB_OUT)

 def testEmreAddElements(self):
     # As above, but a larger/different PDB
     try:
         main(["-c", EMRE_ADD_ELEMENT_INI])
         self.assertFalse(diff_lines(EMRE_ADD_ELEMENT_OUT, GOOD_EMRE_ADD_ELEMENT_OUT))
     finally:
         silent_remove(EMRE_ADD_ELEMENT_OUT)

 def testSortFromLammps(self):
     try:
         main(["-c", SORT_FROM_LAMMPS_INI])
         self.assertFalse(diff_lines(SORT_FROM_LAMMPS, SORT_FROM_LAMMPS_GOOD))
         self.assertFalse(diff_lines(SELECT_FROM_LAMMPS, SELECT_FROM_LAMMPS_GOOD))
     finally:
         silent_remove(SORT_FROM_LAMMPS, disable=DISABLE_REMOVE)
         silent_remove(SELECT_FROM_LAMMPS, disable=DISABLE_REMOVE)

 def testBadInput(self):
     # Test what happens when cannot convert a value to float
     try:
         with capture_stderr(main, ["-f", BAD_INPUT]) as output:
             self.assertTrue("could not be converted to a float" in output)
             self.assertFalse(diff_lines(BAD_INPUT_OUT, GOOD_BAD_INPUT_OUT))
     finally:
         silent_remove(BAD_INPUT_OUT, disable=DISABLE_REMOVE)

 def testBinMax2(self):
     # In this input, both bins have more than the max entries
     test_input = ["-f", BIN_INPUT, "-c", BIN_MAX2_INI]
     try:
         main(test_input)
         self.assertFalse(diff_lines(DEF_BIN_OUT, GOOD_BIN_MAX2_OUT))
     finally:
         silent_remove(DEF_BIN_OUT, disable=DISABLE_REMOVE)

 def testBinMax(self):
     # In this input, one big has more than the max and one less
     test_input = ["-f", BIN_INPUT, "-c", BIN_MAX_INI]
     try:
         main(test_input)
         # self.assertFalse(diff_lines(DEF_BIN_OUT, GOOD_BIN_MAX_OUT))
     finally:
         silent_remove(DEF_BIN_OUT, disable=DISABLE_REMOVE)

 def testReorderAtoms(self):
     try:
         with capture_stdout(main, ["-c", DEF_INI]) as output:
             for message in WATER_OUT_OF_ORDER_MESSAGES:
                 self.assertFalse(message in output)
         self.assertFalse(diff_lines(DEF_OUT, GOOD_OUT))
     finally:
         silent_remove(DEF_OUT)