コード例 #1
0
  /**
   * Test method for {@link
   * RDFJSONUtility.kmr.scam.rest.util.RDFJSON#rdfJsonToGraph(java.lang.String)}.
   *
   * @throws IOException
   * @throws RDFParseException
   * @throws RDFHandlerException
   */
  @Test
  public void testRdfJsonToGraph5() throws IOException, RDFParseException, RDFHandlerException {
    this.testInputFile = "example5.json";

    final Model rdfJsonToGraph =
        Rio.parse(this.getClass().getResourceAsStream(this.testInputFile), "", RDFFormat.RDFJSON);

    // RDFJSONUtility.rdfJsonToHandler(new
    // InputStreamReader(this.getClass().getResourceAsStream(this.testInputFile),
    // StandardCharsets.UTF_8), new StatementCollector(rdfJsonToGraph),
    // ValueFactoryImpl.getInstance());

    Assert.assertEquals(1, rdfJsonToGraph.size());
  }
コード例 #2
0
  /** Test successful search for a Platform in Turtle */
  @Test
  public void testSearchTurtle() throws Exception {
    final String[] searchTypes = {"http://purl.org/podd/ns/poddScience#Platform"}; // ,
    // OWL.THING.stringValue()
    // };
    final MediaType requestMediaType = MediaType.APPLICATION_RDF_TURTLE;

    final Model resultModel =
        this.internalTestSearchRdf("Scan", searchTypes, requestMediaType, null);

    Assert.assertEquals("Not the expected number of results", 5, resultModel.size());
    System.out.println(resultModel.toString());
    Assert.assertEquals(
        "Expected Platform CabScan not found",
        1,
        resultModel.filter(null, null, PODD.VF.createLiteral("CabScan")).size());
    Assert.assertEquals(
        "Expected Platform PlantScan not found",
        1,
        resultModel.filter(null, null, PODD.VF.createLiteral("PlantScan")).size());
  }
コード例 #3
0
  /** Test successful search for a custom Platform in RDF/XML */
  @Test
  public void testSearchRdfForCustomPlatforms() throws Exception {
    // prepare:
    final InferredOWLOntologyID testArtifact =
        this.loadTestArtifact(
            TestConstants.TEST_ARTIFACT_20130206, MediaType.APPLICATION_RDF_TURTLE);

    final String[] searchTypes = {"http://purl.org/podd/ns/poddScience#Platform"};
    final MediaType requestMediaType = MediaType.APPLICATION_RDF_XML;

    final Model resultModel =
        this.internalTestSearchRdf(
            "lat", searchTypes, requestMediaType, testArtifact.getOntologyIRI().toString());

    // verify:
    Assert.assertEquals("Not the expected number of results", 1, resultModel.size());
    Assert.assertEquals(
        "Expected Platform 1 not found",
        1,
        resultModel.filter(null, null, PODD.VF.createLiteral("Platform 1")).size());
  }
コード例 #4
0
  /** Test successful search for a FOR Codes in RDF/XML */
  @Test
  public void testSearchRdfForWildtTypeAssertion() throws Exception {
    final String[] searchTypes = {"http://purl.org/podd/ns/poddScience#WildTypeAssertion"};
    final MediaType requestMediaType = MediaType.APPLICATION_RDF_XML;

    final Model resultModel = this.internalTestSearchRdf("", searchTypes, requestMediaType, null);

    // verify:
    Assert.assertEquals("Not the expected number of results", 4, resultModel.size());
    Assert.assertEquals(
        "Expected Assertion 'Yes' not found",
        1,
        resultModel.filter(null, null, PODD.VF.createLiteral("Yes")).size());
    Assert.assertEquals(
        "Expected Assertion 'Unknown' not found",
        1,
        resultModel.filter(null, null, PODD.VF.createLiteral("Unknown")).size());
    Assert.assertEquals(
        "Expected Assertion 'Not Applicable' not found",
        1,
        resultModel.filter(null, null, PODD.VF.createLiteral("Not Applicable")).size());
  }
