code: package it.unibz.inf.ontop.docker.testsuite;
  
  
  import it.unibz.inf.ontop.docker.QuestParallelScenario;
  import it.unibz.inf.ontop.docker.ScenarioManifestTestUtils;
  import junit.framework.TestCase;
  import junit.framework.TestSuite;
  import org.eclipse.rdf4j.model.IRI;
  import org.eclipse.rdf4j.query.*;
  import org.eclipse.rdf4j.repository.Repository;
  import org.eclipse.rdf4j.repository.RepositoryConnection;
  import org.eclipse.rdf4j.repository.RepositoryException;
  import org.eclipse.rdf4j.repository.sail.SailRepository;
  import org.eclipse.rdf4j.sail.memory.MemoryStore;
  import org.junit.Ignore;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import java.net.URL;
  import java.util.ArrayList;
  import java.util.List;
  
  @Ignore
  public class ParallelScenarioTest extends TestCase {
  
      private static final Logger LOGGER = LoggerFactory.getLogger(QuestParallelScenario.class);
  
  
      public interface ParallelFactory {
  
          QuestParallelScenario createQuestParallelScenarioTest(String suiteName,
                                                                List<String> testIRIs, List<String> names, List<String> queryFileURLs,
                                                                List<String> resultFileURLs, String owlFileURL, String obdaFileURL,
                                                                String parameterFileURL);
  
          String getMainManifestFile();
      }
  
      public static TestCase extractTest(String manifestFileURL, ParallelFactory factory) throws Exception {
          return extractTest(manifestFileURL, factory, true);
      }
  
      public static TestCase extractTest(String manifestFileURL, ParallelFactory factory, boolean approvedOnly) throws Exception {
          LOGGER.info("Building test extractTest for {}", manifestFileURL);
  
          TestSuite suite = new TestSuite(factory.getClass().getName());
  
          // Read manifest and create declared test cases
          Repository manifestRep = new SailRepository(new MemoryStore());
          manifestRep.init();
          RepositoryConnection con = manifestRep.getConnection();
  
          ScenarioManifestTestUtils.addTurtle(con, new URL(manifestFileURL), manifestFileURL);
  
          String suiteName = getManifestName(manifestRep, con, manifestFileURL);
          suite.setName(suiteName);
  
          // Extract test case information from the manifest file. Note that we only
          // select those test cases that are mentioned in the list.
          StringBuilder query = new StringBuilder(512);
          query.append(" PREFIX mf: <http://obda.org/quest/tests/test-manifest#> \n");
          query.append(" PREFIX obdat: <http://obda.org/quest/tests/test-scenario#> \n");
          query.append(" PREFIX qt: <http://obda.org/quest/tests/test-query#> \n");
          query.append(" SELECT DISTINCT ?testIRI ?testName ?resultFile ?queryFile ?owlFile ?obdaFile ?parameterFile \n");
          query.append(" WHERE { [] rdf:first ?testIRI . \n");
          if (approvedOnly) {
              query.append(" ?testIRI obdat:approval obdat:Approved . \n");
          }
          query.append(" ?testIRI mf:name ?testName; \n");
          query.append("    mf:result ?resultFile; \n");
          query.append("    mf:knowledgebase ?owlFile; \n");
          query.append("    mf:mappings ?obdaFile . \n");
          query.append(" OPTIONAL { ?testIRI mf:parameters ?parameterFile . } \n");
          query.append(" ?testIRI mf:action ?action . \n");
          query.append(" ?action qt:query ?queryFile . }\n");
  
          TupleQuery testCaseQuery = con.prepareTupleQuery(QueryLanguage.SPARQL, query.toString());
  
          LOGGER.debug("Evaluating query..");
          TupleQueryResult testCases = testCaseQuery.evaluate();
  
          List<String> testIRIs = new ArrayList<>();
          List<String> testNames = new ArrayList<>();
          List<String> queryFiles = new ArrayList<>();
          List<String> resultFiles = new ArrayList<>();
  
          String mainOwlFile = null;
          String mainObdaFile = null;
          String mainParameterFile = null;
  
          /**
           * Test cases that share the same configuration
           * will be run in parallel.
           */
          while (testCases.hasNext()) {
              BindingSet bindingSet = testCases.next();
  
              IRI testIRI = (IRI) bindingSet.getValue("testIRI");
              String testName = bindingSet.getValue("testName").toString();
              String resultFile = bindingSet.getValue("resultFile").toString();
              String queryFile = bindingSet.getValue("queryFile").toString();
              String owlFile = bindingSet.getValue("owlFile").toString();
              String obdaFile = bindingSet.getValue("obdaFile").toString();
              String parameterFile = (bindingSet.getValue("parameterFile") == null
                      ? "" : bindingSet.getValue("parameterFile").toString());
  
              /**
               * Checks the config files of the Quest instance.
               *
               * Uses the first given files and ignores tests that use different files.
               */
              if (mainOwlFile == null)
                  mainOwlFile = owlFile;
              else if (!mainOwlFile.equals(owlFile)) {
                  LOGGER.warn(String.format("%s use a different OWL file (%s vs %s). Ignored", testName, owlFile, mainOwlFile));
                  continue;
              }
              if (mainObdaFile == null)
                  mainObdaFile = obdaFile;
              else if (!mainObdaFile.equals(obdaFile)) {
                  LOGGER.warn("{} use a different OBDA file. Ignored", testName);
                  continue;
              }
              if (mainParameterFile == null)
                  mainParameterFile = parameterFile;
              else if (!mainParameterFile.equals(parameterFile)) {
                  LOGGER.warn("{} use a different parameter file. Ignored", testName);
                  continue;
              }
  
              LOGGER.debug("Found test case: {}", testName);
  
              testIRIs.add(testIRI.toString());
              testNames.add(testName);
              queryFiles.add(queryFile);
              resultFiles.add(resultFile);
          }
  
          QuestParallelScenario scenario = factory.createQuestParallelScenarioTest(suiteName, testIRIs, testNames,
                  queryFiles, resultFiles, mainOwlFile, mainObdaFile, mainParameterFile);
  
          testCases.close();
          con.close();
  
          manifestRep.shutDown();
          if (scenario == null) {
              return null;
          }
          return new ParallelTestCase(suiteName, scenario);
      }
  
      protected static String getManifestName(Repository manifestRep, RepositoryConnection con, String manifestFileURL)
              throws QueryEvaluationException, RepositoryException, MalformedQueryException
      {
          // Try to extract extractTest name from manifest file
          TupleQuery manifestNameQuery = con.prepareTupleQuery(QueryLanguage.SPARQL,
                  "SELECT ?ManifestName WHERE { ?ManifestURL rdfs:label ?ManifestName }");
          manifestNameQuery.setBinding("ManifestURL", manifestRep.getValueFactory().createIRI(manifestFileURL));
          TupleQueryResult manifestNames = manifestNameQuery.evaluate();
          try {
              if (manifestNames.hasNext()) {
                  return manifestNames.next().getValue("ManifestName").stringValue();
              }
          }
          finally {
              manifestNames.close();
          }
          // Derive name from manifest URL
          int lastSlashIdx = manifestFileURL.lastIndexOf('/');
          int secLastSlashIdx = manifestFileURL.lastIndexOf('/', lastSlashIdx - 1);
          return manifestFileURL.substring(secLastSlashIdx + 1, lastSlashIdx);
      }
  }
  