You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@devicemap.apache.org by wk...@apache.org on 2015/02/01 18:48:44 UTC
svn commit: r1656340 - in
/devicemap/trunk/devicemap/java/simpleddr/src/test/java/test: ./
DDRSimpleAPITester.java
Author: wkeil
Date: Sun Feb 1 17:48:44 2015
New Revision: 1656340
URL: http://svn.apache.org/r1656340
Log:
DMAP-49: W3C integration
Added DDRSimpleAPITester
Task-Url: https://issues.apache.org/jira/browse/DMAP-49
Added:
devicemap/trunk/devicemap/java/simpleddr/src/test/java/test/
devicemap/trunk/devicemap/java/simpleddr/src/test/java/test/DDRSimpleAPITester.java
Added: devicemap/trunk/devicemap/java/simpleddr/src/test/java/test/DDRSimpleAPITester.java
URL: http://svn.apache.org/viewvc/devicemap/trunk/devicemap/java/simpleddr/src/test/java/test/DDRSimpleAPITester.java?rev=1656340&view=auto
==============================================================================
--- devicemap/trunk/devicemap/java/simpleddr/src/test/java/test/DDRSimpleAPITester.java (added)
+++ devicemap/trunk/devicemap/java/simpleddr/src/test/java/test/DDRSimpleAPITester.java Sun Feb 1 17:48:44 2015
@@ -0,0 +1,438 @@
+package test;
+
+import org.w3c.ddr.simple.*;
+import org.w3c.ddr.simple.exception.*;
+
+public class DDRSimpleAPITester {
+
+ // (localPropertyKnownString,localAspectKnownString) is in the database with value localKnownStringValue
+ // (localPropertyUnknownString,localAspectUnknownString) is not in the database
+
+ private String vocabularyIRI;
+ private String aspect1;
+ private String aspect2;
+ private int totalPropertRefsInService;
+
+ private String localPropertyKnownString;
+ private String localPropertyUnknownString;
+ private String localAspectKnownString;
+ private String localAspectUnknownString;
+ private String localKnownStringValue;
+
+ private String localPropertyKnownInteger;
+ private String localAspectKnownInteger;
+ private int localKnownIntegerValue;
+
+ private String localPropertyKnownBoolean;
+ private String localAspectKnownBoolean;
+ private boolean localKnownBooleanValue;
+
+ private String localPropertyKnownEnumeration;
+ private String localAspectKnownEnumeration;
+ private String[] localKnownEnumerationValue;
+
+ private java.util.Hashtable report;
+
+ private org.w3c.ddr.simple.Service s;
+ private org.w3c.ddr.simple.Evidence e;
+
+ /**
+ * A test class for the DDR Simple API.
+ * This is a simple text of an instance of org.w3c.ddr.simple.Service such that all of the methods of
+ * the DDR Simple API are exercised at least once and their results compared against the expected results.
+ * The tests make no statement about the validity of an implementation, the performance of an
+ * implementation or the correctness of the data to which the Service is an interface.
+ * An implementation must be able to support more than one vocabulary, and it is expected that a
+ * conformant implementation would be able to provide at least one vocabulary and associated data so
+ * that the tests represented by this class can be passed.
+ * The motivation for this class is to provide a common independent means of supporting a claim
+ * of conformance to the DDR Simple API for any implementation in Java.
+ * Similar tests may be devised for other implementation languages.
+ *
+ * @param s An instance of the Service implementation that has already been initialised.
+ * @param e An instance of Evidence for which several properties are known to the repository instance.
+ * @param vocabularyIRI The IRI of the vocabulary used in this test, which must have at least two aspects.
+ * @param aspect1 An aspect of the vocabulary.
+ * @param aspect2 An aspect of the vocabulary.
+ * @param totalPropertiesRepresentedInVocabulary The total number of property/aspect in all vocabularies known to the Service.
+ * @param localPropertyKnownString The local property name X of a String property whose value is known in the repository.
+ * @param localPropertyUnknownString The local property name Y of a String property whose value is unknown in the repository.
+ * @param localAspectKnownString The aspect of property X whose value is known.
+ * @param localAspectUnknownString The aspect of property Y whose value is unknown.
+ * @param localKnownStringValue The value for the property X that is known in the repository.
+ * @param localPropertyKnownInteger The local property name for an Integer known in the repository.
+ * @param localAspectKnownInteger The aspect of the Integer that is known in the repository.
+ * @param localKnownIntegerValue The value of the Integer that is known in the repository.
+ * @param localPropertyKnownBoolean The local property bane for a Boolean known in the repository.
+ * @param localAspectKnownBoolean The aspect of the Boolean known in the repository.
+ * @param localKnownBooleanValue The value of the Boolean known in the repository.
+ * @param localPropertyKnownEnumeration The local property name of an Enumeration known in the repository.
+ * @param localAspectKnownEnumeration The aspect of the Enumeration known in the repository.
+ * @param localKnownEnumerationValue The value if the Enumeration known in the repository.
+ */
+ public DDRSimpleAPITester(
+ org.w3c.ddr.simple.Service s, org.w3c.ddr.simple.Evidence e,
+ String vocabularyIRI, String aspect1, String aspect2, int totalPropertiesRepresentedInVocabulary,
+ // For the test, localAspectKnownString must be the default aspect for localPropertyKnownString
+ String localPropertyKnownString, String localPropertyUnknownString, String localAspectKnownString, String localAspectUnknownString, String localKnownStringValue,
+ String localPropertyKnownInteger, String localAspectKnownInteger, int localKnownIntegerValue,
+ String localPropertyKnownBoolean, String localAspectKnownBoolean, boolean localKnownBooleanValue,
+ String localPropertyKnownEnumeration, String localAspectKnownEnumeration, String[] localKnownEnumerationValue
+ ) {
+ this.s = s; this.e = e;
+ this.vocabularyIRI = vocabularyIRI; this.aspect1 = aspect1; this.aspect2 = aspect2;
+ this.totalPropertRefsInService = totalPropertiesRepresentedInVocabulary;
+ this.localPropertyKnownString = localPropertyKnownString;
+ this.localPropertyUnknownString = localPropertyUnknownString;
+ this.localAspectKnownString = localAspectKnownString;
+ this.localAspectUnknownString = localAspectUnknownString;
+ this.localKnownStringValue = localKnownStringValue;
+ this.localPropertyKnownInteger = localPropertyKnownInteger;
+ this.localAspectKnownInteger = localAspectKnownInteger;
+ this.localKnownIntegerValue = localKnownIntegerValue;
+ this.localPropertyKnownBoolean = localPropertyKnownBoolean;
+ this.localAspectKnownBoolean = localAspectKnownBoolean;
+ this.localKnownBooleanValue = localKnownBooleanValue;
+ this.localPropertyKnownEnumeration = localPropertyKnownEnumeration;
+ this.localAspectKnownEnumeration = localAspectKnownEnumeration;
+ this.localKnownEnumerationValue = localKnownEnumerationValue;
+ }
+
+ private void setReport(boolean status, String testID) {
+ report.put(testID, status?"Pass":"FAIL"); // This will cause [unchecked] warnings in Java 1.5+. OK to ignore.
+ }
+
+ private void Clear() {
+ report = new java.util.Hashtable();
+ }
+
+ private void Clear(String testID) {
+ if (report == null) {
+ Clear();
+ }
+ report.put(testID, "????"); // This will cause [unchecked] warnings in Java 1.5+. OK to ignore.
+ }
+
+ public java.util.Hashtable getReport() {
+ Clear();
+ Clear("#sec-Evidence");
+ Clear("#sec-Evidence-get");
+ Clear("#sec-Evidence-exists");
+ Clear("#sec-Evidence-put");
+
+ Clear("#sec-PropertyName");
+ Clear("#sec-PropertyName-getLocalPropertyName");
+ Clear("#sec-PropertyName-getNamespace");
+
+ Clear("#sec-PropertyRef");
+ Clear("#sec-PropertyRef-getLocalPropertyName");
+ Clear("#sec-PropertyRef-getAspectName");
+ Clear("#sec-PropertyRef-getNamespace");
+
+ Clear("#sec-PropertyValue");
+ Clear("#sec-PropertyValue-getXXX Double"); // Untested
+ Clear("#sec-PropertyValue-getXXX Long"); // Untested
+ Clear("#sec-PropertyValue-getXXX String");
+ Clear("#sec-PropertyValue-getXXX Boolean");
+ Clear("#sec-PropertyValue-getXXX Integer");
+ Clear("#sec-PropertyValue-getXXX Enumeration");
+ Clear("#sec-PropertyValue-getXXX Float"); // Untested
+ Clear("#sec-PropertyValue-exists");
+ Clear("#sec-PropertyValue-getPropertyRef");
+
+ Clear("#sec-PropertyValues");
+ Clear("#sec-PropertyValues-getAll");
+ Clear("#sec-PropertyValues-getValue");
+
+ Clear("#sec-Service");
+ Clear("#sec-Service-newHTTPEvidence-1");
+ Clear("#sec-Service-newHTTPEvidence-2");
+ Clear("#sec-Service-newPropertyName-1");
+ Clear("#sec-Service-newPropertyName-2");
+ Clear("#sec-Service-newPropertyRef-1");
+ Clear("#sec-Service-newPropertyRef-2");
+ Clear("#sec-Service-newPropertyRef-3");
+ Clear("#sec-Service-getPropertyValues-1");
+ Clear("#sec-Service-getPropertyValues-2");
+ Clear("#sec-Service-getPropertyValues-3");
+ Clear("#sec-Service-getPropertyValues-4");
+ Clear("#sec-Service-getPropertyValue-1");
+ Clear("#sec-Service-getPropertyValue-2");
+ Clear("#sec-Service-getPropertyValue-3");
+ Clear("#sec-Service-getPropertyValue-4");
+ Clear("#sec-Service-getImplementationVersion");
+ Clear("#sec-Service-getDataVersion");
+ Clear("#sec-Service-listPropertyRefs");
+ Clear("#sec-Service-initialize");
+
+ try {
+
+ // Service tests included in other tests
+ boolean factoryCreatedEvidence = false;
+ boolean factoryCreatedPropertyName = false;
+ boolean factoryCreatedPropertyRef = false;
+ boolean obtainedPropertyValueInstance = false;
+ boolean obtainedPropertyValuesInstance = false;
+
+
+ // Evidence
+ {
+ boolean putCausedNoException = false;
+ boolean getReturnedCorrectValue = false;
+ boolean getDoesNotKnowUnputs = false;
+ boolean existsWorks = false;
+
+ Evidence evidence = s.newHTTPEvidence();
+ factoryCreatedEvidence = (evidence != null && evidence instanceof Evidence);
+ evidence.put("TestHeader", "TestHeaderValue");
+ putCausedNoException = true;
+ getReturnedCorrectValue = evidence.get("TestHeader").equals("TestHeaderValue");
+ existsWorks = evidence.exists("TestHeader") && !evidence.exists("UnknownHeader");
+ try {
+ getDoesNotKnowUnputs = (evidence.get("UnknownHeader") == null || "".equals(evidence.get("UnknownHeader")));
+ }
+ catch (Exception exc) {
+ getDoesNotKnowUnputs = true; // Throwing an exception is also a valid response to not finding the header
+ }
+ setReport(factoryCreatedEvidence, "#sec-Service-newHTTPEvidence-1");
+ setReport(putCausedNoException,"#sec-Evidence-put"); // Only need to be sure put() didn't cause an exception
+ setReport(getReturnedCorrectValue && getDoesNotKnowUnputs,"#sec-Evidence-get");
+ setReport(existsWorks,"#sec-Evidence-exists");
+ setReport(putCausedNoException && getReturnedCorrectValue && getDoesNotKnowUnputs && existsWorks,"#sec-Evidence");
+ }
+
+ // PropertyName
+ {
+ boolean knowsName = false;
+ boolean knowsNamespace = false;
+
+ PropertyName propertyName = s.newPropertyName(localPropertyKnownString, vocabularyIRI);
+ factoryCreatedPropertyName = true;
+ knowsName = localPropertyKnownString.equals(propertyName.getLocalPropertyName());
+ knowsNamespace = vocabularyIRI.equals(propertyName.getNamespace());
+
+ setReport(factoryCreatedPropertyName,"#sec-Service-newPropertyName-2");
+ setReport(knowsName, "#sec-PropertyName-getLocalPropertyName");
+ setReport(knowsNamespace, "#sec-PropertyName-getNamespace");
+ setReport(knowsName && knowsNamespace, "#sec-PropertyName");
+ }
+
+ // PropertyRef
+ {
+ boolean knowsName = false;
+ boolean knowsNamespace = false;
+ boolean knowsAspect = false;
+
+ PropertyRef propertyRef = s.newPropertyRef(s.newPropertyName(localPropertyKnownString, vocabularyIRI), localAspectKnownString);
+ factoryCreatedPropertyRef = (propertyRef != null && propertyRef instanceof PropertyRef);
+ knowsName = localPropertyKnownString.equals(propertyRef.getLocalPropertyName());
+ knowsAspect = localAspectKnownString.equals(propertyRef.getAspectName());
+ knowsNamespace = vocabularyIRI.equals(propertyRef.getNamespace());
+
+ setReport(factoryCreatedPropertyRef, "#sec-Service-newPropertyRef-3");
+ setReport(knowsName, "#sec-PropertyRef-getLocalPropertyName");
+ setReport(knowsAspect, "#sec-PropertyRef-getAspectName");
+ setReport(knowsNamespace, "#sec-PropertyRef-getNamespace");
+ setReport(knowsName && knowsAspect && knowsNamespace,"#sec-PropertyRef");
+ }
+
+ // PropertyValue
+ {
+ boolean obtainedExistingValue = false;
+ boolean detectedUnknownValue = false;
+ boolean gotSomeStringRepresentation = false;
+ boolean gotPropertyRef = false;
+ boolean gotCorrectString = false;
+ boolean gotCorrectInteger = false;
+ boolean gotCorrectBoolean = false;
+ boolean gotCorrectEnumeration = false;
+
+ PropertyValue propertyValue = s.getPropertyValue(e, localPropertyKnownString, localAspectKnownString, vocabularyIRI);
+ obtainedPropertyValueInstance = (propertyValue != null && propertyValue instanceof PropertyValue);
+ obtainedExistingValue = propertyValue.exists();
+ try {
+ PropertyValue propertyValueBad = s.getPropertyValue(e, localPropertyUnknownString, localAspectUnknownString, vocabularyIRI);
+ }
+ catch (NameException nex) {
+ detectedUnknownValue = true; // Implementations are free to use alternative codes, so just check for the exception
+ }
+ String stringRepresentation = propertyValue.getString();
+ gotSomeStringRepresentation = (stringRepresentation != null && !stringRepresentation.equals(""));
+ gotCorrectString = (stringRepresentation != null && stringRepresentation.equals(localKnownStringValue));
+ PropertyRef propertyRef = propertyValue.getPropertyRef();
+ gotPropertyRef = (
+ propertyRef != null && propertyRef instanceof PropertyRef &&
+ localPropertyKnownString.equals(propertyRef.getLocalPropertyName()) &&
+ localAspectKnownString.equals(propertyRef.getAspectName()) &&
+ vocabularyIRI.equals(propertyRef.getNamespace())
+ );
+ PropertyValue propertyValueInteger = s.getPropertyValue(e, localPropertyKnownInteger, localAspectKnownInteger, vocabularyIRI);
+ gotCorrectInteger = (propertyValueInteger.getInteger() == localKnownIntegerValue);
+ PropertyValue propertyValueBoolean = s.getPropertyValue(e, localPropertyKnownBoolean, localAspectKnownBoolean, vocabularyIRI);
+ gotCorrectBoolean = (propertyValueBoolean.getBoolean() == localKnownBooleanValue);
+ PropertyValue propertyValueEnumeration = s.getPropertyValue(e, localPropertyKnownEnumeration, localAspectKnownEnumeration, vocabularyIRI);
+ String[] enumeratedValue = propertyValueEnumeration.getEnumeration();
+ gotCorrectEnumeration = (enumeratedValue.length == localKnownEnumerationValue.length);
+ if (gotCorrectEnumeration) {
+ for (int i = 0; i < enumeratedValue.length; i++) {
+ // Warning: the order of values in the enumeration is prescribed for this test,
+ // although nothing has been said regarding the significance of any such ordering.
+ gotCorrectEnumeration = gotCorrectEnumeration && localKnownEnumerationValue[i].equals(enumeratedValue[i]);
+ }
+ }
+
+ // not tested: #sec-PropertyValue-getXXX Double
+ // not tested: #sec-PropertyValue-getXXX Long
+ // not tested: #sec-PropertyValue-getXXX Float
+ setReport(obtainedExistingValue && gotCorrectString && gotSomeStringRepresentation, "#sec-PropertyValue-getXXX String");
+ setReport(gotCorrectInteger, "#sec-PropertyValue-getXXX Integer");
+ setReport(gotCorrectBoolean, "#sec-PropertyValue-getXXX Boolean");
+ setReport(gotCorrectEnumeration, "#sec-PropertyValue-getXXX Enumeration");
+ setReport(obtainedExistingValue && detectedUnknownValue,"#sec-PropertyValue-exists");
+ setReport(gotPropertyRef,"#sec-PropertyValue-getPropertyRef");
+ setReport(gotCorrectInteger && gotCorrectBoolean && gotCorrectEnumeration && gotPropertyRef, "#sec-PropertyValue");
+ setReport(obtainedPropertyValueInstance, "#sec-Service-getPropertyValue-4");
+ }
+
+ // PropertyValues
+ {
+ boolean gotCorrectArray = false;
+ boolean gotCorrectValue = false;
+
+ PropertyRef[] propertyRefs = new PropertyRef[]{
+ s.newPropertyRef(s.newPropertyName(localPropertyKnownString, vocabularyIRI), localAspectKnownString),
+ s.newPropertyRef(s.newPropertyName(localPropertyKnownInteger, vocabularyIRI), localAspectKnownInteger),
+ s.newPropertyRef(s.newPropertyName(localPropertyKnownBoolean, vocabularyIRI), localAspectKnownBoolean)
+ };
+ PropertyValues propertyValues = s.getPropertyValues(e, propertyRefs);
+ obtainedPropertyValuesInstance = (propertyValues != null && propertyValues instanceof PropertyValues);
+ PropertyValue[] propertyValueArray = propertyValues.getAll();
+ gotCorrectArray = (
+ propertyValueArray != null && propertyValueArray.length == 3 &&
+ localKnownStringValue.equals(propertyValueArray[0].getString()) &&
+ localKnownIntegerValue == propertyValueArray[1].getInteger() &&
+ localKnownBooleanValue == propertyValueArray[2].getBoolean()
+ );
+ PropertyRef innerPropertyRef = s.newPropertyRef(
+ s.newPropertyName(localPropertyKnownInteger, vocabularyIRI), localAspectKnownInteger
+ );
+ PropertyValue innerPropertyValue = propertyValues.getValue(innerPropertyRef);
+ gotCorrectValue = (innerPropertyValue.getInteger() == localKnownIntegerValue);
+
+ setReport(gotCorrectArray, "#sec-PropertyValues-getAll");
+ setReport(gotCorrectValue, "#sec-PropertyValues-getValue");
+ setReport(gotCorrectArray && gotCorrectValue, "#sec-PropertyValues");
+ setReport(obtainedPropertyValuesInstance, "#sec-Service-getPropertyValues-4");
+ }
+
+ // Service
+ // Tests cover features not already covered by previous tests
+ {
+ boolean gotListOfProperties = false;
+ boolean evidenceViaMapOK = false;
+ boolean propNameDefaultIRIOK = false;
+ boolean propRefStringOK = false;
+ boolean propRefPropNameOK = false;
+ boolean propValuesEvidenceOK = false;
+ boolean propValuesEvidenceAspectOK = false;
+ boolean propValuesEvidenceAspectVocabOK = false;
+ boolean propValueEvidencePropRefOK = false;
+ boolean propValueEvidencePropNameOK = false;
+ boolean propValueEvidenceNameOK = false;
+
+ PropertyRef[] propertyRefArray = s.listPropertyRefs();
+ if (propertyRefArray != null && propertyRefArray.length == totalPropertRefsInService) {
+ gotListOfProperties = true;
+ }
+
+ // #sec-Service-newHTTPEvidence-2
+ java.util.HashMap<String,String> map = new java.util.HashMap<String, String>();
+ map.put("X-Header1", "HeaderValue1");
+ map.put("X-Header2", "HeaderValue2");
+ map.put("X-Header1", "HeaderValue3");
+ Evidence e2 = s.newHTTPEvidence(map);
+ if ("HeaderValue3".equals(e2.get("X-Header1")) && "HeaderValue2".equals(e2.get("X-Header2"))) {
+ evidenceViaMapOK = e2.exists("X-Header1") && e2.exists("X-Header2") && !e2.exists("X-Header3");
+ }
+
+ PropertyName pn = s.newPropertyName(localPropertyKnownString, vocabularyIRI);
+ PropertyRef pr = s.newPropertyRef(pn, localAspectKnownString);
+
+ // #sec-Service-newPropertyName-1
+ // Test assumes that default vocabulary was used in the class constructor.
+ PropertyName pn1 = s.newPropertyName(localPropertyKnownString);
+ propNameDefaultIRIOK = pn1.getLocalPropertyName().equals(localPropertyKnownString) && pn1.getNamespace().equals(vocabularyIRI);
+
+ // #sec-Service-newPropertyRef-1
+ // Test assumes that default vocabulary was used in the class constructor.
+ PropertyRef pr1 = s.newPropertyRef(localPropertyKnownString);
+ propRefStringOK = pr1.getLocalPropertyName().equals(localPropertyKnownString) &&
+ pr1.getNamespace().equals(vocabularyIRI) && pr1.getAspectName().equals(PropertyRef.NULL_ASPECT);
+
+ // #sec-Service-newPropertyRef-2
+ PropertyRef pr2 = s.newPropertyRef(pn1);
+ propRefPropNameOK = pr2.getLocalPropertyName().equals(localPropertyKnownString) &&
+ pr2.getNamespace().equals(vocabularyIRI) && pr2.getAspectName().equals(PropertyRef.NULL_ASPECT);
+
+ // #sec-Service-getPropertyValues-1
+ PropertyValues pvs1 = s.getPropertyValues(e);
+ propValuesEvidenceOK = pvs1.getValue(pr).getString().equals(localKnownStringValue);
+
+ // #sec-Service-getPropertyValues-2
+ PropertyValues pvs2 = s.getPropertyValues(e, localAspectKnownString);
+ propValuesEvidenceAspectOK = pvs2.getValue(pr).getString().equals(localKnownStringValue);
+
+ // #sec-Service-getPropertyValues-3
+ PropertyValues pvs3 = s.getPropertyValues(e, localAspectKnownString, vocabularyIRI);
+ propValuesEvidenceAspectVocabOK = pvs3.getValue(pr).getString().equals(localKnownStringValue);
+
+ // #sec-Service-getPropertyValue-1
+ PropertyValue pv1 = s.getPropertyValue(e, pr);
+ propValueEvidencePropRefOK = pv1.getString().equals(localKnownStringValue);
+
+ // #sec-Service-getPropertyValue-2
+ PropertyValue pv2 = s.getPropertyValue(e, pn);
+ propValueEvidencePropNameOK = pv2.getString().equals(localKnownStringValue);
+
+ // #sec-Service-getPropertyValue-3
+ PropertyValue pv3 = s.getPropertyValue(e, localPropertyKnownString);
+ propValueEvidenceNameOK = pv3.getString().equals(localKnownStringValue);
+
+ setReport(evidenceViaMapOK,"#sec-Service-newHTTPEvidence-2");
+ setReport(propNameDefaultIRIOK,"#sec-Service-newPropertyName-1");
+ setReport(propRefStringOK,"#sec-Service-newPropertyRef-1");
+ setReport(propRefPropNameOK,"#sec-Service-newPropertyRef-2");
+ setReport(propValuesEvidenceOK,"#sec-Service-getPropertyValues-1");
+ setReport(propValuesEvidenceAspectOK,"#sec-Service-getPropertyValues-2");
+ setReport(propValuesEvidenceAspectVocabOK,"#sec-Service-getPropertyValues-3");
+ setReport(propValueEvidencePropRefOK,"#sec-Service-getPropertyValue-1");
+ setReport(propValueEvidencePropNameOK,"#sec-Service-getPropertyValue-2");
+ setReport(propValueEvidenceNameOK,"#sec-Service-getPropertyValue-3");
+ setReport(s.getImplementationVersion() != null,"#sec-Service-getImplementationVersion"); // Just has to work without causing an exception
+ setReport(s.getDataVersion() != null,"#sec-Service-getDataVersion"); // Just has to work without causing an exception
+ setReport(gotListOfProperties,"#sec-Service-listPropertyRefs");
+ setReport(true,"#sec-Service-initialize"); // Just has to work without causing an exception
+ setReport(
+ factoryCreatedEvidence && factoryCreatedPropertyName && factoryCreatedPropertyRef &&
+ obtainedPropertyValueInstance && obtainedPropertyValuesInstance &&
+ evidenceViaMapOK && propNameDefaultIRIOK && propRefStringOK && propRefPropNameOK &&
+ propValuesEvidenceOK && propValuesEvidenceAspectOK && propValuesEvidenceAspectVocabOK &&
+ propValueEvidencePropRefOK && propValueEvidencePropNameOK &&
+ propValueEvidenceNameOK && gotListOfProperties &&
+ s.getImplementationVersion() != null && s.getDataVersion() != null
+ ,"#sec-Service");
+ }
+
+ }
+ catch (NameException ne) {
+ System.out.println("NameException: "+ne.getMessage());
+ ne.printStackTrace();
+ }
+ catch (ValueException ve) {
+ System.out.println("ValueException: "+ve.getMessage());
+ ve.printStackTrace();
+ }
+ return report;
+ }
+
+}