def testWrongFileToFilter(self):
     # If put a configuration file as the file to read, fail well
     test_input = ["-f", DEF_INI, "-c", DEF_INI]
     if logger.isEnabledFor(logging.DEBUG):
         main(test_input)
     with capture_stderr(main, test_input) as output:
         self.assertTrue("could not convert string" in output)

 def testBinTooMany(self):
     test_input = ["-f", DEF_INPUT, "-c", BIN_TOO_MANY_INI]
     if logger.isEnabledFor(logging.DEBUG):
         main(test_input)
     with capture_stderr(main, test_input) as output:
         self.assertTrue("Expected a comma-separated list of length 3 or 4 for section 'bin_settings' key 'cv'. "
                         "Read: 0.5,0.7,2,6,10" in output)

 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 testFindNoWatH(self):
     test_input = ["-c", WRONG_WAT_H_TYPE_INI]
     if logger.isEnabledFor(logging.DEBUG):
         main(test_input)
     with capture_stderr(main, test_input) as output:
         self.assertTrue(WAT_H_TYPE in output)
         self.assertTrue("no such atoms were found" in output)

 def testNotIni(self):
     # gracefully fail if give the wrong file to the -c option
     test_input = ["-c", NOT_INI]
     if logger.isEnabledFor(logging.DEBUG):
         main(test_input)
     with capture_stderr(main, test_input) as output:
         self.assertTrue("WARNING:  File contains no section headers" in output)

 def testSubsetCiInfo(self):
     with capture_stderr(main, ["-c", CI_SUBSET_INI]) as output:
         self.assertTrue("found no data from" in output)
         self.assertFalse(diff_lines(DEF_CI_SUBSET_OUT, GOOD_CI_SUBSET_OUT))
         silent_remove(DEF_CI_SUBSET_OUT)
         silent_remove(DEF_CI_OUT1)
         silent_remove(DEF_CI_OUT2)

 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 testNoSuchOption(self):
     # main(["[email protected]", DEF_OUT])
     with capture_stderr(main, ["[email protected]", DEF_OUT]) as output:
         self.assertTrue("unrecognized argument" in output)
         self.assertTrue(DEF_OUT in output)
     with capture_stdout(main, ["[email protected]", DEF_OUT]) as output:
         self.assertTrue("optional arguments" in output)

 def testNoArgs(self):
     test_input = []
     if logger.isEnabledFor(logging.DEBUG):
         main(test_input)
     with capture_stderr(main, test_input) as output:
         self.assertTrue("Could not read file" in output)
     with capture_stdout(main, test_input) as output:
         self.assertTrue("optional arguments" in output)

 def testParseError(self):
     # This input has a line with only "z" (no equals), resulting in a parsing error we will catch
     test_input = ["-f", DEF_INPUT, "-c", PARSE_ERROR_INI]
     if logger.isEnabledFor(logging.DEBUG):
         main(test_input)
     with capture_stderr(main, test_input) as output:
         self.assertTrue("File contains parsing errors" in output)
         self.assertTrue("'z" in output)

 def testMissingInfo(self):
     test_input = ["-c", INCOMP_INI]
     if logger.isEnabledFor(logging.DEBUG):
         main(test_input)
     with capture_stderr(main, test_input) as output:
         self.assertTrue("Missing config val for key 'prot_res_mol_id'" in output)
     with capture_stdout(main, test_input) as output:
         self.assertTrue("optional arguments" in output)

 def testNoIni(self):
     test_input = []
     if logger.isEnabledFor(logging.DEBUG):
         main(test_input)
     with capture_stdout(main, test_input) as output:
         self.assertTrue("usage:" in output)
     with capture_stderr(main, test_input) as output:
         self.assertTrue("Problems reading file: Could not read file" in output)

 def testDupCol(self):
     test_input = ["-f", DUP_COL_CMP_LIST]
     if logger.isEnabledFor(logging.DEBUG):
         main(test_input)
     with capture_stderr(main, test_input) as output:
         self.assertFalse(diff_lines(DEF_OUT, GOOD_OUT))
         self.assertTrue("Non-unique column" in output)
     silent_remove(DEF_OUT, disable=DISABLE_REMOVE)

 def testAddNothing(self):
     # this first test does not really doing anything, and warns the user
     try:
         with capture_stderr(main, [INPUT_PATH]) as output:
             self.assertTrue("Return file will be the same as the input" in output)
         self.assertFalse(diff_lines(INPUT_PATH, DEF_OUT_PATH))
     finally:
         silent_remove(DEF_OUT_PATH)

 def testCompDihAlt(self):
     # Test it is okay with sections in the 1st but not 2nd file
     with capture_stderr(main, ["-c", COMP_DIH_ALT_INI]) as output:
         self.assertTrue("WARNING:  Skipping section" in output)
     try:
         self.assertFalse(diff_lines(COMP_DIH_ALT_OUT, COMP_DIH_ALT_OUT_GOOD))
     finally:
         silent_remove(COMP_DIH_ALT_OUT, disable=DISABLE_REMOVE)

 def testHelp(self):
     test_input = ['-h']
     if logger.isEnabledFor(logging.DEBUG):
         main(test_input)
     with capture_stderr(main, test_input) as output:
         self.assertFalse(output)
     with capture_stdout(main, test_input) as output:
         self.assertTrue("optional arguments" in output)

 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 testMissingConfig(self):
     test_input = ["-c", INCOMP_INI_PATH]
     if logger.isEnabledFor(logging.DEBUG):
         main(test_input)
     with capture_stderr(main, test_input) as output:
         self.assertTrue("Missing config val for key 'water_o_type'" in output)
     with capture_stdout(main, test_input) as output:
         self.assertTrue("optional arguments" in output)

 def testGluBadDump(self):
     # main(["-c", GLU_BAD_DATA_INI])
     try:
         with capture_stderr(main, ["-c", GLU_BAD_DATA_INI]) as output:
             self.assertTrue("Problems reading data: Unexpected line in file tests/test_data/evbd2d/glu_bad.dump: "
                             "ITEM: XYZ MS id mol type q x y z" in output)
     finally:
         silent_remove(REPROD_TPL)

 def testNoHydData(self):
     """
     Because the types do not match the data file, did not find the molecules desired.
     """
     evbdump2data.main(["-c", GLU_BAD_ATOM_TYPE_INI])
     with capture_stderr(evbdump2data.main, ["-c", GLU_BAD_ATOM_TYPE_INI]) as output:
         self.assertTrue("Check the data file" in output)
     silent_remove(REPROD_TPL)