Java SimpleValueFactory类代码示例

import org.eclipse.rdf4j.model.impl.SimpleValueFactory; //导入依赖的package包/类
@Test
public void map_withClasses_appliesEveryClassToGeneratedSubject() throws Exception {

	EvaluateExpression evaluator = null;
	SimpleValueFactory f = SimpleValueFactory.getInstance();
	IRI subjectIRI = f.createIRI("http://foo.bar/subjectIRI");

	when(subjectGenerator.apply(evaluator))
			.thenReturn(Optional.of(subjectIRI));

	Set<IRI> expectedClasses = 
		ImmutableSet.of(
			f.createIRI("http://www.none.invalid/foo"),
			f.createIRI("http://www.none.invalid/bar"),
			f.createIRI("http://www.none.invalid/baz")
		);

	Model model = new ModelBuilder().build();
	SubjectMapper s = new SubjectMapper(subjectGenerator, ImmutableSet.of(), expectedClasses, ImmutableSet.of());
	s.map(model, evaluator);

	expectedClasses.forEach(iri -> Assert.assertTrue(model.contains(subjectIRI, RDF.TYPE, iri)));
}
 

import org.eclipse.rdf4j.model.impl.SimpleValueFactory; //导入依赖的package包/类
@Test
public void map_withPredicateMappers_callsEachPredicateMapper() throws Exception {
	SimpleValueFactory f = SimpleValueFactory.getInstance();
	IRI subjectIRI = f.createIRI("http://foo.bar/subjectIRI");

	Set<PredicateMapper> predicateMappers = ImmutableSet.of(
			mock(PredicateMapper.class),
			mock(PredicateMapper.class),
			mock(PredicateMapper.class),
			mock(PredicateMapper.class)
	);

	Model model = new ModelBuilder().build();
	EvaluateExpression evaluator = null;


	PredicateObjectMapper testSubject = new PredicateObjectMapper(ImmutableSet.of(), predicateMappers);
	testSubject.map(model, evaluator, subjectIRI, ImmutableSet.of());

	predicateMappers.forEach(mapper -> verify(mapper).map(model, evaluator, subjectIRI));
}
 

import org.eclipse.rdf4j.model.impl.SimpleValueFactory; //导入依赖的package包/类
@Test
public void IriTermGenerator_withRelativeIRI_usesBaseIRI() throws Exception {

	ValueFactory f = SimpleValueFactory.getInstance();

	String baseIri = "http://base.iri";
	TermGeneratorCreator tgc = new TermGeneratorCreator(f, baseIri, null, TemplateParser.build(), null);

	String ref = "ref";
	TermGenerator<Value> generator = tgc.getObjectGenerator(new ObjectMapImpl(ref, null, null, TermType.IRI, null, null, null, null));

	String relativeIriPart = "/relativeIriPortion";
	EvaluateExpression evaluator = Mockito.mock(EvaluateExpression.class);
	when(evaluator.apply(ref)).thenReturn(Optional.of(relativeIriPart));
	Optional<Value> result = generator.apply(evaluator);

	Assert.assertTrue(result.isPresent());
	Assert.assertTrue(result.get() instanceof IRI);
	Assert.assertEquals(result.get(), f.createIRI(baseIri + relativeIriPart));
}
 

import org.eclipse.rdf4j.model.impl.SimpleValueFactory; //导入依赖的package包/类
@Test
public void IriTermGenerator_withAbsoluteIRI_usesBaseIRI() throws Exception {

	ValueFactory f = SimpleValueFactory.getInstance();

	String baseIri = "http://base.iri";
	TermGeneratorCreator tgc = new TermGeneratorCreator(f, baseIri, null, TemplateParser.build(), null);

	String ref = "ref";
	TermGenerator<Value> generator = tgc.getObjectGenerator(new ObjectMapImpl(ref, null, null, TermType.IRI, null, null, null, null));

	String absoluteIri = "http://foo.bar/absoluteIri";
	EvaluateExpression evaluator = Mockito.mock(EvaluateExpression.class);
	when(evaluator.apply(ref)).thenReturn(Optional.of(absoluteIri));
	Optional<Value> result = generator.apply(evaluator);

	Assert.assertTrue(result.isPresent());
	Assert.assertTrue(result.get() instanceof IRI);
	Assert.assertEquals(result.get(), f.createIRI(absoluteIri));
}
 

