testsrc/compbio/runner/structure/RNAalifoldParametersTester.java

   1 package compbio.runner.structure;
   2
   3 import static org.testng.Assert.assertFalse;
   4 import static org.testng.Assert.assertNotNull;
   5 import static org.testng.Assert.assertTrue;
   6 import static org.testng.Assert.fail;
   7
   8 import java.io.File;
   9 import java.io.FileInputStream;
  10 import java.io.FileNotFoundException;
  11 import java.io.IOException;
  12 import java.util.ArrayList;
  13 import java.util.Collections;
  14 import java.util.List;
  15 import java.util.Map;
  16
  17 import javax.xml.bind.JAXBException;
  18 import javax.xml.bind.ValidationException;
  19
  20 import org.apache.log4j.Level;
  21 import org.apache.log4j.Logger;
  22 import org.testng.annotations.BeforeMethod;
  23 import org.testng.annotations.Test;
  24
  25 import compbio.engine.Configurator;
  26 import compbio.engine.client.ConfiguredExecutable;
  27 import compbio.engine.client.Executable.ExecProvider;
  28 import compbio.engine.conf.RunnerConfigMarshaller;
  29 import compbio.engine.local.ExecutableWrapper;
  30 import compbio.engine.local.LocalRunner;
  31 import compbio.metadata.AllTestSuit;
  32 import compbio.metadata.JobExecutionException;
  33 import compbio.metadata.JobSubmissionException;
  34 import compbio.metadata.Option;
  35 import compbio.metadata.Parameter;
  36 import compbio.metadata.Preset;
  37 import compbio.metadata.PresetManager;
  38 import compbio.metadata.ResultNotAvailableException;
  39 import compbio.metadata.RunnerConfig;
  40 import compbio.runner.OptionCombinator;
  41 import compbio.runner.structure.RNAalifold;
  42 import compbio.util.FileUtil;
  43
  44
  45 public class RNAalifoldParametersTester {
  46
  47
  48         // should be: AllTestSuit.TEST_DATA_PATH + "RNAalifoldParameters.xml"
  49         static final String rnaalifoldConfigFile =
  50                         AllTestSuit.TEST_DATA_PATH + "RNAalifoldParameters.xml";
  51         public static String test_outfile = "rnaalifold.out.txt";
  52
  53         private static Logger log = Logger
  54                         .getLogger(AllTestSuit.RUNNER_TEST_LOGGER);
  55
  56         static {
  57                 log.setLevel(Level.INFO);
  58         }
  59
  60         RunnerConfig<RNAalifold> rnaalifoldConfig = null;
  61         OptionCombinator rnaalifoldOpc = null;
  62
  63         @BeforeMethod(groups = { AllTestSuit.test_group_runner })
  64         @SuppressWarnings("unchecked")
  65         public void setup() {
  66                 try {
  67                         RunnerConfigMarshaller<RNAalifold> rnaalifoldmarsh =
  68                                         new RunnerConfigMarshaller<RNAalifold>(RunnerConfig.class);
  69                         rnaalifoldConfig = rnaalifoldmarsh.read(new FileInputStream(new File(
  70                                         rnaalifoldConfigFile)), RunnerConfig.class);
  71                         rnaalifoldOpc = new OptionCombinator(rnaalifoldConfig);
  72
  73                         log.info("Num options: " + rnaalifoldOpc.getAllOptions().size());
  74                         log.info("Num params: " + rnaalifoldOpc.getAllParameters().size());
  75
  76
  77                 } catch (JAXBException e) {
  78                         e.printStackTrace();
  79                         fail(e.getLocalizedMessage());
  80                 } catch (FileNotFoundException e) {
  81                         e.printStackTrace();
  82                         fail(e.getLocalizedMessage());
  83                 }
  84         }
  85
  86         @Test
  87         public void testConfiguration() {
  88                 try {
  89                         this.rnaalifoldConfig.validate();
  90                 } catch (ValidationException e) {
  91                         e.printStackTrace();
  92                         fail(e.getLocalizedMessage());
  93                 } catch (IllegalStateException e) {
  94                         e.printStackTrace();
  95                         fail(e.getLocalizedMessage());
  96                 }
  97         }
  98
  99         @Test(groups = { AllTestSuit.test_group_runner })
 100         public void testDefaultParameters() {
 101                 RNAalifold rnaalifold = new RNAalifold();
 102                 rnaalifold.setInput(AllTestSuit.test_input_aln).setOutput(test_outfile);
 103
 104                 try {
 105                         // For local execution use relavive
 106                         ConfiguredExecutable<RNAalifold> confRNAalifold = Configurator
 107                                         .configureExecutable(rnaalifold);
 108                         LocalRunner lr = new LocalRunner(confRNAalifold);
 109                         lr.executeJob();
 110                         confRNAalifold = (ConfiguredExecutable<RNAalifold>) lr.waitForResult();
 111                         assertNotNull(confRNAalifold.getResults());
 112                 } catch (JobSubmissionException e) {
 113                         e.printStackTrace();
 114                         fail(e.getLocalizedMessage());
 115                 } catch (JobExecutionException e) {
 116                         e.printStackTrace();
 117                         fail(e.getLocalizedMessage());
 118                 } catch (ResultNotAvailableException e) {
 119                         e.printStackTrace();
 120                         fail(e.getLocalizedMessage());
 121                 }
 122         }
 123
 124         @Test(groups = { AllTestSuit.test_group_runner })
 125         public void testOptions() {
 126                 test(rnaalifoldOpc.getAllOptions());
 127         }
 128
 129         @Test(groups = { AllTestSuit.test_group_runner })
 130         public void testParameters() {
 131                 List<Parameter<?>> params = rnaalifoldOpc.getAllParameters();
 132                 Collections.shuffle(params);
 133                 test(params);
 134         }
 135
 136         @Test(groups = { AllTestSuit.test_group_runner })
 137         public void testArguments() {
 138                 List<Option<?>> options = rnaalifoldOpc.getAllOptions();
 139                 options.addAll(rnaalifoldOpc.getAllParameters());
 140                 Collections.shuffle(options);
 141                 test(options);
 142         }
 143
 144         void test(Map<Parameter<?>, String> paramValue) {
 145                 List<Parameter<?>> paramList = new ArrayList<Parameter<?>>(paramValue
 146                                 .keySet());
 147                 for (int i = 0; i < paramValue.size(); i++) {
 148                         List<String> args = rnaalifoldOpc.parametersToCommandString(paramList,
 149                                         paramValue);
 150                         singleTest(args);
 151                         Collections.shuffle(paramList);
 152                 }
 153                 log.info("NUMBER OF COMBINATION TESTED: " + paramValue.size());
 154         }
 155
 156         void test(List<? extends Option<?>> params) {
 157                 for (int i = 0; i < params.size(); i++) {
 158                         List<String> args = rnaalifoldOpc.argumentsToCommandString(params);
 159                         singleTest(args);
 160                         Collections.shuffle(params);
 161                 }
 162                 log.info("NUMBER OF COMBINATION TESTED: " + params.size());
 163         }
 164
 165         void singleTest(List<String> params) {
 166                 try {
 167                         log.info("Using arguments: " + params);
 168                         RNAalifold rnaalifold = new RNAalifold();
 169                         rnaalifold.setInput(AllTestSuit.test_input_aln).setOutput(test_outfile);
 170
 171                         ConfiguredExecutable<RNAalifold> confRNAalifold = Configurator
 172                                         .configureExecutable(rnaalifold, ExecProvider.Local);
 173                         // Add options to the executable
 174                         confRNAalifold.addParameters(params);
 175                         LocalRunner lr = new LocalRunner(confRNAalifold);
 176                         lr.executeJob();
 177                         confRNAalifold = (ConfiguredExecutable<RNAalifold>) lr.waitForResult();
 178                         assertNotNull(confRNAalifold.getResults());
 179                         File errors = new File(confRNAalifold.getWorkDirectory(),
 180                                         ExecutableWrapper.PROC_ERR_FILE);
 181                         if (errors.length() != 0) {
 182                                 log.error("PROBLEMS:\n " + FileUtil.readFileToString(errors));
 183                         }
 184                         assertTrue(errors.length() == 0, "Run with arguments : " + params
 185                                         + " FAILED!");
 186                         Collections.shuffle(params);
 187                 } catch (JobSubmissionException e) {
 188                         e.printStackTrace();
 189                         fail(e.getLocalizedMessage());
 190                 } catch (JobExecutionException e) {
 191                         e.printStackTrace();
 192                         fail(e.getLocalizedMessage());
 193                 } catch (IOException e) {
 194                         e.printStackTrace();
 195                         fail(e.getLocalizedMessage());
 196                 } catch (ResultNotAvailableException e) {
 197                         e.printStackTrace();
 198                         fail(e.getLocalizedMessage());
 199                 }
 200         }
 201
 202 }