コード例 #5
0
  /** Test successful search for a PODD Project in RDF/XML */
  @Test
  public void testSearchRdfForProjects() throws Exception {
    // prepare:
    final InferredOWLOntologyID testArtifact =
        this.loadTestArtifact(
            TestConstants.TEST_ARTIFACT_20130206, MediaType.APPLICATION_RDF_TURTLE);

    final String[] searchTypes = {"http://purl.org/podd/ns/poddScience#Project"};
    final MediaType requestMediaType = MediaType.APPLICATION_RDF_XML;

    final Model resultModel =
        this.internalTestSearchRdf(
            "Cot", searchTypes, requestMediaType, testArtifact.getOntologyIRI().toString());

    // verify:
    Assert.assertEquals("Not the expected number of results", 1, resultModel.size());
    Assert.assertTrue(
        "Expected Project not found",
        resultModel
            .filter(null, RDFS.LABEL, null)
            .objectString()
            .contains("Cotton Leaf Morphology"));
  }
コード例 #6
0
  /** Test a search in RDF/XML, with no "searchTypes" specified. */
  @Test
  public void testSearchRdfWithoutSearchTypes() throws Exception {
    final String[] searchTypes = {}; // EVERYTHING in the search space is
    // compared
    final MediaType requestMediaType = MediaType.APPLICATION_RDF_XML;

    final Model resultModel = this.internalTestSearchRdf("e", searchTypes, requestMediaType, null);

    // verify:
    Assert.assertEquals("Not the expected number of results", 224, resultModel.size());

    Assert.assertEquals(
        "dcTerms not found",
        1,
        resultModel
            .filter(null, null, PODD.VF.createLiteral("The PODD Ontology for Dublin Core Terms"))
            .size());
    Assert.assertEquals(
        "The PODD Ontology for Dublin Core Terms not found",
        1,
        resultModel
            .filter(null, null, PODD.VF.createLiteral("The PODD Ontology for Dublin Core Terms"))
            .size());
  }
コード例 #7
0
  /** Test successful search for PoddScience:Sex values in RDF/XML */
  @Test
  public void testSearchRdfForSex() throws Exception {
    // prepare: add an artifact
    final InferredOWLOntologyID testArtifact =
        this.loadTestArtifact(
            TestConstants.TEST_ARTIFACT_20130206, MediaType.APPLICATION_RDF_TURTLE);

    final String[] searchTypes = {"http://purl.org/podd/ns/poddScience#Sex"};
    final MediaType requestMediaType = MediaType.APPLICATION_RDF_XML;

    final Model resultModel =
        this.internalTestSearchRdf(
            "", searchTypes, requestMediaType, testArtifact.getOntologyIRI().toString());

    Assert.assertEquals("Not the expected number of results", 5, resultModel.size());
    Assert.assertEquals(
        "Value Hermaphrodite not found",
        1,
        resultModel.filter(null, null, PODD.VF.createLiteral("Hermaphrodite")).size());
    Assert.assertEquals(
        "Value Male not found",
        1,
        resultModel.filter(null, null, PODD.VF.createLiteral("Male")).size());
  }
コード例 #8
0
  /**
   * Test successful search for a Platform in RDF/XML including owl:Thing in the list to verify that
   * it doesn't expand the search space, as the search types must all match. Ie, it is not the case
   * that if "any" types match the search will succeed.
   */
  @Test
  public void testSearchRdfForPlatformsWithOWLThing() throws Exception {
    final String[] searchTypes = {
      "http://purl.org/podd/ns/poddScience#Platform", OWL.THING.stringValue()
    };
    final MediaType requestMediaType = MediaType.APPLICATION_RDF_XML;

    final Model resultModel = this.internalTestSearchRdf("me", searchTypes, requestMediaType, null);

    // verify:
    Assert.assertEquals("Not the expected number of results", 9, resultModel.size());
    Assert.assertEquals(
        "Expected Platform SPAD Meter not found",
        1,
        resultModel.filter(null, null, PODD.VF.createLiteral("SPAD Meter")).size());
    Assert.assertEquals(
        "Expected Platform Pyrometer not found",
        1,
        resultModel.filter(null, null, PODD.VF.createLiteral("Pyrometer")).size());
    Assert.assertEquals(
        "Expected Platform SC1 Porometer not found",
        1,
        resultModel.filter(null, null, PODD.VF.createLiteral("SC1 Porometer")).size());
  }
