001: package org.ontoware.rdf2go.impl.jena24;
002:
003: import junit.framework.TestCase;
004:
005: import org.ontoware.rdf2go.exception.ModelRuntimeException;
006: import org.ontoware.rdf2go.model.node.DatatypeLiteral;
007: import org.ontoware.rdf2go.model.node.URI;
008: import org.ontoware.rdf2go.model.node.impl.DatatypeLiteralImpl;
009: import org.ontoware.rdf2go.model.node.impl.URIImpl;
010:
011: import com.hp.hpl.jena.datatypes.BaseDatatype;
012: import com.hp.hpl.jena.datatypes.RDFDatatype;
013: import com.hp.hpl.jena.datatypes.TypeMapper;
014: import com.hp.hpl.jena.graph.Node;
015: import com.hp.hpl.jena.graph.impl.LiteralLabel;
016: import com.hp.hpl.jena.rdf.model.Literal;
017: import com.hp.hpl.jena.rdf.model.ModelFactory;
018: import com.hp.hpl.jena.shared.impl.JenaParameters;
019:
020: public class DataTypeTesting extends TestCase {
021:
022: public void testDataTypeEqualness() throws Exception {
023:
024: // die erste DatenTyp URI
025: URI testA = new URIImpl("test://somedata-A", false);
026: // die zweite DatenTyp URI
027: URI testB = new URIImpl("test://somedata-B", false);
028:
029: // der erste BaseDatatype wird von der ersten DatenTyp URI erzeugt
030: BaseDatatype BDtestA1 = new BaseDatatype(testA + "");
031: // der zweite BaseDatatype ebenso
032: BaseDatatype BDtestA2 = new BaseDatatype(testA + "");
033: // f�r den dritten BaseDatatype nehmen wir eine neue Datentyp URI
034: BaseDatatype BDtestB = new BaseDatatype(testB + "");
035:
036: // alle Literals haben den gleichen Inhalt
037:
038: // das erste Literal kriegt den ersten BaseDatatype
039: LiteralLabel litA11 = new LiteralLabel("teststring", "",
040: BDtestA1);
041: // das zweite Liertal kriegt den auch, es hat also komplett die gleichen
042: // Eigenschaften wie das erste Literal aber in einem neuen Objekt
043: LiteralLabel litA12 = new LiteralLabel("teststring", "",
044: BDtestA1);
045: // jetzt machen wir ein drittes Literal, welches aber den zweiten
046: // BasedataType
047: // bekommt, der aber eigentlich von der ersten DataTypeURI stammt
048: LiteralLabel litA2 = new LiteralLabel("teststring", "",
049: BDtestA2);
050: // und jetzt machen wir noch nen vierten Literal, der von einem neuen
051: // Basedatatype komt, welche wiederrum von einer neuen DatatypeURI ist
052: LiteralLabel litB = new LiteralLabel("teststring", "", BDtestB);
053:
054: // dann wollen wir mal schauen was passiert:
055:
056: // reflexivit�t: A == A , passt
057: assertTrue(litA11.sameValueAs(litA11));
058: // gleicher Inhalt, in zwei versch. Objekten, passt auch
059: assertTrue(litA11.sameValueAs(litA12));
060: // zwei Objekte, mit untersch. BaseDatatypes, von der gleichen Datatype
061: // URI:
062: // nein
063: assertFalse(litA11.sameValueAs(litA2));
064: // und zur sicherheit: 2 versch Datentyp URIs: nein
065: assertFalse(litA11.sameValueAs(litB));
066:
067: // und nochmal der negativ Test:
068: assertTrue(litB.sameValueAs(litB));
069: assertFalse(litB.sameValueAs(litA11));
070: assertFalse(litB.sameValueAs(litA12));
071: assertFalse(litB.sameValueAs(litA2));
072:
073: // weiterlesen ;)
074:
075: // das liegt an der Implementierung von BaseDatatype.isEqual()
076: assertFalse(BDtestA1.isEqual(litA11, litA2));
077:
078: /**
079: * Compares two instances of values of the given datatype. This default
080: * requires value and datatype equality.
081: *
082: * public boolean isEqual(LiteralLabel value1, LiteralLabel value2) {
083: * return value1.getDatatype() == value2.getDatatype() ^^^^^^ &&
084: * value1.getValue().equals(value2.getValue()); }
085: */
086:
087: // Es werden dirket 2 Object Referenzen verglichen, und 2 versch.
088: // Basedatatype Objecte sind ebend unterschiedlich.
089: // wir m�ssen entweder irgendwo auf der Seite von RDF2GO
090: // BaseDatatypes recyclen, oder einen eigenen Datentyp schreiben,
091: // bei dem isEqual() den Inhalt der Datentyp URIs der beiden
092: // Basedatatypes
093: // vergleicht.
094: }
095:
096: public void testGeneralDataTypeEqualness() throws Exception {
097:
098: // Die Idee mit dem GeneralDataType ist an sich echt gut, aber:
099: // Es kann passieren das mit addStatement(object, object, object, object)
100: // als Object des Tripels ein Literal mit Daten Typ erzeugt wird.
101: // Wenn ich nun mein Literal mit einem GeneralDataType erzeuge,
102: // es in den Graphen einf�ge, und ich sp�ter abfragen will
103: // ob dieses data typed Literal sich wirklich im Graphen befindet,
104: // dann wird das literal mit dem GeneralDataType mit dem eigentlich
105: // gleichen Literal verglichen, aber die zweite Instanz hat einen BaseDatatype
106: // weil sie automatisch in Search-Triple oder irgend sowas eingef�gt wurde.
107: // Da GeneralDataType auf BaseDatatype down-gecastet werden kann, werden sie
108: // dann mit dem BaseDatatype.equals() verglichen und dann passt es wieder nicht.
109:
110: // L�sung siehe Funktion testDataTypesWithUnknownType()
111:
112: // die erste DatenTyp URI
113: URI testA = new URIImpl("test://somedata-A", false);
114: // die zweite DatenTyp URI
115: URI testB = new URIImpl("test://somedata-B", false);
116:
117: // der erste BaseDatatype wird von der ersten DatenTyp URI erzeugt
118: GeneralDataType BDtestA1 = new GeneralDataType(testA + "");
119: // der zweite BaseDatatype ebenso
120: GeneralDataType BDtestA2 = new GeneralDataType(testA + "");
121: // f�r den dritten BaseDatatype nehmen wir eine neue Datentyp URI
122: GeneralDataType BDtestB = new GeneralDataType(testB + "");
123:
124: // alle Literals haben den gleichen Inhalt
125:
126: // das erste Literal kriegt den ersten BaseDatatype
127: LiteralLabel litA11 = new LiteralLabel("teststring", "",
128: BDtestA1);
129: // das zweite Liertal kriegt den auch, es hat also komplett die gleichen
130: // Eigenschaften wie das erste Literal aber in einem neuen Objekt
131: LiteralLabel litA12 = new LiteralLabel("teststring", "",
132: BDtestA1);
133: // jetzt machen wir ein drittes Literal, welches aber den zweiten
134: // BasedataType
135: // bekommt, der aber eigentlich von der ersten DataTypeURI stammt
136: LiteralLabel litA2 = new LiteralLabel("teststring", "",
137: BDtestA2);
138: // und jetzt machen wir noch nen vierten Literal, der von einem neuen
139: // Basedatatype komt, welche wiederrum von einer neuen DatatypeURI ist
140: LiteralLabel litB = new LiteralLabel("teststring", "", BDtestB);
141:
142: // dann wollen wir mal schauen was passiert:
143:
144: // reflexivit�t: A == A , passt
145: assertTrue(litA11.sameValueAs(litA11));
146: // gleicher Inhalt, in zwei versch. Objekten, passt auch
147: assertTrue(litA11.sameValueAs(litA12));
148: // zwei Objekte, mit untersch. BaseDatatypes, von der gleichen Datatype URI:
149:
150: // ACHTUNG: mit GeneralDataType passt das jetzt weil f�r die Gleichheit der Datentypen
151: // nun nur die Gleichheit der URIs der Datentypen notwendig ist
152: assertTrue(litA11.sameValueAs(litA2));
153: // und zur sicherheit: 2 versch Datentyp URIs: nein
154: assertFalse(litA11.sameValueAs(litB));
155:
156: // und nochmal der negativ Test:
157: assertTrue(litB.sameValueAs(litB));
158: assertFalse(litB.sameValueAs(litA11));
159: assertFalse(litB.sameValueAs(litA12));
160: assertFalse(litB.sameValueAs(litA2));
161:
162: // und hier nochmal der Low Level Test:
163: // mit GeneralDataType ist nun isEqual()
164: // so implementiert, das die URIs der Datentypen verglichen werden und die Werte der Strings
165: // und deswegen ist das jetzt hier True
166: assertTrue(BDtestA1.isEqual(litA11, litA2));
167:
168: }
169:
170: public void testOldDataTypesUsedAsIntended() throws Exception {
171:
172: // laut der jena-dev Mailingliste, sollte man Datentypen so erzeugen:
173: // siehe http://groups.yahoo.com/group/jena-dev/message/14052
174:
175: // String dtURI = tmpProp.getRange().getURI();
176: // RDFDatatype dt = TypeMapper.getInstance().getTypeByName(dtURI);
177: // Literal tmpLit = tmpModel.createTypedLiteral("123", dt );
178:
179: // leider f�hrt das dann dazu das "test"^^xsd:funky equal zu "test" ist,
180: // da dann xsd:funky ein unknown data type ist und
181: // somit "test"^^xsd:funky genau wie ein plain literal behandelt wird.
182:
183: // die erste DatenTyp URI
184: // URI testA = URIUtils.createURI("test://somedata-A");
185: String strTestA = new String("test://somedata-A");
186: // die zweite DatenTyp URI
187: // URI testB = URIUtils.createURI("test://somedata-B");
188: String strTestB = new String("test://somedata-B");
189:
190: // der erste BaseDatatype wird von der ersten DatenTyp URI erzeugt
191: RDFDatatype DTtestA1 = TypeMapper.getInstance().getTypeByName(
192: strTestA);
193: // der zweite BaseDatatype ebenso
194: RDFDatatype DTtestA2 = TypeMapper.getInstance().getTypeByName(
195: strTestA);
196: // f�r den dritten BaseDatatype nehmen wir eine neue Datentyp URI
197: RDFDatatype DTtestB = TypeMapper.getInstance().getTypeByName(
198: strTestB);
199:
200: com.hp.hpl.jena.rdf.model.Model model = ModelFactory
201: .createDefaultModel();
202:
203: Literal litA11 = model.createTypedLiteral("teststring",
204: DTtestA1);
205: Literal litA12 = model.createTypedLiteral("teststring",
206: DTtestA1);
207: Literal litA2 = model
208: .createTypedLiteral("teststring", DTtestA2);
209: @SuppressWarnings("unused")
210: Literal litB = model.createTypedLiteral("teststring", DTtestB);
211:
212: // alle Literals haben den gleichen Wert !
213:
214: // dann wollen wir mal schauen was passiert:
215:
216: // reflexivit�t: A == A , passt
217: assertTrue(litA11.equals(litA11));
218: // gleicher Inhalt, in zwei versch. Objekten, passt auch
219: assertTrue(litA11.equals(litA12));
220: // zwei Objekte, mit untersch. BaseDatatypes, von der gleichen Datatype URI:
221:
222: assertTrue(litA11.equals(litA2));
223: // und zur sicherheit: 2 versch Datentyp URIs:
224:
225: // -> das sollte eigentlich nicht sein
226: //TODO jena bug assertFalse(litA11.equals(litB));
227:
228: }
229:
230: public void testDataTypesWithUnknownType() throws Exception {
231:
232: // siehe dazu com.hp.hpl.jena.graph.test.TestTypedLiterals.java, Funktion testUnknown()
233: // das ganze funktioniert sowohl mit Jena2.2 als auch mit dem jena aus dem cvs
234:
235: // das ganze Problem scheint wohl zu sein das Jena ziemlich abgefahrene Sachen machen kann
236: // mit daten typen und der valdierung und solchen advanced topics.
237: // die Erwaeaehnte Test Datei zeigt das ziemlich eindrucksvoll.
238:
239: // Dieser gesamte Test testet direkt die Funktion von Jena, nicht von rdf2go. (SG)
240:
241: // die erste DatenTyp URI
242: String strTestA = new String("test://somedata-A");
243: // die zweite DatenTyp URI
244: String strTestB = new String("test://somedata-B");
245:
246: com.hp.hpl.jena.rdf.model.Model model = ModelFactory
247: .createDefaultModel();
248:
249: // das hier scheint alles zu sein was notwendig ist damit Jena die data typed literals
250: // semantisch so behandelt wie wir es wollen
251: // Behold !!
252: JenaParameters.enableSilentAcceptanceOfUnknownDatatypes = true;
253:
254: Literal litA1 = model
255: .createTypedLiteral("teststring", strTestA);
256: Literal litA2 = model
257: .createTypedLiteral("teststring", strTestA);
258: Literal litB = model.createTypedLiteral("teststring", strTestB);
259:
260: // dann wollen wir mal schauen was passiert:
261:
262: // reflexivit�t: A == A , passt
263: assertTrue(litA1.equals(litA1));
264: // gleicher Inhalt, in zwei versch. Objekten, passt auch
265: assertTrue(litA1.equals(litA2));
266: // und zur sicherheit: 2 versch Datentyp URIs: nein
267: assertFalse(litA1.equals(litB));
268:
269: // und nochmal der negativ Test:
270: assertTrue(litB.equals(litB));
271: assertFalse(litB.equals(litA1));
272: assertFalse(litB.equals(litA2));
273: assertEquals("Extract Datatype URI", litA1.getDatatypeURI(),
274: strTestA);
275: assertEquals("Extract value", "teststring", litA1
276: .getLexicalForm());
277:
278: // im jena cvs geht auch folgendes, damit kann man das Object des Daten Typs besser manipulieren
279: // assertEquals("Extract value", l1.getValue(), new BaseDatatype.TypedValue("foo", typeURI));
280:
281: }
282:
283: public void testNewToJenaNode() throws ModelRuntimeException {
284: com.hp.hpl.jena.rdf.model.Model model = ModelFactory
285: .createDefaultModel();
286:
287: DatatypeLiteralImpl l1 = new DatatypeLiteralImpl("test",
288: new URIImpl("test:funky", false));
289: DatatypeLiteralImpl l2 = new DatatypeLiteralImpl("test",
290: new URIImpl("test:funky", false));
291:
292: Node n1 = TypeConversion.toJenaNode(l1, model);
293: Node n2 = TypeConversion.toJenaNode(l2, model);
294:
295: assertTrue(n1.equals(n2));
296:
297: Object o1 = TypeConversion.toRDF2Go(n1);
298: Object o2 = TypeConversion.toRDF2Go(n2);
299:
300: assertTrue(o1 instanceof DatatypeLiteral);
301: assertTrue(o2 instanceof DatatypeLiteral);
302:
303: DatatypeLiteralImpl new1 = (DatatypeLiteralImpl) o1;
304: DatatypeLiteralImpl new2 = (DatatypeLiteralImpl) o2;
305:
306: assertTrue(new1.getValue().equals("test"));
307: assertTrue(new2.getValue().equals("test"));
308: assertTrue(new1.getDatatype().equals(
309: new URIImpl("test:funky", false)));
310: assertTrue(new2.getDatatype().equals(
311: new URIImpl("test:funky", false)));
312: }
313:
314: }
|