import org.eclipse.rdf4j.model.impl.SimpleValueFactory; //导入依赖的package包/类
@Test
public void IriTermGenerator_withFaultyIRI_throwsException() throws Exception {

	ValueFactory f = SimpleValueFactory.getInstance();

	String baseIri = "?";
	TermGeneratorCreator tgc = new TermGeneratorCreator(f, baseIri, null, TemplateParser.build(), null);

	String ref = "ref";
	TermGenerator<Value> generator = tgc.getObjectGenerator(new ObjectMapImpl(ref, null, null, TermType.IRI, null, null, null, null));

	String relativeIriPart = "/relativeIriPortion";
	EvaluateExpression evaluator = Mockito.mock(EvaluateExpression.class);
	when(evaluator.apply(ref)).thenReturn(Optional.of(relativeIriPart));

	RuntimeException exception = null;
	try {
		generator.apply(evaluator);
		Assert.assertTrue("This code should be unreachable", false);
	} catch (RuntimeException e) {
		exception = e;
	}

	Assert.assertNotNull(exception);
	Assert.assertTrue(exception.getMessage().startsWith("data error: could not generate a valid iri"));
}
 

import org.eclipse.rdf4j.model.impl.SimpleValueFactory; //导入依赖的package包/类
@Test
public void filterSubjects_ReturnsResults_WhenFilterDoesMatch() {
  // Arrange
  Model model = new ModelBuilder().add("http://www.test.nl#subj", "http://www.test.nl#is",
      SimpleValueFactory.getInstance().createIRI("http://www.test.nl#obj1")).add(
          "http://www.test.nl#subj2", "http://www.test.nl#is",
          SimpleValueFactory.getInstance().createIRI("http://www.test.nl#obj1")).build();
  when(graphEntityContextMock.getModel()).thenReturn(model);

  Map<String, Object> vendorExtensions =
      Maps.newHashMap(ImmutableMap.of(OpenApiSpecificationExtensions.SUBJECT_FILTER,
          Maps.newHashMap(ImmutableMap.of(OpenApiSpecificationExtensions.SUBJECT_FILTER_PREDICATE,
              "http://www.test.nl#is", OpenApiSpecificationExtensions.SUBJECT_FILTER_OBJECT,
              "http://www.test.nl#obj1"))));
  when(propertyMock.getVendorExtensions()).thenReturn(vendorExtensions);
  // Act
  Set<Resource> results = mapper.getSubjects(propertyMock, graphEntityContextMock);
  // Assert
  assertThat(results, hasSize(is(2)));
}
 

import org.eclipse.rdf4j.model.impl.SimpleValueFactory; //导入依赖的package包/类
@Test
public void listObjects_NoDuplicates_WhenSubjectAndPropSimilar() throws Exception {
  // Arrange
  RepositoryConnection repositoryConnection = mock(RepositoryConnection.class);
  when(repository.getConnection()).thenReturn(repositoryConnection);
  ValueFactory valueFactory = SimpleValueFactory.getInstance();
  when(repositoryConnection.getValueFactory()).thenReturn(valueFactory);
  RepositoryResult queryResult = mock(RepositoryResult.class);

  Model model =
      new ModelBuilder().add("http://www.test.nl#sub", "http://www.test.nl#pred", "test").build();
  when(queryResult.hasNext()).thenReturn(true).thenReturn(false);
  when(queryResult.next()).thenReturn(model.stream().findFirst().get());
  when(
      repositoryConnection.getStatements(any(), any(), isNull(), anyBoolean(), any())).thenReturn(
          queryResult);
  Value subject = SimpleValueFactory.getInstance().createIRI("http://www.test.nl#test");
  Value prop = SimpleValueFactory.getInstance().createIRI("http://www.test.nl#test");
  // Act
  Collection<Value> values = backend.listObjects(subject, prop);
  // Assert
  assertThat(values, hasSize(1));
  assertThat(values.iterator().next().stringValue(), is("test"));
}
 