コード例 #9
0
  @Override
  public void endRDF() throws RDFHandlerException {
    final SesameRDFParser serialiser = new SesameRDFParser();
    try {
      Object output = JsonLdProcessor.fromRDF(model, serialiser);

      final JSONLDMode mode = getWriterConfig().get(JSONLDSettings.JSONLD_MODE);

      final JsonLdOptions opts = new JsonLdOptions();
      // opts.addBlankNodeIDs =
      // getWriterConfig().get(BasicParserSettings.PRESERVE_BNODE_IDS);
      opts.setUseRdfType(getWriterConfig().get(JSONLDSettings.USE_RDF_TYPE));
      opts.setUseNativeTypes(getWriterConfig().get(JSONLDSettings.USE_NATIVE_TYPES));
      // opts.optimize = getWriterConfig().get(JSONLDSettings.OPTIMIZE);

      if (mode == JSONLDMode.EXPAND) {
        output = JsonLdProcessor.expand(output, opts);
      }
      // TODO: Implement inframe in JSONLDSettings
      final Object inframe = null;
      if (mode == JSONLDMode.FLATTEN) {
        output = JsonLdProcessor.frame(output, inframe, opts);
      }
      if (mode == JSONLDMode.COMPACT) {
        final Map<String, Object> ctx = new LinkedHashMap<String, Object>();
        addPrefixes(ctx, model.getNamespaces());
        final Map<String, Object> localCtx = new HashMap<String, Object>();
        localCtx.put("@context", ctx);

        output = JsonLdProcessor.compact(output, localCtx, opts);
      }
      if (getWriterConfig().get(BasicWriterSettings.PRETTY_PRINT)) {
        JSONUtils.writePrettyPrint(writer, output);
      } else {
        JSONUtils.write(writer, output);
      }

    } catch (final JsonLdError e) {
      throw new RDFHandlerException("Could not render JSONLD", e);
    } catch (final JsonGenerationException e) {
      throw new RDFHandlerException("Could not render JSONLD", e);
    } catch (final JsonMappingException e) {
      throw new RDFHandlerException("Could not render JSONLD", e);
    } catch (final IOException e) {
      throw new RDFHandlerException("Could not render JSONLD", e);
    }
  }
コード例 #10
0
  public VocabBuilder(String filename, RDFFormat format) throws IOException, RDFParseException {
    Path file = Paths.get(filename);
    if (!Files.exists(file)) throw new FileNotFoundException(filename);

    if (format == null) {
      format = Rio.getParserFormatForFileName(filename);
      log.trace("detected input format from filename {}: {}", filename, format);
    }

    try (final InputStream inputStream = Files.newInputStream(file)) {
      log.trace("Loading input file");
      model = Rio.parse(inputStream, "", format);
    }

    // import
    Set<Resource> owlOntologies = model.filter(null, RDF.TYPE, OWL.ONTOLOGY).subjects();
    if (!owlOntologies.isEmpty()) {
      setPrefix(owlOntologies.iterator().next().stringValue());
    }
  }
