testsrc/compbio/runner/structure/RNAalifoldParametersTester.java

   1 package compbio.runner.structure;\r
   2 \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
   7 \r
   8 import java.io.File;\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
  16 \r
  17 import javax.xml.bind.JAXBException;\r
  18 import javax.xml.bind.ValidationException;\r
  19 \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
  24 \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
  45 \r
  46 \r
  47 public class RNAalifoldParametersTester {\r
  48 \r
  49         \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
  54 \r
  55         private static Logger log = Logger\r
  56                         .getLogger(AllTestSuit.RUNNER_TEST_LOGGER);\r
  57         \r
  58         static {\r
  59                 log.setLevel(Level.INFO);\r
  60         }\r
  61         \r
  62         RunnerConfig<RNAalifold> rnaalifoldConfig = null;\r
  63         OptionCombinator rnaalifoldOpc = null;\r
  64         \r
  65         @BeforeMethod(groups = { AllTestSuit.test_group_runner })\r
  66         @SuppressWarnings("unchecked")\r
  67         public void setup() {\r
  68                 try {\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
  76                         \r
  77                         \r
  78                         \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
  85                 }\r
  86         }\r
  87         \r
  88         @Test\r
  89         public void testConfiguration() {\r
  90                 try {\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
  98                 }\r
  99         }\r
 100 \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
 105 \r
 106                 try {\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
 111                         lr.executeJob();\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
 123                 }\r
 124         }\r
 125         \r
 126         \r
 127         \r
 128         @Test\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
 132 \r
 133                 \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
 138         }\r
 139         \r
 140 \r
 141         // Prints all the incompatible option pairs \r
 142         // (-c, -g) and (-p, -p0)\r
 143         \r
 144         @Test\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
 149                 \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
 153                                 if (i != j) {\r
 154                                         pair.clear();\r
 155                                         pair.add(options.get(i)); pair.add(options.get(j));\r
 156                                         List<String> args = rnaalifoldOpc.argumentsToCommandString(pair);\r
 157                                         try { \r
 158                                                 failed = singleRun(args);\r
 159                                         } catch (ResultNotAvailableException e) {\r
 160                                                 System.out.println("Results not available: " + e.getMessage());\r
 161                                                 failed = true;\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
 171                                         }\r
 172                                         if (failed == true) {\r
 173                                                 failedOptionPairs.add(args);\r
 174                                         }\r
 175                                 }\r
 176                         }\r
 177                 }\r
 178                 System.out.println("failedOptionPairs: " + failedOptionPairs);\r
 179                 \r
 180         }\r
 181         \r
 182         // tests for incompatible Pairs of Parameters \r
 183         // there are none however the --betascale parameter requires -p\r
 184         \r
 185         @Test\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
 190                 \r
 191                 \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
 195                                 if (i != j) {\r
 196                                         pair.clear();\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
 200                                         try { \r
 201                                                 failed = singleRun(args);\r
 202                                         } catch (ResultNotAvailableException e) {\r
 203                                                 System.out.println("Results not available: " + e.getMessage());\r
 204                                                 failed = true;\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
 214                                         }\r
 215                                         if (failed == true) {\r
 216                                                 failedParameterPairs.add(args);\r
 217                                         }\r
 218                                 }\r
 219                         }\r
 220                 }\r
 221                 System.out.println("failedParameterPairs: " + failedParameterPairs);\r
 222                 \r
 223         }\r
 224         \r
 225         \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
 232                                 \r
 233                                 newL.add(optionList.get(i));\r
 234                         }\r
 235                                 \r
 236                 }\r
 237                 return newL;\r
 238         }\r
 239         \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
 243                 }\r
 244                 return optionList;\r
 245         }\r
 246         \r
 247         \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
 256                 \r
 257                 test(params, precursor);\r
 258         }\r
 259         \r
 260         // incompatible pairs of arguments are\r
 261         /*\r
 262          * the -c and -g options\r
 263          * the -d2 option and the -d option\r
 264          * the -p and -p0 option\r
 265          */\r
 266 \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
 272                 test(options);\r
 273         }\r
 274         \r
 275         // This test supercedes the testParameterPair() and testOptionPair()\r
 276         // tests by testing all pairs of arguments\r
 277         \r
 278         \r
 279         @Test\r
 280         public void testAllPairs() throws ResultNotAvailableException {\r
 281                 List<Option<?>> pair = new ArrayList<Option<?>>();\r
 282                 List<Option<?>> options = rnaalifoldOpc.getAllOptions();\r
 283                 \r
 284                 // take out -p options so it can be added to all commands later\r
 285                 // options = removeParam(options, "Partition Function");\r
 286                 \r
 287                 options.addAll(rnaalifoldOpc.getAllParameters());\r
 288                 List<List<String>> failedOptionPairs = new ArrayList<List<String>>();\r
 289                 \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
 293                                 if (i != j) {\r
 294                                         pair.clear();\r
 295                                         pair.add(options.get(i)); pair.add(options.get(j));\r
 296                                         List<String> args = rnaalifoldOpc.argumentsToCommandString(pair);\r
 297                                         // add -p\r
 298                                         // args.add("-p");\r
 299                                         try { \r
 300                                                 failed = singleRun(args);\r
 301                                         } catch (ResultNotAvailableException e) {\r
 302                                                 System.out.println("Results not available: " + e.getMessage());\r
 303                                                 failed = true;\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
 313                                         }\r
 314                                         if (failed == true) {\r
 315                                                 failedOptionPairs.add(args);\r
 316                                         }\r
 317                                 }\r
 318                         }\r
 319                 }\r
 320                 System.out.println("failedOptionPairs: " + failedOptionPairs);\r
 321         }\r
 322         \r
 323         /*\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
 329          *  \r
 330          */\r
 331         \r
 332         \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
 336                         singleTest(args);\r
 337                         Collections.shuffle(params);\r
 338                 }\r
 339                 log.info("NUMBER OF COMBINATION TESTED: " + params.size());\r
 340         }\r
 341         \r
 342         // because some parameters presuppose the -p option\r
 343         \r
 344         void test(List<? extends Option<?>> params, List<String> precursor) {\r
 345 \r
 346                 for (int i = 0; i < params.size(); i++) {\r
 347                         List<String> args = rnaalifoldOpc.argumentsToCommandString(params);\r
 348                         args.addAll(precursor);\r
 349                         singleTest(args);\r
 350                         Collections.shuffle(params);\r
 351                 }\r
 352                 log.info("NUMBER OF COMBINATION TESTED: " + params.size());\r
 353         }\r
 354         @Test\r
 355         void singleParamTest() {\r
 356                 //List<Parameter<?>> params = rnaalifoldOpc.getAllParameters();\r
 357                 //System.out.println("special: params: " + params);\r
 358                 \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
 364                 args.add("-p");\r
 365                 singleTest(args);\r
 366                 \r
 367         }\r
 368         \r
 369         void singleTest(List<String> params) {\r
 370                 try {\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
 374                         \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
 380                         lr.executeJob();\r
 381                         confRNAalifold = (ConfiguredExecutable<RNAalifold>) lr.waitForResult();\r
 382                         assertNotNull(confRNAalifold.getResults(), "results is null");\r
 383                         \r
 384                         System.out.println("Results: \n" \r
 385                         + ((RNAStructScoreManager) confRNAalifold.getResults()).toString());\r
 386                         \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
 391                         }\r
 392                         assertTrue(errors.length() == 0, "Run with arguments : " + params\r
 393                                         + " FAILED!");\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
 407                 }\r
 408         }\r
 409         \r
 410         /* A version of singleTest that continues running instead of calling\r
 411          * fail() when it encounters a problem\r
 412          * \r
 413          * Used to identify incompatible options and parameters\r
 414          * returns -1 on failure\r
 415          * \r
 416          * Bad Progamming practice? \r
 417          */\r
 418         \r
 419         \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
 426 \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
 432                 lr.executeJob();\r
 433                 confRNAalifold = (ConfiguredExecutable<RNAalifold>) lr.waitForResult();\r
 434                 \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
 442                 }\r
 443                 assertTrue(errors.length() == 0, "Run with arguments : " + params\r
 444                                 + " FAILED!");\r
 445                 Collections.shuffle(params);\r
 446                 return fail;\r
 447                 }\r
 448 }\r