import org.eclipse.rdf4j.model.impl.SimpleValueFactory; //导入依赖的package包/类
@Test
public void listSubjects_ListOnlySubjects_InMixedModel() throws Exception {
  // Arrange
  RepositoryConnection repositoryConnection = mock(RepositoryConnection.class);
  when(repository.getConnection()).thenReturn(repositoryConnection);
  ValueFactory valueFactory = SimpleValueFactory.getInstance();
  when(repositoryConnection.getValueFactory()).thenReturn(valueFactory);
  RepositoryResult queryResult = mock(RepositoryResult.class);

  Model model =
      new ModelBuilder().add("http://www.test.nl#sub", "http://www.test.nl#pred", "test").build();
  when(queryResult.hasNext()).thenReturn(true).thenReturn(false);
  when(queryResult.next()).thenReturn(model.stream().findFirst().get());
  when(
      repositoryConnection.getStatements(isNull(), any(), any(), anyBoolean(), any())).thenReturn(
          queryResult);
  Value subject = SimpleValueFactory.getInstance().createIRI("http://www.test.nl#test");
  Value prop = SimpleValueFactory.getInstance().createIRI("http://www.test.nl#test");
  // Act
  Collection<Value> values = backend.listSubjects(subject, prop);
  // Assert
  assertThat(values, hasSize(1));
  assertThat(values.iterator().next(),
      is(SimpleValueFactory.getInstance().createIRI("http://www.test.nl#sub")));
}
 

import org.eclipse.rdf4j.model.impl.SimpleValueFactory; //导入依赖的package包/类
@Test
public void listSubjects_ThrowsExeption_QueryingRepositoryFailed() {
  // Assert
  thrown.expect(Rdf4jBackendRuntimeException.class);
  thrown.expectMessage("Error while querying RDF4J repository.");
  RepositoryConnection repositoryConnection = mock(RepositoryConnection.class);

  // Arrange
  when(repository.getConnection()).thenReturn(repositoryConnection);
  Exception dummy = new Exception("x");

  doThrow(new RepositoryLockedException("a", "b", "c", dummy)).when(repositoryConnection).begin();
  Value object = SimpleValueFactory.getInstance().createIRI("http://www.test.nl#test");
  Value prop = SimpleValueFactory.getInstance().createIRI("http://www.test.nl#test");

  // Act
  backend.listSubjects(prop, object);
}
 

import org.eclipse.rdf4j.model.impl.SimpleValueFactory; //导入依赖的package包/类
@Test
public void listObjects_ThrowsExeption_ForIllegalSubject() {
  // Assert
  thrown.expect(IllegalArgumentException.class);
  thrown.expectMessage("Subject needs to be a URI or blank node, property a URI node"
      + " (types: [subject: URI, property: bNode]).");

  // Arrange
  RepositoryConnection repositoryConnection = mock(RepositoryConnection.class);
  when(repository.getConnection()).thenReturn(repositoryConnection);
  Value subject = SimpleValueFactory.getInstance().createIRI("http://www.test.nl#test");
  Value prop = SimpleValueFactory.getInstance().createBNode();

  // Act
  backend.listObjects(subject, prop);
}
 

import org.eclipse.rdf4j.model.impl.SimpleValueFactory; //导入依赖的package包/类
@Test
public void listObjects_ThrowsExeption_QueryingRepositoryFailed() {
  // Assert
  thrown.expect(Rdf4jBackendRuntimeException.class);
  thrown.expectMessage("Error while querying RDF4J repository.");

  // Arrange
  RepositoryConnection repositoryConnection = mock(RepositoryConnection.class);

  when(repository.getConnection()).thenReturn(repositoryConnection);
  Exception dummy = new Exception("x");

  doThrow(new RepositoryLockedException("a", "b", "c", dummy)).when(repositoryConnection).begin();
  Value subject = SimpleValueFactory.getInstance().createIRI("http://www.test.nl#test");
  Value prop = SimpleValueFactory.getInstance().createIRI("http://www.test.nl#test");
  // Act
  backend.listObjects(subject, prop);
}
 