コード例 #11
0
  @Test
  public void testPostRdfBasic() throws Exception {
    // prepare: add an artifact
    final InferredOWLOntologyID testArtifact =
        this.loadTestArtifact(
            TestConstants.TEST_ARTIFACT_20130206, MediaType.APPLICATION_RDF_TURTLE);

    final ClientResource searchClientResource =
        new ClientResource(this.getUrl(PoddWebConstants.PATH_SEARCH));
    try {
      searchClientResource.addQueryParameter(
          PoddWebConstants.KEY_ARTIFACT_IDENTIFIER, testArtifact.getOntologyIRI().toString());

      // prepare: the test input
      final String[] objectUris = {
        "http://purl.org/podd/basic-1-20130206/object:2966",
        "http://purl.org/podd/basic-2-20130206/artifact:1#Demo-Genotype",
        "http://purl.org/podd/basic-2-20130206/artifact:1#SqueekeeMaterial",
        "http://purl.org/podd/ns/poddScience#WildType_NotApplicable",
        "http://purl.org/podd/ns/poddPlant#DeltaTporometer-63",
        "http://purl.org/podd/ns/poddBase#DisplayType_LongText"
      };

      final String[] expectedLabels = {
        "Project#2012-0006_ Cotton Leaf Morphology",
        "Demo genotype",
        "Squeekee material",
        "Not Applicable",
        "Delta-T porometer",
        null
      };

      final Model testModel = new LinkedHashModel();
      for (final String s : objectUris) {
        testModel.add(PODD.VF.createURI(s), RDFS.LABEL, PODD.VF.createLiteral("?blank"));
      }

      final RDFFormat inputFormat = RDFFormat.RDFXML;
      final MediaType inputMediaType = MediaType.valueOf(inputFormat.getDefaultMIMEType());

      // build input representation
      final ByteArrayOutputStream output = new ByteArrayOutputStream(8096);
      Rio.write(testModel, output, inputFormat);
      final Representation input = new StringRepresentation(output.toString(), inputMediaType);

      // invoke service
      final Representation results =
          this.doTestAuthenticatedRequest(
              searchClientResource,
              Method.POST,
              input,
              inputMediaType,
              Status.SUCCESS_OK,
              AbstractResourceImplTest.WITH_ADMIN);

      // verify: response
      final Model resultModel = this.assertRdf(results, RDFFormat.RDFXML, 5);

      // verify: each URI has the expected label
      for (int i = 0; i < objectUris.length; i++) {
        final String objectString =
            resultModel.filter(PODD.VF.createURI(objectUris[i]), RDFS.LABEL, null).objectString();
        Assert.assertEquals("Not the expected label", expectedLabels[i], objectString);
      }
    } finally {
      this.releaseClient(searchClientResource);
    }
  }
コード例 #12
0
 @Override
 public void startRDF() throws RDFHandlerException {
   statementCollector.clear();
   model.clear();
 }
コード例 #13
0
 @Override
 public void handleNamespace(String prefix, String uri) throws RDFHandlerException {
   model.setNamespace(prefix, uri);
 }
