1 package compbio.runner.structure;
\r
3 import static org.testng.Assert.assertFalse;
\r
4 import static org.testng.Assert.assertNotNull;
\r
5 import static org.testng.Assert.assertTrue;
\r
6 import static org.testng.Assert.fail;
\r
9 import java.io.FileInputStream;
\r
10 import java.io.FileNotFoundException;
\r
11 import java.io.IOException;
\r
12 import java.util.ArrayList;
\r
13 import java.util.Collections;
\r
14 import java.util.List;
\r
15 import java.util.Map;
\r
17 import javax.xml.bind.JAXBException;
\r
18 import javax.xml.bind.ValidationException;
\r
20 import org.apache.log4j.Level;
\r
21 import org.apache.log4j.Logger;
\r
22 import org.testng.annotations.BeforeMethod;
\r
23 import org.testng.annotations.Test;
\r
25 import compbio.data.sequence.RNAStructScoreManager;
\r
26 import compbio.data.sequence.ScoreManager;
\r
27 import compbio.engine.Configurator;
\r
28 import compbio.engine.client.ConfiguredExecutable;
\r
29 import compbio.engine.client.Executable.ExecProvider;
\r
30 import compbio.engine.conf.RunnerConfigMarshaller;
\r
31 import compbio.engine.local.ExecutableWrapper;
\r
32 import compbio.engine.local.LocalRunner;
\r
33 import compbio.metadata.AllTestSuit;
\r
34 import compbio.metadata.JobExecutionException;
\r
35 import compbio.metadata.JobSubmissionException;
\r
36 import compbio.metadata.Option;
\r
37 import compbio.metadata.Parameter;
\r
38 import compbio.metadata.Preset;
\r
39 import compbio.metadata.PresetManager;
\r
40 import compbio.metadata.ResultNotAvailableException;
\r
41 import compbio.metadata.RunnerConfig;
\r
42 import compbio.runner.OptionCombinator;
\r
43 import compbio.runner.structure.RNAalifold;
\r
44 import compbio.util.FileUtil;
\r
47 public class RNAalifoldParametersTester {
\r
50 // should be: AllTestSuit.TEST_DATA_PATH + "RNAalifoldParameters.xml"
\r
51 static final String rnaalifoldConfigFile =
\r
52 AllTestSuit.TEST_DATA_PATH + "RNAalifoldParameters.xml";
\r
53 public static String test_outfile = "rnaalifold.out.txt";
\r
55 private static Logger log = Logger
\r
56 .getLogger(AllTestSuit.RUNNER_TEST_LOGGER);
\r
59 log.setLevel(Level.INFO);
\r
62 RunnerConfig<RNAalifold> rnaalifoldConfig = null;
\r
63 OptionCombinator rnaalifoldOpc = null;
\r
65 @BeforeMethod(groups = { AllTestSuit.test_group_runner })
\r
66 @SuppressWarnings("unchecked")
\r
67 public void setup() {
\r
69 RunnerConfigMarshaller<RNAalifold> rnaalifoldmarsh =
\r
70 new RunnerConfigMarshaller<RNAalifold>(RunnerConfig.class);
\r
71 rnaalifoldConfig = rnaalifoldmarsh.read(new FileInputStream(new File(
\r
72 rnaalifoldConfigFile)), RunnerConfig.class);
\r
73 // set Name value separator
\r
74 rnaalifoldConfig.setPrmSeparator(" ");
\r
75 rnaalifoldOpc = new OptionCombinator(rnaalifoldConfig);
\r
79 } catch (JAXBException e) {
\r
80 e.printStackTrace();
\r
81 fail(e.getLocalizedMessage());
\r
82 } catch (FileNotFoundException e) {
\r
83 e.printStackTrace();
\r
84 fail(e.getLocalizedMessage());
\r
89 public void testConfiguration() {
\r
91 this.rnaalifoldConfig.validate();
\r
92 } catch (ValidationException e) {
\r
93 e.printStackTrace();
\r
94 fail(e.getLocalizedMessage());
\r
95 } catch (IllegalStateException e) {
\r
96 e.printStackTrace();
\r
97 fail(e.getLocalizedMessage());
\r
101 @Test(groups = { AllTestSuit.test_group_runner })
\r
102 public void testDefaultParameters() {
\r
103 RNAalifold rnaalifold = new RNAalifold();
\r
104 rnaalifold.setInput(AllTestSuit.test_input_aln).setOutput(test_outfile);
\r
107 // For local execution use relavive
\r
108 ConfiguredExecutable<RNAalifold> confRNAalifold = Configurator
\r
109 .configureExecutable(rnaalifold);
\r
110 LocalRunner lr = new LocalRunner(confRNAalifold);
\r
112 confRNAalifold = (ConfiguredExecutable<RNAalifold>) lr.waitForResult();
\r
113 assertNotNull(confRNAalifold.getResults());
\r
114 } catch (JobSubmissionException e) {
\r
115 e.printStackTrace();
\r
116 fail(e.getLocalizedMessage());
\r
117 } catch (JobExecutionException e) {
\r
118 e.printStackTrace();
\r
119 fail(e.getLocalizedMessage());
\r
120 } catch (ResultNotAvailableException e) {
\r
121 e.printStackTrace();
\r
122 fail(e.getLocalizedMessage());
\r
129 public void testOptions() {
\r
130 // populate list of incompatable pairs by their names. todo
\r
131 List<List<String>> failPairs = new ArrayList<List<String>>();
\r
134 // test the parameters without -g option
\r
135 test(removeParam(rnaalifoldOpc.getAllOptions(), "G-Quadruplex"));
\r
136 // now test without -c option
\r
137 test(removeParam(rnaalifoldOpc.getAllOptions(), "Circular"));
\r
141 // Prints all the incompatible option pairs
\r
142 // (-c, -g) and (-p, -p0)
\r
145 public void testOptionPairs() throws ResultNotAvailableException {
\r
146 List<Option<?>> pair = new ArrayList<Option<?>>();
\r
147 List<Option<?>> options = rnaalifoldOpc.getAllOptions();
\r
148 List<List<String>> failedOptionPairs = new ArrayList<List<String>>();
\r
150 boolean failed = true;
\r
151 for (int i = 0; i<options.size(); i++) {
\r
152 for (int j = i; j<options.size(); j++) {
\r
155 pair.add(options.get(i)); pair.add(options.get(j));
\r
156 List<String> args = rnaalifoldOpc.argumentsToCommandString(pair);
\r
158 failed = singleRun(args);
\r
159 } catch (ResultNotAvailableException e) {
\r
160 System.out.println("Results not available: " + e.getMessage());
\r
162 } catch (JobSubmissionException e) {
\r
163 e.printStackTrace();
\r
164 fail(e.getLocalizedMessage());
\r
165 } catch (JobExecutionException e) {
\r
166 e.printStackTrace();
\r
167 fail(e.getLocalizedMessage());
\r
168 } catch (IOException e) {
\r
169 e.printStackTrace();
\r
170 fail(e.getLocalizedMessage());
\r
172 if (failed == true) {
\r
173 failedOptionPairs.add(args);
\r
178 System.out.println("failedOptionPairs: " + failedOptionPairs);
\r
182 // tests for incompatible Pairs of Parameters
\r
183 // there are none however the --betascale parameter requires -p
\r
186 public void testParameterPairs() throws ResultNotAvailableException {
\r
187 List<Parameter<?>> pair = new ArrayList<Parameter<?>>();
\r
188 List<Parameter<?>> Parameters = rnaalifoldOpc.getAllParameters();
\r
189 List<List<String>> failedParameterPairs = new ArrayList<List<String>>();
\r
192 boolean failed = true;
\r
193 for (int i = 0; i<Parameters.size(); i++) {
\r
194 for (int j = i; j<Parameters.size(); j++) {
\r
197 pair.add(Parameters.get(i)); pair.add(Parameters.get(j));
\r
198 List<String> args = rnaalifoldOpc.argumentsToCommandString(pair);
\r
199 args.add("-p"); // --betascale requires -p
\r
201 failed = singleRun(args);
\r
202 } catch (ResultNotAvailableException e) {
\r
203 System.out.println("Results not available: " + e.getMessage());
\r
205 } catch (JobSubmissionException e) {
\r
206 e.printStackTrace();
\r
207 fail(e.getLocalizedMessage());
\r
208 } catch (JobExecutionException e) {
\r
209 e.printStackTrace();
\r
210 fail(e.getLocalizedMessage());
\r
211 } catch (IOException e) {
\r
212 e.printStackTrace();
\r
213 fail(e.getLocalizedMessage());
\r
215 if (failed == true) {
\r
216 failedParameterPairs.add(args);
\r
221 System.out.println("failedParameterPairs: " + failedParameterPairs);
\r
226 // removes an argument from the list by name
\r
227 public <U extends Option<?>> List<U> removeParam(List<U> optionList, String name) {
\r
228 List<U> newL = new ArrayList<U>();
\r
229 for (int i = 0; i < optionList.size(); i++) {
\r
230 System.out.println(name.equals(optionList.get(i).getName()));
\r
231 if (!name.equals(optionList.get(i).getName())) {
\r
233 newL.add(optionList.get(i));
\r
240 public <U extends Option<?>> List<U> removeParams(List<U> optionList, List<String> names) {
\r
241 for (int i = 0; i < names.size(); i++) {
\r
242 optionList = removeParam(optionList, names.get(i));
\r
248 @Test(groups = { AllTestSuit.test_group_runner })
\r
249 public void testParameters() {
\r
250 List<Parameter<?>> params = rnaalifoldOpc.getAllParameters();
\r
251 System.out.println("param list: " + params);
\r
252 Collections.shuffle(params);
\r
253 // test with -p for betascale option
\r
254 List<String> precursor = new ArrayList<String>();
\r
255 precursor.add("-p");
\r
257 test(params, precursor);
\r
260 // incompatible pairs of arguments are
\r
262 * the -c and -g options
\r
263 * the -d2 option and the -d option
\r
264 * the -p and -p0 option
\r
267 @Test(groups = { AllTestSuit.test_group_runner })
\r
268 public void testArguments() {
\r
269 List<Option<?>> options = rnaalifoldOpc.getAllOptions();
\r
270 options.addAll(rnaalifoldOpc.getAllParameters());
\r
271 Collections.shuffle(options);
\r
275 // This test supercedes the testParameterPair() and testOptionPair()
\r
276 // tests by testing all pairs of arguments
\r
280 public void testAllPairs() throws ResultNotAvailableException {
\r
281 List<Option<?>> pair = new ArrayList<Option<?>>();
\r
282 List<Option<?>> options = rnaalifoldOpc.getAllOptions();
\r
284 // take out -p options so it can be added to all commands later
\r
285 // options = removeParam(options, "Partition Function");
\r
287 options.addAll(rnaalifoldOpc.getAllParameters());
\r
288 List<List<String>> failedOptionPairs = new ArrayList<List<String>>();
\r
290 boolean failed = true;
\r
291 for (int i = 0; i<options.size(); i++) {
\r
292 for (int j = i; j<options.size(); j++) {
\r
295 pair.add(options.get(i)); pair.add(options.get(j));
\r
296 List<String> args = rnaalifoldOpc.argumentsToCommandString(pair);
\r
300 failed = singleRun(args);
\r
301 } catch (ResultNotAvailableException e) {
\r
302 System.out.println("Results not available: " + e.getMessage());
\r
304 } catch (JobSubmissionException e) {
\r
305 e.printStackTrace();
\r
306 fail(e.getLocalizedMessage());
\r
307 } catch (JobExecutionException e) {
\r
308 e.printStackTrace();
\r
309 fail(e.getLocalizedMessage());
\r
310 } catch (IOException e) {
\r
311 e.printStackTrace();
\r
312 fail(e.getLocalizedMessage());
\r
314 if (failed == true) {
\r
315 failedOptionPairs.add(args);
\r
320 System.out.println("failedOptionPairs: " + failedOptionPairs);
\r
324 * This test method stolen from the other parameter testing classes
\r
325 * the only purpose of the Collections.shuffle(params) and the for loop
\r
326 * is to test giving the executable the parameters in different orders
\r
327 * which leads to a lot of (unnecessary?) tests with an argument list
\r
328 * as long as this one.
\r
333 void test(List<? extends Option<?>> params) {
\r
334 for (int i = 0; i < params.size(); i++) {
\r
335 List<String> args = rnaalifoldOpc.argumentsToCommandString(params);
\r
337 Collections.shuffle(params);
\r
339 log.info("NUMBER OF COMBINATION TESTED: " + params.size());
\r
342 // because some parameters presuppose the -p option
\r
344 void test(List<? extends Option<?>> params, List<String> precursor) {
\r
346 for (int i = 0; i < params.size(); i++) {
\r
347 List<String> args = rnaalifoldOpc.argumentsToCommandString(params);
\r
348 args.addAll(precursor);
\r
350 Collections.shuffle(params);
\r
352 log.info("NUMBER OF COMBINATION TESTED: " + params.size());
\r
355 void singleParamTest() {
\r
356 //List<Parameter<?>> params = rnaalifoldOpc.getAllParameters();
\r
357 //System.out.println("special: params: " + params);
\r
359 //List<String> args = rnaalifoldOpc.argumentsToCommandString(params);
\r
360 List<String> args = new ArrayList<String>();
\r
361 //args.add("-T 37"); args.add("-S 1.07"); args.add("--stochBT_en 10");
\r
362 // replace "=" with " " to fail test
\r
363 args.add("--MEA=1");
\r
369 void singleTest(List<String> params) {
\r
371 log.info("Using arguments: " + params);
\r
372 RNAalifold rnaalifold = new RNAalifold();
\r
373 rnaalifold.setInput(AllTestSuit.test_input_aln).setOutput(test_outfile);
\r
375 ConfiguredExecutable<RNAalifold> confRNAalifold = Configurator
\r
376 .configureExecutable(rnaalifold, ExecProvider.Local);
\r
377 // Add options to the executable
\r
378 confRNAalifold.addParameters(params);
\r
379 LocalRunner lr = new LocalRunner(confRNAalifold);
\r
381 confRNAalifold = (ConfiguredExecutable<RNAalifold>) lr.waitForResult();
\r
382 assertNotNull(confRNAalifold.getResults(), "results is null");
\r
384 System.out.println("Results: \n"
\r
385 + ((RNAStructScoreManager) confRNAalifold.getResults()).toString());
\r
387 File errors = new File(confRNAalifold.getWorkDirectory(),
\r
388 ExecutableWrapper.PROC_ERR_FILE);
\r
389 if (errors.length() != 0) {
\r
390 log.error("PROBLEMS:\n " + FileUtil.readFileToString(errors));
\r
392 assertTrue(errors.length() == 0, "Run with arguments : " + params
\r
394 Collections.shuffle(params);
\r
395 } catch (JobSubmissionException e) {
\r
396 e.printStackTrace();
\r
397 fail(e.getLocalizedMessage());
\r
398 } catch (JobExecutionException e) {
\r
399 e.printStackTrace();
\r
400 fail(e.getLocalizedMessage());
\r
401 } catch (IOException e) {
\r
402 e.printStackTrace();
\r
403 fail(e.getLocalizedMessage());
\r
404 } catch (ResultNotAvailableException e) {
\r
405 e.printStackTrace();
\r
406 fail(e.getLocalizedMessage());
\r
410 /* A version of singleTest that continues running instead of calling
\r
411 * fail() when it encounters a problem
\r
413 * Used to identify incompatible options and parameters
\r
414 * returns -1 on failure
\r
416 * Bad Progamming practice?
\r
420 boolean singleRun(List<String> params) throws JobSubmissionException,
\r
421 JobExecutionException, IOException, ResultNotAvailableException {
\r
422 boolean fail = true;
\r
423 log.info("Using arguments: " + params);
\r
424 RNAalifold rnaalifold = new RNAalifold();
\r
425 rnaalifold.setInput(AllTestSuit.test_input_aln).setOutput(test_outfile);
\r
427 ConfiguredExecutable<RNAalifold> confRNAalifold = Configurator
\r
428 .configureExecutable(rnaalifold, ExecProvider.Local);
\r
429 // Add options to the executable
\r
430 confRNAalifold.addParameters(params);
\r
431 LocalRunner lr = new LocalRunner(confRNAalifold);
\r
433 confRNAalifold = (ConfiguredExecutable<RNAalifold>) lr.waitForResult();
\r
435 System.out.println("Results: \n"
\r
436 + ((RNAStructScoreManager) confRNAalifold.getResults()).toString());
\r
437 if (confRNAalifold.getResults() != null) fail = false;
\r
438 File errors = new File(confRNAalifold.getWorkDirectory(),
\r
439 ExecutableWrapper.PROC_ERR_FILE);
\r
440 if (errors.length() != 0) {
\r
441 log.error("PROBLEMS:\n " + FileUtil.readFileToString(errors));
\r
443 assertTrue(errors.length() == 0, "Run with arguments : " + params
\r
445 Collections.shuffle(params);
\r