import org.eclipse.rdf4j.model.impl.SimpleValueFactory; //导入依赖的package包/类
@Before
public void setUp() {
  SimpleValueFactory valueFactory = SimpleValueFactory.getInstance();

  parameter = new StringTermParameter(valueFactory.createIRI("http://parameter-iri"),
      "parameter-name", true);
  parameter2 = new StringTermParameter(valueFactory.createIRI("http://parameter2-iri"),
      "parameter2-name", true);

  product = new TestInformationProduct(DBEERPEDIA.ORIGIN_INFORMATION_PRODUCT,
      DBEERPEDIA.BREWERIES_LABEL.stringValue(), ResultType.GRAPH,
      ImmutableList.of(parameter, parameter2), templateProcessorMock);

  mapper = new RequestParameterMapper();

  requestParameters = new RequestParameters();
  MultivaluedMap<String, String> mvMap = new MultivaluedHashMap<>();
  mvMap.put("param1", ImmutableList.of("value", "valueB"));
  mvMap.put("param2", ImmutableList.of("value2"));
  requestParameters.putAll(mvMap);
}
 

import org.eclipse.rdf4j.model.impl.SimpleValueFactory; //导入依赖的package包/类
@Test
public void loadResources_ThrowException_WithUnknownParameterMapper() {
  // Assert
  thrown.expect(ConfigurationException.class);

  // Arrange
  ValueFactory valueFactory = SimpleValueFactory.getInstance();
  final IRI unknownParameterMapper =
      valueFactory.createIRI("http://dotwebstack.org/def/elmo", "UnknownParameterMapper");

  when(graphQuery.evaluate()).thenReturn(new IteratingGraphQueryResult(ImmutableMap.of(),
      ImmutableList.of(
          valueFactory.createStatement(DBEERPEDIA.SUBJECT_FROM_URL, RDF.TYPE,
              unknownParameterMapper),
          valueFactory.createStatement(DBEERPEDIA.SUBJECT_FROM_URL, ELMO.SOURCE_PROP,
              HTTP.REQUEST_URI),
          valueFactory.createStatement(DBEERPEDIA.SUBJECT_FROM_URL, ELMO.TARGET_PROP,
              DBEERPEDIA.SUBJECT_PARAMETER))));

  // Act
  parameterMapperResourceProvider.loadResources();
}
 

import org.eclipse.rdf4j.model.impl.SimpleValueFactory; //导入依赖的package包/类
@Before
public void setUp() {
  // Arrange
  SimpleValueFactory valueFactory = SimpleValueFactory.getInstance();

  requiredParameter = new StringTermParameter(
      valueFactory.createIRI("http://required-parameter-iri"), "required-parameter-name", true);
  optionalParameter = new StringTermParameter(
      valueFactory.createIRI("http://optional-parameter-iri"), "optional-parameter-name", false);

  product = new TestInformationProduct(DBEERPEDIA.ORIGIN_INFORMATION_PRODUCT,
      DBEERPEDIA.BREWERIES_LABEL.stringValue(), ResultType.GRAPH,
      ImmutableList.of(requiredParameter, optionalParameter), templateProcessorMock);

  representationRequestParameterMapper = new RepresentationRequestParameterMapper();

  uriInfoMock = mock(UriInfo.class);
  when(contextMock.getUriInfo()).thenReturn(uriInfoMock);

}
 

import org.eclipse.rdf4j.model.impl.SimpleValueFactory; //导入依赖的package包/类
public Value convertValue(Object object) {
  if (object instanceof Value) {
    return (Value) object;
  }

  ValueFactory valueFactory = SimpleValueFactory.getInstance();
  if (object instanceof String) {
    return valueFactory.createLiteral((String) object);
  }
  if (object instanceof Integer) {
    return valueFactory.createLiteral((Integer) object);
  }
  if (object instanceof Double) {
    return valueFactory.createLiteral((Double) object);
  }

  throw new NotSupportedException("Value is not supported: " + object.getClass());
}