コード例 #14
0
  public HashMap<String, Properties> generateResourceBundle(String baseName)
      throws GenerationException {
    // be sure to have at least the default URI constant settings
    if (uriGeneration == null) {
      uriGeneration = GenerationSetting.createDefault(caseFormat, "", "");
    }
    Pattern pattern = Pattern.compile(Pattern.quote(getPrefix()) + "(.+)");
    HashMap<String, URI> splitUris = new HashMap<>();
    for (Resource nextSubject : model.subjects()) {
      if (nextSubject instanceof URI) {
        Matcher matcher = pattern.matcher(nextSubject.stringValue());
        if (matcher.find()) {
          String k = matcher.group(1);
          splitUris.put(k, (URI) nextSubject);
        }
      }
    }

    List<String> keys = new ArrayList<>();
    keys.addAll(splitUris.keySet());
    Collections.sort(keys, String.CASE_INSENSITIVE_ORDER);

    HashMap<String, Properties> bundles = new HashMap<>();
    // Default we have for sure
    bundles.put(baseName, new Properties());
    for (String key : keys) {
      final URI resource = splitUris.get(key);
      //
      String nextKey = cleanKey(doCaseFormatting(key, uriGeneration.getCaseFormat()));

      for (URI p : LABEL_PROPERTIES) {
        for (Value v : GraphUtil.getObjects(model, resource, p)) {
          if (v instanceof Literal) {
            final Literal lit = (Literal) v;
            final String lang = lit.getLanguage();
            final Properties bundle;
            if (lang == null) {
              bundle = bundles.get(baseName);
            } else if (bundles.containsKey(baseName + "_" + lang)) {
              bundle = bundles.get(baseName + "_" + lang);
            } else {
              bundle = new Properties();
              bundles.put(baseName + "_" + lang, bundle);
            }

            if (!bundle.containsKey(nextKey + ".label")) {
              bundle.put(nextKey + ".label", lit.getLabel().replaceAll("\\s+", " "));
            }
          }
        }
      }

      for (URI p : COMMENT_PROPERTIES) {
        for (Value v : GraphUtil.getObjects(model, resource, p)) {
          if (v instanceof Literal) {
            final Literal lit = (Literal) v;
            final String lang = lit.getLanguage();
            final Properties bundle;
            if (lang == null) {
              bundle = bundles.get(baseName);
            } else if (bundles.containsKey(baseName + "_" + lang)) {
              bundle = bundles.get(baseName + "_" + lang);
            } else {
              bundle = new Properties();
              bundles.put(baseName + "_" + lang, bundle);
            }

            if (!bundle.containsKey(nextKey + ".comment")) {
              bundle.put(nextKey + ".comment", lit.getLabel().replaceAll("\\s+", " "));
            }
          }
        }
      }
    }

    if (getPreferredLanguage() != null) {
      log.debug("completing default Bundle with preferred language {}", getPreferredLanguage());
      final Properties defaultBundle = bundles.get(baseName);
      final Properties prefBundle = bundles.get(baseName + "_" + getPreferredLanguage());
      if (prefBundle != null) {
        for (Entry<Object, Object> key : prefBundle.entrySet()) {
          String nextKey = (String) key.getKey();
          if (!defaultBundle.containsKey(nextKey)) {
            log.trace("copying {} from {} to default Bundle", nextKey, getPreferredLanguage());
            defaultBundle.setProperty(nextKey, (String) key.getValue());
          }
        }
      } else {
        log.warn("No Bundle data found for preferred language {}", getPreferredLanguage());
      }
    }
    return bundles;
  }
コード例 #15
0
  public void generate(String className, PrintWriter out)
      throws IOException, GraphUtilException, GenerationException {
    // be sure to have at least the uri constants generated
    if (stringGeneration == null && uriGeneration == null) {
      uriGeneration = GenerationSetting.createDefault(caseFormat, "", "");
      // throw new GenerationException("no generation settings present, please set explicitly");
    }
    log.trace("classname: {}", className);
    if (StringUtils.isBlank(name)) {
      name = className;
    }
    if (StringUtils.isBlank(prefix)) {
      throw new GenerationException("could not detect prefix, please set explicitly");
    } else {
      log.debug("prefix: {}", prefix);
    }

    Pattern pattern = Pattern.compile(Pattern.quote(getPrefix()) + "(.+)");
    ConcurrentMap<String, URI> splitUris = new ConcurrentHashMap<>();
    for (Resource nextSubject : model.subjects()) {
      if (nextSubject instanceof URI) {
        Matcher matcher = pattern.matcher(nextSubject.stringValue());
        if (matcher.find()) {
          String k = matcher.group(1);
          URI putIfAbsent = splitUris.putIfAbsent(k, (URI) nextSubject);
          if (putIfAbsent != null) {
            log.warn(
                "Conflicting keys found: uri={} key={} existing={}",
                nextSubject.stringValue(),
                k,
                putIfAbsent);
          }
        }
      }
    }

    // print

    // package is optional
    if (StringUtils.isNotBlank(packageName)) {
      out.printf("package %s;%n%n", getPackageName());
    }
    // imports
    out.println("import org.openrdf.model.URI;");
    out.println("import org.openrdf.model.ValueFactory;");
    out.println("import org.openrdf.model.impl.ValueFactoryImpl;");
    out.println();

    final URI pfx = new URIImpl(prefix);
    Literal oTitle =
        getFirstExistingObjectLiteral(model, pfx, getPreferredLanguage(), LABEL_PROPERTIES);
    Literal oDescr =
        getFirstExistingObjectLiteral(model, pfx, getPreferredLanguage(), COMMENT_PROPERTIES);
    Set<Value> oSeeAlso = model.filter(pfx, RDFS.SEEALSO, null).objects();

    // class JavaDoc
    out.println("/**");
    if (oTitle != null) {
      out.printf(
          " * %s.%n",
          WordUtils.wrap(oTitle.getLabel().replaceAll("\\s+", " "), 70, "\n * ", false));
      out.println(" * <p>");
    }
    if (oDescr != null) {
      out.printf(
          " * %s.%n",
          WordUtils.wrap(oDescr.getLabel().replaceAll("\\s+", " "), 70, "\n * ", false));
      out.println(" * <p>");
    }
    out.printf(" * Namespace %s.%n", name);
    out.printf(" * Prefix: {@code <%s>}%n", prefix);
    if (!oSeeAlso.isEmpty()) {
      out.println(" *");
      for (Value s : oSeeAlso) {
        if (s instanceof URI) {
          out.printf(" * @see <a href=\"%s\">%s</a>%n", s.stringValue(), s.stringValue());
        }
      }
    }
    out.println(" */");
    // class Definition
    out.printf("public class %s {%n", className);
    out.println();

    // constants
    out.printf(getIndent(1) + "/** {@code %s} **/%n", prefix);
    out.printf(getIndent(1) + "public static final String NAMESPACE = \"%s\";%n", prefix);
    out.println();
    out.printf(getIndent(1) + "/** {@code %s} **/%n", name.toLowerCase());
    out.printf(getIndent(1) + "public static final String PREFIX = \"%s\";%n", name.toLowerCase());
    out.println();

    List<String> keys = new ArrayList<>();
    keys.addAll(splitUris.keySet());
    Collections.sort(keys, String.CASE_INSENSITIVE_ORDER);
    // do the string constant generation (if set)
    if (stringGeneration != null) {
      for (String key : keys) {
        final Literal comment =
            getFirstExistingObjectLiteral(
                model, splitUris.get(key), getPreferredLanguage(), COMMENT_PROPERTIES);
        final Literal label =
            getFirstExistingObjectLiteral(
                model, splitUris.get(key), getPreferredLanguage(), LABEL_PROPERTIES);

        out.println(getIndent(1) + "/**");
        if (label != null) {
          out.printf(getIndent(1) + " * %s%n", label.getLabel());
          out.println(getIndent(1) + " * <p>");
        }
        out.printf(getIndent(1) + " * {@code %s}.%n", splitUris.get(key).stringValue());
        if (comment != null) {
          out.println(getIndent(1) + " * <p>");
          out.printf(
              getIndent(1) + " * %s%n",
              WordUtils.wrap(
                  comment.getLabel().replaceAll("\\s+", " "),
                  70,
                  "\n" + getIndent(1) + " * ",
                  false));
        }
        out.println(getIndent(1) + " *");
        out.printf(getIndent(1) + " * @see <a href=\"%s\">%s</a>%n", splitUris.get(key), key);
        out.println(getIndent(1) + " */");

        final String nextKey =
            cleanKey(
                // NOTE: CONSTANT PREFIX and constant SUFFIX are NOT part of caseFormatting
                String.format(
                    "%s%s%s",
                    StringUtils.defaultString(stringGeneration.getConstantPrefix()),
                    doCaseFormatting(key, stringGeneration.getCaseFormat()),
                    StringUtils.defaultString(stringGeneration.getConstantSuffix())));
        checkField(className, nextKey);
        out.printf(
            getIndent(1) + "public static final String %s = %s.NAMESPACE + \"%s\";%n",
            nextKey,
            className,
            key);
        out.println();
      }
    }
    // do the entire uri constant generation
    if (uriGeneration != null) {
      for (String key : keys) {
        Literal comment =
            getFirstExistingObjectLiteral(
                model, splitUris.get(key), getPreferredLanguage(), COMMENT_PROPERTIES);
        Literal label =
            getFirstExistingObjectLiteral(
                model, splitUris.get(key), getPreferredLanguage(), LABEL_PROPERTIES);

        out.println(getIndent(1) + "/**");
        if (label != null) {
          out.printf(getIndent(1) + " * %s%n", label.getLabel());
          out.println(getIndent(1) + " * <p>");
        }
        out.printf(getIndent(1) + " * {@code %s}.%n", splitUris.get(key).stringValue());
        if (comment != null) {
          out.println(getIndent(1) + " * <p>");
          out.printf(
              getIndent(1) + " * %s%n",
              WordUtils.wrap(
                  comment.getLabel().replaceAll("\\s+", " "),
                  70,
                  "\n" + getIndent(1) + " * ",
                  false));
        }
        out.println(getIndent(1) + " *");
        out.printf(getIndent(1) + " * @see <a href=\"%s\">%s</a>%n", splitUris.get(key), key);
        out.println(getIndent(1) + " */");
        final String nextKey =
            cleanKey(
                // NOTE: CONSTANT PREFIX and constant SUFFIX are NOT part of caseFormatting
                String.format(
                    "%s%s%s",
                    StringUtils.defaultString(uriGeneration.getConstantPrefix()),
                    doCaseFormatting(key, uriGeneration.getCaseFormat()),
                    StringUtils.defaultString(uriGeneration.getConstantSuffix())));

        // String nextKey = cleanKey(doCaseFormatting(key, uriGeneration.getCaseFormat()));
        checkField(className, nextKey);
        out.printf(getIndent(1) + "public static final URI %s;%n", nextKey);
        out.println();
      }
      // static init
      out.println(getIndent(1) + "static {");
      out.printf(getIndent(2) + "ValueFactory factory = ValueFactoryImpl.getInstance();%n");
      out.println();
      for (String key : keys) {
        final String nextKey =
            cleanKey(
                // NOTE: CONSTANT PREFIX and constant SUFFIX are NOT part of caseFormatting
                String.format(
                    "%s%s%s",
                    StringUtils.defaultString(uriGeneration.getConstantPrefix()),
                    doCaseFormatting(key, uriGeneration.getCaseFormat()),
                    StringUtils.defaultString(uriGeneration.getConstantSuffix())));
        out.printf(
            getIndent(2) + "%s = factory.createURI(%s.NAMESPACE, \"%s\");%n",
            nextKey,
            className,
            key);
      }
      out.println(getIndent(1) + "}");
      out.println();
    }

    // private contructor to avoid instances
    out.printf(getIndent(1) + "private %s() {%n", className);
    out.println(getIndent(2) + "//static access only");
    out.println(getIndent(1) + "}");
    out.println();

    // class end
    out.println("}");
    out.flush();
  }
コード例 #16
0
  /**
   * Test method for {@link
   * RDFJSONUtility.kmr.scam.rest.util.RDFJSON#graphToRdfJsonPreordered(java.util.Set,
   * java.io.Writer)} .
   *
   * @throws JSONException
   */
  @Test
  public void testModelToRdfJsonPreorderedSetOfStatementWriter() throws Exception {
    // final Set<Statement> testStatements = new TreeSet<Statement>(new StatementComparator());
    final Model testStatements = new TreeModel();
    final ValueFactoryImpl vf = ValueFactoryImpl.getInstance();

    final BNode testBNode1 = vf.createBNode();

    final BNode testBNode2 = vf.createBNode();

    final URI testURI1 = vf.createURI("http://example.org/test/rdf/json/1");

    final URI testURI2 = vf.createURI("http://my.test.org/rdf/type/2");

    final URI testURI3 = vf.createURI("http://example.org/test/rdf/json/3");

    final URI testURI4 = vf.createURI("http://example.org/test/rdf/json/4");

    final URI testURI5 = vf.createURI("http://my.test.org/rdf/type/5");

    final Statement testStatement1 = vf.createStatement(testURI1, testURI2, testURI3);
    testStatements.add(testStatement1);
    final Statement testStatement2 = vf.createStatement(testURI1, testURI2, testBNode1);
    testStatements.add(testStatement2);
    final Statement testStatement3 = vf.createStatement(testURI1, testURI2, testBNode2);
    testStatements.add(testStatement3);

    final Statement testStatement4 = vf.createStatement(testURI4, testURI2, testURI3);
    testStatements.add(testStatement4);
    final Statement testStatement5 = vf.createStatement(testURI4, testURI2, testBNode2);
    testStatements.add(testStatement5);
    final Statement testStatement6 = vf.createStatement(testURI4, testURI2, testBNode1);
    testStatements.add(testStatement6);

    final Statement testStatement7 = vf.createStatement(testBNode1, testURI5, testBNode2);
    testStatements.add(testStatement7);
    final Statement testStatement8 = vf.createStatement(testBNode1, testURI5, testURI1);
    testStatements.add(testStatement8);
    final Statement testStatement9 = vf.createStatement(testBNode1, testURI5, testURI4);
    testStatements.add(testStatement9);

    // RDFJSONUnitTest.log.info("testStatements=" + testStatements);

    Assert.assertEquals(9, testStatements.size());

    // Verify that the statements are in an acceptable order (testStatement5 and testStatement6
    // can be legitimately swapped)

    final Iterator<Statement> testStatementIterator = testStatements.iterator();

    Assert.assertTrue(testStatementIterator.hasNext());

    // testStatement7 should always be first by virtue of the fact that it has two blank nodes
    // and no other statements have two blank nodes
    Assert.assertEquals(testStatement7, testStatementIterator.next());
    Assert.assertTrue(testStatementIterator.hasNext());

    // Then testStatement8
    Assert.assertEquals(testStatement8, testStatementIterator.next());
    Assert.assertTrue(testStatementIterator.hasNext());

    // Then testStatement9
    Assert.assertEquals(testStatement9, testStatementIterator.next());
    Assert.assertTrue(testStatementIterator.hasNext());

    Rio.write(testStatements, this.testWriter, RDFFormat.RDFJSON);
    // RDFJSONUtility.modelToRdfJson(testStatements, this.testWriter, this.testWriterConfig);

    this.testOutput = this.testWriter.toString();

    Assert.assertTrue(this.testOutput.length() > 0);

    Assert.assertTrue(this.testOutput.startsWith("{"));

    Assert.assertTrue(this.testOutput.endsWith("}"));

    // RDFJSONUnitTest.log.info("testOutput=" + this.testOutput);

    final int firstBlankNode = this.testOutput.indexOf("\"_:");

    // Test that a bnode exists after the opening brace
    Assert.assertTrue(firstBlankNode > 0);

    // The first value after the first blank node should be a blank node identifier
    final int firstValue = this.testOutput.indexOf("\"value\" : \"_:", firstBlankNode);

    Assert.assertTrue("A suitable blank node value was not found", firstValue > 0);

    // This should be guaranteed by the indexOf contract, but doing a quick check anyway
    Assert.assertTrue(firstValue > firstBlankNode);

    // Do a quick check to see if the testOutput is valid JSON

    // FIXME: TODO: Test using Jackson
    // Assert.fail("TODO: Implement me using Jackson");
    // final JSONObject testJSONObject = new JSONObject(this.testOutput);

    // Assert.assertNotNull(testJSONObject);
    // Assert.assertTrue(testJSONObject.length() > 0);
    // Assert.assertTrue(testJSONObject.names().length() > 0);
    // Assert.assertTrue(testJSONObject.keys().hasNext());
  }
コード例 #17
0
 @BeforeMethod
 public void setUp() {
   model.clear();
 }