AnonIDRef xref


1   /*
2    wsmo4j - a WSMO API and Reference Implementation
3   
4    Copyright (c) 2005, University of Innsbruck, Austria
5   
6    This library is free software; you can redistribute it and/or modify it under
7    the terms of the GNU Lesser General Public License as published by the Free
8    Software Foundation; either version 2.1 of the License, or (at your option)
9    any later version.
10   This library is distributed in the hope that it will be useful, but WITHOUT
11   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
12   FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
13   details.
14   You should have received a copy of the GNU Lesser General Public License along
15   with this library; if not, write to the Free Software Foundation, Inc.,
16   59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17   */
18  package test.wsmo4j.validator;
19  
20  import org.deri.wsmo4j.validator.ValidationErrorImpl;
21  import org.omwg.ontology.*;
22  import org.wsmo.common.*;
23  import org.wsmo.factory.*;
24  import org.wsmo.validator.ValidationError;
25  import org.wsmo.validator.WsmlValidator;
26  
27  
28  /**
29   * <p>
30   * Title: WSMO4J
31   * </p>
32   * <p>
33   * Description: WSMO API and a Reference Implementation
34   * </p>
35   * <p>
36   * Copyright: Copyright (c) 2004-2005
37   * </p>
38   * <p>
39   * Company: University of Innsbruck, Austria
40   * </p>
41   * 
42   * @author Holger Lausen, Nathalie Steinmetz
43   * @version 1.0
44   */
45  public class AnonIDRef extends ValidatorTestCase {
46      WsmlValidator w = Factory.createWsmlValidator(null);
47      boolean b = false;
48      ValidationError ve = null;
49      
50      WsmoFactory factory = Factory.createWsmoFactory(null);
51      private final static String ns = "http://example/";
52      //setup
53      Ontology ontology = factory.createOntology(factory.createIRI(ns + getOntLocalName()));
54      IRI ida = factory.createIRI(ns+"a");
55      IRI idnfp = factory.createIRI(ns+"nfp");
56      UnnumberedAnonymousID anonId = factory.createAnonymousID();
57      UnnumberedAnonymousID anonId2 = factory.createAnonymousID();
58      Concept c1 = factory.createConcept(factory.createIRI(ns+"c1"));
59      Concept c2 = factory.createConcept(factory.createIRI(ns+"c2"));
60      Concept c3 = factory.createConcept(factory.createIRI(ns+"c3"));
61      Concept c4 = factory.createConcept(factory.createIRI(ns+"c4"));
62      Relation r1 = factory.createRelation(factory.createIRI(ns+"r1"));
63      Instance i1 = factory.createInstance(factory.createIRI(ns+"i1"));
64      Concept anonC = factory.createConcept(anonId);
65      Instance anonI = factory.createInstance(anonId2);
66      Attribute a, attr;
67      
68      public void testAnonymousSuperRelation() throws Exception {
69          errors.clear();
70          warnings.clear();
71          Ontology o = factory.createOntology(factory.createIRI(ns + getOntLocalName()));
72          Relation r1 = factory.createRelation(factory.createAnonymousID());
73          Relation r2 = factory.createRelation(factory.createIRI(ns+"testAnonymousSuperRelationR1"));
74          r1.addSubRelation(r2);
75          o.addRelation(r1);
76          o.addRelation(r2);
77          b = w.isValid(o, WSML.WSML_CORE, errors, warnings);
78          ve = errors.firstElement();
79          assertFalse(b);
80          assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
81  //        printError(errors);
82      }
83      
84      /**
85       * Anonymous concept could not have sub concepts:
86       * concept _#
87       * concept http://example/testProblemC1 subConceptOf _#
88       * 
89       * The link between the two concepts is lost after a parse/serialize
90       * @throws Exception
91       */
92      public void testAnonymousSuperConcept() throws Exception {
93          errors.clear();
94          warnings.clear();
95          Ontology o = factory.createOntology(factory.createIRI(ns + getOntLocalName()));
96          Concept c1 = factory.createConcept(factory.createAnonymousID());
97          Concept c2 = factory.createConcept(factory.createIRI(ns+"testAnonymousSuperConceptC1"));
98          c1.addSubConcept(c2);
99          o.addConcept(c1);
100         o.addConcept(c2);
101         b = w.isValid(o, WSML.WSML_CORE, errors, warnings);
102         ve = errors.firstElement();
103         assertFalse(b);
104         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
105 //        printError(errors);
106         c1.removeSubConcept(c2);
107     }
108 
109     /**
110      * Anonymous concept is a subconcept of non anonymous concept
111      * concept http://example/testProblemC1
112      * concept _# subConceptOf http://example/testProblemC1
113      * 
114      * This WSML fragment is valid (if reparsed it would be the same)
115      * @throws Exception
116      */
117     public void testAnonymousSubConcept() throws Exception {
118         errors.clear();
119         warnings.clear();
120         Ontology o = factory.createOntology(factory.createIRI(ns + getOntLocalName()));
121         Concept c1 = factory.createConcept(factory.createAnonymousID());
122         Concept c2 = factory.createConcept(factory.createIRI(ns+"testAnonymousSubConceptC1"));
123         c1.addSuperConcept(c2);
124         o.addConcept(c1);
125         o.addConcept(c2);
126         b = w.isValid(o, WSML.WSML_CORE, errors, warnings);
127         assertTrue(b);
128         c1.removeSubConcept(c2);
129     }
130     
131     public void testMutableEntityWithAnonId() throws Exception {
132         //NOK
133         //concept c1 subConceptOf _#
134         //c1.setOntology
135         //_#.setOntology
136         errors.clear();
137         warnings.clear();
138         Ontology o = factory.createOntology(factory.createIRI(ns + getOntLocalName()));
139         Concept c1 = factory.createConcept(factory.createIRI(ns + "myC1"));
140         Concept c2 = factory.createConcept(factory.createAnonymousID());
141         c1.addSuperConcept(c2);
142         c1.setOntology(o);
143         c2.setOntology(o);
144         b = w.isValid(o, WSML.WSML_FULL, errors, warnings); 
145         ve = errors.firstElement();
146 //        printWarning(warnings);
147 //        printError(errors);
148         assertFalse(b);
149         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
150         c1.removeSuperConcept(c2);
151         
152         //NOK
153         //relation r1 subRelationOf _#
154         //r1.setOntology
155         //_#.setOntology
156         errors.clear();
157         warnings.clear();
158         Relation r1 = factory.createRelation(factory.createIRI(ns + "myC1"));
159         Relation r2 = factory.createRelation(factory.createAnonymousID());
160         r1.createParameter((byte) 0);
161         r2.createParameter((byte) 0);
162         r1.addSuperRelation(r2);
163         r1.setOntology(o);
164         r2.setOntology(o);
165         b = w.isValid(o, WSML.WSML_FULL, errors, warnings); 
166         ve = errors.firstElement();
167 //        printWarning(warnings);
168 //        printError(errors);
169         assertFalse(b);
170         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
171         r1.removeSuperRelation(r2);
172     }
173     
174     public void testMutableConcept() throws Exception {  
175         errors.clear();
176         warnings.clear();
177         Relation rel = factory.createRelation(factory.createIRI(ns + "myR1"));
178         ontology.addRelation(rel);
179         Concept concept = factory.createConcept(factory.createAnonymousID());
180         rel.createParameter((byte) 0).addType(concept);        
181         concept.setOntology(ontology);
182         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
183         ve = errors.firstElement();
184 //        printWarning(warnings);
185 //        printError(errors);
186         assertFalse(b);
187         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
188         ontology.removeRelation(rel);
189     }
190     
191     /*
192      * check addSuperConcept method
193      */
194     public void testAddSuperConcept() throws Exception {
195         ontology = factory.createOntology(factory.createIRI(ns + getOntLocalName()));
196         ontology.addConcept(anonC);
197         ontology.addInstance(i1);
198         ontology.addRelation(r1);
199         r1.createParameter((byte) 0);
200         
201         //OK
202         //c1 subConceptOf _#
203         errors.clear();
204         warnings.clear();
205         c1.addSuperConcept(anonC);
206         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
207 //        printWarning(warnings);
208 //        printError(errors);
209         assertTrue(b);
210         c1.removeSuperConcept(anonC);
211         
212         ontology.addConcept(c1);
213         ontology.addConcept(c2);
214 
215         //NOK
216         //concept _# subConceptOf c2
217         //concept c1 subConceptOf _#
218         errors.clear();
219         warnings.clear();
220         anonC.addSuperConcept(c2);
221         c1.addSuperConcept(anonC);
222         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
223         ve = errors.firstElement();
224 //        printWarning(warnings);
225 //        printError(errors);
226         assertFalse(b);
227         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
228         anonC.removeSuperConcept(c2);
229         c1.removeSuperConcept(anonC);
230       
231         ontology.removeConcept(c2);
232         ontology.addConcept(c3);
233         
234         //NOK
235         //concept _# a ofType c3
236         //concept c1 subConceptOf _#
237         errors.clear();
238         warnings.clear();
239         a = anonC.createAttribute(ida);
240         a.addType(c3);
241         c1.addSuperConcept(anonC);
242         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
243         ve = errors.firstElement();
244 //        printWarning(warnings);
245 //        printError(errors);
246         assertFalse(b);
247         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
248         anonC.removeAttribute(a);
249         a.removeType(c3);
250         c1.removeSuperConcept(anonC);
251         
252         ontology.removeConcept(c3);
253         ontology.removeConcept(c1);
254         ontology.addConcept(c2);
255         
256         //NOK
257         //instance i1 memberOf _#
258         //concept _# subConceptOf c2
259         errors.clear();
260         warnings.clear();
261         anonC.addInstance(i1);
262         anonC.addSuperConcept(c2);
263         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
264         ve = errors.firstElement();
265 //        printWarning(warnings);
266 //        printError(errors);
267         assertFalse(b);
268         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
269         anonC.removeInstance(i1);
270         anonC.removeSuperConcept(c2);
271         
272         //NOK
273         //concept _# nfp e#nfp
274         //concept _# subConceptOf c2
275         errors.clear();
276         warnings.clear();
277         anonC.addNFPValue(idnfp,ida);    
278         anonC.addSuperConcept(c2);
279         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
280         ve = errors.firstElement();
281 //        printWarning(warnings);
282 //        printError(errors);
283         assertFalse(b);
284         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
285         anonC.removeNFP(idnfp);
286         anonC.removeSuperConcept(c2);
287         
288         ontology.addConcept(c1);      
289         
290         //NOK
291         //concept c1 subConceptOf _# 
292         //concept c2 subConceptOf _#
293         errors.clear();
294         warnings.clear();
295 //        anonC.addSubConcept(c1);
296         c1.addSuperConcept(anonC);
297         c2.addSuperConcept(anonC);
298         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
299         ve = errors.firstElement();
300 //        printWarning(warnings);
301 //        printError(errors);
302         assertFalse(b);
303         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
304         anonC.removeSubConcept(c1);
305         c2.removeSuperConcept(anonC);
306         
307         //NOK
308         //concept c1 a ofType _# 
309         //concept c2 subConceptOf _#
310         errors.clear();
311         warnings.clear();
312         a =  c1.createAttribute(ida);
313         a.addType(anonC);
314         c2.addSuperConcept(anonC);
315         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
316         ve = errors.firstElement();
317 //        printWarning(warnings);
318 //        printError(errors);
319         assertFalse(b);
320         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
321         c1.removeAttribute(a);
322         a.removeType(anonC);
323         c2.removeSuperConcept(anonC);
324         
325         ontology.removeConcept(c1);
326         
327         //NOK
328         //relation r1(ofType _#) 
329         //concept c2 subConceptOf _#
330         errors.clear();
331         warnings.clear();
332         Parameter p = r1.createParameter((byte)0);
333         p.addType(anonC);
334         c2.addSuperConcept(anonC);
335         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
336         ve = errors.firstElement();
337 //        printWarning(warnings);
338 //        printError(errors);
339         assertFalse(b);
340         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
341         r1.removeParameter((byte)0);
342         p.removeType(anonC);
343         c2.removeSuperConcept(anonC);
344         
345         ontology.removeConcept(c2);
346         ontology.removeRelation(r1);
347         ontology.removeConcept(anonC);
348     }
349 
350     /*
351      * check createAttribute method
352      */
353     public void testConceptAddAttribute() throws Exception {
354         
355         ontology = factory.createOntology(factory.createIRI(ns + getOntLocalName()));
356         
357         //OK
358         //_# a ofType c3
359         errors.clear();
360         warnings.clear();
361         attr = anonC.createAttribute(ida);
362         attr.addType(c3);
363         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
364 //        printWarning(warnings);
365 //        printError(errors);
366         assertTrue(b);
367         attr.removeType(c3);
368         anonC.removeAttribute(attr);
369         
370         ontology.addConcept(anonC);
371         ontology.addConcept(c3);
372         ontology.addConcept(c1);
373         
374         //NOK
375         //_# subConceptOf c1
376         //_# a ofType c3
377         errors.clear();
378         warnings.clear();
379         anonC.addSuperConcept(c1);
380         attr = anonC.createAttribute(ida);
381         attr.addType(c3);
382         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
383         ve = errors.firstElement();
384 //        printWarning(warnings);
385 //        printError(errors);
386         assertFalse(b);
387         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
388         anonC.removeSuperConcept(c1);
389         attr.removeType(c3);
390         anonC.removeAttribute(ida);
391         
392         //NOK        
393         //c1 subConceptOf _#
394         //_# a ofType c3
395         errors.clear();
396         warnings.clear();
397         c1.addSuperConcept(anonC);
398         attr = anonC.createAttribute(ida);
399         attr.addType(c3);
400         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
401         ve = errors.firstElement();
402 //        printWarning(warnings);
403 //        printError(errors);
404         assertFalse(b);
405         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
406         c1.removeSuperConcept(anonC);
407         attr.removeType(c3);
408         anonC.removeAttribute(ida);
409         
410         ontology.removeConcept(c1);
411         ontology.addInstance(i1);
412         
413         //NOK
414         //instance i1 memberOf _#
415         //concept _# a ofType c3
416         errors.clear();
417         warnings.clear();
418         i1.addConcept(anonC);
419         attr = anonC.createAttribute(ida);
420         attr.addType(c3);
421         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
422         ve = errors.firstElement();
423 //        printWarning(warnings);
424 //        printError(errors);
425         assertFalse(b);
426         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
427         i1.removeConcept(anonC);
428         attr.removeType(c3);
429         anonC.removeAttribute(ida);
430         
431         ontology.removeInstance(i1);
432         
433         //NOK
434         //_# nfp e#nfp
435         //_# a ofType c3
436         errors.clear();
437         warnings.clear();
438         anonC.addNFPValue(idnfp,ida);
439         attr = anonC.createAttribute(ida);
440         attr.addType(c3);
441         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
442         ve = errors.firstElement();
443 //        printWarning(warnings);
444 //        printError(errors);
445         assertFalse(b);
446         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
447         anonC.removeNFP(idnfp);
448         attr.removeType(c3);
449         anonC.removeAttribute(ida);
450         
451         ontology.removeConcept(c3);
452         ontology.removeConcept(anonC);
453     }
454     
455     /*
456      * check addtype of parameter 
457      */
458     public void testParemeterAddType() throws Exception {
459         ontology = factory.createOntology(factory.createIRI(ns + getOntLocalName()));
460         ontology.addConcept(c1);
461         ontology.addConcept(anonC);
462         Parameter p = r1.createParameter((byte)0);
463         
464         //OK
465         //relation r1(ofType _#) 
466         errors.clear();
467         warnings.clear();
468         p.addType(anonC);
469         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
470 //        printWarning(warnings);
471 //        printError(errors);
472         assertTrue(b);
473         p.removeType(anonC);
474     
475         ontology.addRelation(r1);
476         
477         //NOK
478         //concept _# subConceptOf c2
479         //relation r1(ofType _#) 
480         errors.clear();
481         warnings.clear();
482         anonC.addSuperConcept(c2);
483         p.addType(anonC);
484         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
485         ve = errors.firstElement();
486 //        printWarning(warnings);
487 //        printError(errors);
488         assertFalse(b);
489         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
490         anonC.removeSuperConcept(c2);
491         p.removeType(anonC);
492         
493         //NOK
494         //concept _# a ofType c3
495         //relation r1(ofType _#) 
496         errors.clear();
497         warnings.clear();
498         Attribute a = anonC.createAttribute(ida);
499         a.addType(c3);
500         p.addType(anonC);
501         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
502         ve = errors.firstElement();
503 //        printWarning(warnings);
504 //        printError(errors);
505         assertFalse(b);
506         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
507         anonC.removeAttribute(a);
508         a.removeType(c3);
509         p.removeType(anonC);
510         
511         //NOK
512         //instance i1 memberOf _#
513         //relation r1(ofType _#) 
514         errors.clear();
515         warnings.clear();
516         anonC.addInstance(i1);
517         p.addType(anonC);
518         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
519         ve = errors.firstElement();
520 //        printWarning(warnings);
521 //        printError(errors);
522         assertFalse(b);
523         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
524         anonC.removeInstance(i1);
525         p.removeType(anonC);
526         
527         //NOK
528         //concept _# nfp e#nfp
529         //relation r1(ofType _#) 
530         errors.clear();
531         warnings.clear();
532         anonC.addNFPValue(idnfp,ida);
533         p.addType(anonC);
534         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
535         ve = errors.firstElement();
536 //        printWarning(warnings);
537 //        printError(errors);
538         assertFalse(b);
539         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
540         anonC.removeNFP(idnfp);
541         p.removeType(anonC);
542         
543         //NOK
544         //concept c1 subConceptOf _# 
545         //relation r1(ofType _#) 
546         errors.clear();
547         warnings.clear();
548         anonC.addSubConcept(c1);
549         p.addType(anonC);
550         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
551         ve = errors.firstElement();
552 //        printWarning(warnings);
553 //        printError(errors);
554         assertFalse(b);
555         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
556         anonC.removeSubConcept(c1);
557         p.removeType(anonC);
558         
559         //NOK
560         //concept c1 a ofType _# 
561         //relation r1(ofType _#) 
562         errors.clear();
563         warnings.clear();
564         a =  c1.createAttribute(ida);
565         a.addType(anonC);
566         p.addType(anonC);
567         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
568         ve = errors.firstElement();
569 //        printWarning(warnings);
570 //        printError(errors);
571         assertFalse(b);
572         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
573         c1.removeAttribute(a);
574         a.removeType(anonC);
575         p.removeType(anonC);
576         
577         //NOK
578         //relation r1(ofType _#, ofType _#) 
579         errors.clear();
580         warnings.clear();
581         Parameter p2 = r1.createParameter((byte)1);
582         p2.addType(anonC);
583         p.addType(anonC);
584         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
585         ve = errors.firstElement();
586 //        printWarning(warnings);
587 //        printError(errors);
588         assertFalse(b);
589         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
590         r1.removeParameter((byte)1);
591         p2.removeType(anonC);
592         p.removeType(anonC);
593         
594         ontology.removeConcept(c1);
595         ontology.removeConcept(anonC);
596         r1.removeParameter(p);
597         ontology.removeRelation(r1);
598     }
599     
600     
601     /*
602      * check Attribute.addType method
603      */
604     public void testAttributeAddType() throws Exception {
605         ontology = factory.createOntology(factory.createIRI(ns + getOntLocalName()));
606         ontology.addConcept(c1);
607         ontology.addConcept(c2);
608         ontology.addConcept(c3);
609         a =  c1.createAttribute(ida);
610         
611         //OK
612         //concept c1 a ofType _# 
613         errors.clear();
614         warnings.clear();
615         a.addType(anonC);
616         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
617 //        printWarning(warnings);
618 //        printError(errors);
619         assertTrue(b);
620         a.removeType(anonC);
621         
622         ontology.addConcept(anonC);
623         
624         //NOK
625         //concept _# subConceptOf c2
626         //concept c1 a ofType _# 
627         errors.clear();
628         warnings.clear();
629         anonC.addSuperConcept(c2);
630         a.addType(anonC);
631         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
632         ve = errors.firstElement();
633 //        printWarning(warnings);
634 //        printError(errors);
635         assertFalse(b);
636         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
637         anonC.removeSuperConcept(c2);
638         a.removeType(anonC);
639         
640         //NOK
641         //concept _# a2 ofType c3
642         //concept c1 a ofType _# 
643         errors.clear();
644         warnings.clear();
645         Attribute a2 = anonC.createAttribute(ida);
646         a2.addType(c3);
647         a.addType(anonC);
648         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
649         ve = errors.firstElement();
650 //        printWarning(warnings);
651 //        printError(errors);
652         assertFalse(b);
653         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
654         a2.removeType(c3);  
655         anonC.removeAttribute(a2);
656         a.removeType(anonC);
657         
658         
659         //NOK
660         //concept c1 a ofType _# 
661         //concept _# a2 ofType c3
662         errors.clear();
663         warnings.clear();
664         a.addType(anonC);   
665         attr = anonC.createAttribute(ida);
666         attr.addType(c3);
667         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
668         ve = errors.firstElement();
669 //        printWarning(warnings);
670 //        printError(errors);
671         assertFalse(b);
672         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
673         a.removeType(anonC);
674         anonC.removeAttribute(ida);
675         
676         //NOK
677         //instance i1 memberOf _#
678         //concept c1 a ofType _# 
679         errors.clear();
680         warnings.clear();
681         anonC.addInstance(i1);
682         a.addType(anonC);
683         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
684         ve = errors.firstElement();
685 //        printWarning(warnings);
686 //        printError(errors);
687         assertFalse(b);
688         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
689         anonC.removeInstance(i1);
690         a.removeType(anonC);
691         
692         //NOK
693         //concept _# nfp e#nfp
694         //concept c1 a ofType _# 
695         errors.clear();
696         warnings.clear();
697         anonC.addNFPValue(idnfp,ida);
698         a.addType(anonC);
699         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
700         ve = errors.firstElement();
701 //        printWarning(warnings);
702 //        printError(errors);
703         assertFalse(b);
704         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
705         anonC.removeNFP(idnfp);
706         a.removeType(anonC);
707         
708         //NOK
709         //concept c1 subConceptOf _# 
710         //concept c1 a ofType _# 
711         errors.clear();
712         warnings.clear();
713         anonC.addSubConcept(c1);
714         a.addType(anonC);
715         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
716         ve = errors.firstElement();
717 //        printWarning(warnings);
718 //        printError(errors);
719         assertFalse(b);
720         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
721         anonC.removeSubConcept(c1);
722         a.removeType(anonC);
723         
724         //NOK
725         //concept c2 a3 ofType _# 
726         //concept c1 a ofType _# 
727         errors.clear();
728         warnings.clear();
729         Attribute a3 =  c2.createAttribute(ida);
730         a.addType(anonC);
731         a3.addType(anonC);
732         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
733         ve = errors.firstElement();
734 //        printWarning(warnings);
735 //        printError(errors);
736         assertFalse(b);
737         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
738         c2.removeAttribute(a3);
739         a.removeType(anonC);
740         a3.removeType(anonC);
741         
742         ontology.addRelation(r1);
743         
744         //NOK
745         //relation r1(ofType _#) 
746         //concept c1 a ofType _# 
747         errors.clear();
748         warnings.clear();
749         Parameter p = r1.createParameter((byte)0);
750         p.addType(anonC);
751         a.addType(anonC);
752         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
753         ve = errors.firstElement();
754 //        printWarning(warnings);
755 //        printError(errors);
756         assertFalse(b);
757         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
758         r1.removeParameter((byte)0);
759         p.removeType(anonC);   
760         a.removeType(anonC);
761         
762         c1.removeAttribute(a);
763         ontology.removeRelation(r1);
764         ontology.removeConcept(c1);
765         ontology.removeConcept(c2);
766         ontology.removeConcept(c3);
767         ontology.removeConcept(anonC);
768     }   
769     
770     /*
771      * check Instance addConcept method
772      */
773     public void testAddMemberOf() throws Exception {
774         ontology = factory.createOntology(factory.createIRI(ns + getOntLocalName()));
775         ontology.addConcept(c1);
776         Instance i2 = factory.createInstance(factory.createIRI(ns+"i2"));
777         ontology.addInstance(i2);
778         ontology.addInstance(i1);
779         
780         //OK
781         //i2 memberOf _#
782         errors.clear();
783         warnings.clear();
784         i2.addConcept(anonC);
785         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
786 //        printWarning(warnings);
787 //        printError(errors);
788         assertTrue(b);
789         i2.removeConcept(anonC);
790         
791         ontology.addConcept(anonC);
792         
793         //NOK
794         //concept _# subConceptOf c2
795         //i2 memberOf _#
796         errors.clear();
797         warnings.clear();
798         anonC.addSuperConcept(c2);
799         i2.addConcept(anonC);
800         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
801         ve = errors.firstElement();
802 //        printWarning(warnings);
803 //        printError(errors);
804         assertFalse(b);
805         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
806         anonC.removeSuperConcept(c2);
807         i2.removeConcept(anonC);
808         
809         //NOK
810         //concept _# a ofType c3
811         //i2 memberOf _#
812         errors.clear();
813         warnings.clear();
814         Attribute a = anonC.createAttribute(ida);
815         a.addType(c3);
816         i2.addConcept(anonC);
817         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
818         ve = errors.firstElement();
819 //        printWarning(warnings);
820 //        printError(errors);
821         assertFalse(b);
822         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
823         anonC.removeAttribute(a);
824         a.removeType(c3);
825         i2.removeConcept(anonC);
826         
827         //NOK
828         //instance i1 memberOf _#
829         //instance i2 memberOf _#
830         errors.clear();
831         warnings.clear();
832         anonC.addInstance(i1);
833         i2.addConcept(anonC);
834         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
835         ve = errors.firstElement();
836 //        printWarning(warnings);
837 //        printError(errors);
838         assertFalse(b);
839         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
840         anonC.removeInstance(i1);
841         i2.removeConcept(anonC);
842         
843         //NOK
844         //concept _# nfp e#nfp
845         //i2 memberOf _#
846         errors.clear();
847         warnings.clear();
848         anonC.addNFPValue(idnfp,ida);
849         i2.addConcept(anonC);
850         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
851         ve = errors.firstElement();
852 //        printWarning(warnings);
853 //        printError(errors);
854         assertFalse(b);
855         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
856         anonC.removeNFP(idnfp);
857         i2.removeConcept(anonC);
858         
859         //NOK
860         //concept c1 subConceptOf _# 
861         //i2 memberOf _#
862         errors.clear();
863         warnings.clear();
864         anonC.addSubConcept(c1);
865         i2.addConcept(anonC);
866         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
867         ve = errors.firstElement();
868 //        printWarning(warnings);
869 //        printError(errors);
870         assertFalse(b);
871         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
872         anonC.removeSubConcept(c1);
873         i2.removeConcept(anonC);
874         
875         //NOK
876         //concept c1 a ofType _# 
877         //i2 memberOf _#
878         errors.clear();
879         warnings.clear();
880         a =  c1.createAttribute(ida);
881         a.addType(anonC);
882         i2.addConcept(anonC);
883         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
884         ve = errors.firstElement();
885 //        printWarning(warnings);
886 //        printError(errors);
887         assertFalse(b);
888         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
889         c1.removeAttribute(a);
890         a.removeType(anonC);
891         i2.removeConcept(anonC);
892         
893         ontology.addRelation(r1);
894         
895         //NOK
896         //relation r1(ofType _#) 
897         //i2 memberOf _#
898         errors.clear();
899         warnings.clear();
900         Parameter p = r1.createParameter((byte)0);
901         p.addType(anonC);
902         i2.addConcept(anonC);
903         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
904         ve = errors.firstElement();
905 //        printWarning(warnings);
906 //        printError(errors);
907         assertFalse(b);
908         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
909         r1.removeParameter((byte)0);
910         p.removeType(anonC); 
911         i2.removeConcept(anonC);
912         
913         ontology.removeRelation(r1);
914         ontology.removeConcept(c1);
915         ontology.removeConcept(anonC);
916         ontology.removeInstance(i1);
917         ontology.removeInstance(i2);
918     }
919     
920     /*
921      * check Instance addAttributeValue method
922      */
923     public void testAddValueAttribute() throws Exception {
924         ontology = factory.createOntology(factory.createIRI(ns + getOntLocalName()));
925         Instance i4 = factory.createInstance(factory.createIRI(ns+"i4"));
926         IRI attr = factory.createIRI(ns + "attribute");      
927 
928         ontology.addInstance(i1);
929         ontology.addInstance(anonI);
930         
931         //OK
932         //instance i4 a4 hasValue _#
933         errors.clear();
934         warnings.clear();
935         i4.addAttributeValue(attr,anonI);
936         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
937 //        printWarning(warnings);
938 //        printError(errors);
939         assertTrue(b);
940         i4.removeAttributeValues(attr);
941 
942         ontology.addInstance(i4);
943         
944         //NOK
945         //instance _# a4 hasValue i1 
946         //instance i4 a4 hasValue _#
947         errors.clear();
948         warnings.clear();
949         anonI.addAttributeValue(attr,i1);
950         i4.addAttributeValue(attr,anonI);
951         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
952         ve = errors.firstElement();
953 //        printWarning(warnings);
954 //        printError(errors);
955         assertFalse(b);
956         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
957         anonI.removeAttributeValues(attr);
958         i4.removeAttributeValues(attr);
959 
960         //NOK
961         //instance _# memberOf c1 
962         //instance i4 a4 hasValue _#
963         errors.clear();
964         warnings.clear();
965         anonI.addConcept(c1);
966         i4.addAttributeValue(attr,anonI);
967         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
968         ve = errors.firstElement();
969 //        printWarning(warnings);
970 //        printError(errors);
971         assertFalse(b);
972         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
973         anonI.removeConcept(c1);
974         i4.removeAttributeValues(attr);
975         
976         //NOK
977         //instance _# nfp idnfp hasValue i1 endNfp
978         //instance i4 a4 hasValue _#
979         errors.clear();
980         warnings.clear();
981         anonI.addNFPValue(idnfp, i1);
982         i4.addAttributeValue(attr,anonI);
983         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
984         ve = errors.firstElement();
985 //        printWarning(warnings);
986 //        printError(errors);
987         assertFalse(b);
988         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
989         anonI.removeNFP(idnfp);
990         i4.removeAttributeValues(attr);
991         
992         ontology.removeInstance(anonI);
993         ontology.removeInstance(i1);
994         ontology.removeInstance(i4);
995     }
996     
997     /*
998      * check Relation setParameterValue method
999      */
1000     public void testAddValueParameter() throws Exception {
1001         ontology = factory.createOntology(factory.createIRI(ns + getOntLocalName()));
1002         IRI attr = factory.createIRI(ns + "attribute");   
1003         Relation r4 = factory.createRelation(factory.createIRI(ns+"r4"));
1004         r4.createParameter((byte)0);
1005         RelationInstance ri4 = factory.createRelationInstance(r4);
1006         
1007         ontology.addRelation(r4);
1008         ontology.addRelationInstance(ri4);
1009         
1010         //OK
1011         //relationInstance r4(_#)
1012         errors.clear();
1013         warnings.clear();
1014         ri4.setParameterValue((byte)0,anonI);
1015         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
1016 //        printWarning(warnings);
1017 //        printError(errors);
1018         assertTrue(b);
1019         ri4.setParameterValue((byte)0,null);
1020         
1021         ontology.addInstance(anonI);
1022         
1023         //NOK
1024         //instance _# a4 hasValue i1 
1025         //relationInstance r4(_#)
1026         errors.clear();
1027         warnings.clear();
1028         anonI.addAttributeValue(attr,i1);
1029         ri4.setParameterValue((byte)0,anonI);
1030         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
1031         ve = errors.firstElement();
1032 //        printWarning(warnings);
1033 //        printError(errors);
1034         assertFalse(b);
1035         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
1036         anonI.removeAttributeValues(attr);
1037         ri4.setParameterValue((byte)0,null);
1038 
1039         //NOK
1040         //instance _# memberOf c1 
1041         //relationInstance r4(_#)
1042         errors.clear();
1043         warnings.clear();
1044         anonI.addConcept(c1);
1045         ri4.setParameterValue((byte)0,anonI);
1046         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
1047         ve = errors.firstElement();
1048 //        printWarning(warnings);
1049 //        printError(errors);
1050         assertFalse(b);
1051         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
1052         anonI.removeConcept(c1);
1053         ri4.setParameterValue((byte)0,null);
1054         
1055         //NOK
1056         //instance _# nfp idnfp hasValue i1 endNfp
1057         //relationInstance r4(_#)
1058         errors.clear();
1059         warnings.clear();
1060         anonI.addNFPValue(idnfp, i1);
1061         ri4.setParameterValue((byte)0,anonI);
1062         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
1063         ve = errors.firstElement();
1064 //        printWarning(warnings);
1065 //        printError(errors);
1066         assertFalse(b);
1067         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
1068         anonI.removeNFP(idnfp);
1069         ri4.setParameterValue((byte)0,null);
1070         
1071         ontology.removeRelation(r4);
1072         ontology.removeRelationInstance(ri4);
1073         ontology.removeInstance(anonI);
1074     }
1075     
1076     /*
1077      * check addSuperRelation method
1078      */
1079     public void testAddSuperRelation() throws Exception {
1080         ontology = factory.createOntology(factory.createIRI(ns + getOntLocalName()));
1081         Relation anonR = factory.createRelation(factory.createAnonymousID());
1082         Relation r3 = factory.createRelation(factory.createIRI(ns + "r3"));
1083         r1.createParameter((byte) 0);
1084         r3.createParameter((byte) 0);
1085         anonR.createParameter((byte) 0);
1086         Parameter p;
1087         ontology.addRelation(r3);
1088         ontology.addRelation(anonR);
1089         
1090         //OK
1091         //relation r1 subRelationOf anonR
1092         errors.clear();
1093         warnings.clear();
1094         r1.addSuperRelation(anonR);
1095         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
1096 //        printWarning(warnings);
1097 //        printError(errors);
1098         assertTrue(b);
1099         r1.removeSuperRelation(anonR);
1100         
1101         ontology.addRelation(r1);
1102         
1103         //NOK
1104         //relation _# subRelationOf r3
1105         //relation r1 subRelationOf _#
1106         errors.clear();
1107         warnings.clear();
1108         anonR.addSuperRelation(r3);
1109         r1.addSuperRelation(anonR);
1110         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
1111         ve = errors.firstElement();
1112 //        printWarning(warnings);
1113 //        printError(errors);
1114         assertFalse(b);
1115         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
1116         anonR.removeSuperRelation(r3);
1117         r1.removeSuperRelation(anonR);
1118         
1119         //NOK
1120         //relation anonR(ofType c1)
1121         //relation r1 subRelationOf anonR
1122         errors.clear();
1123         warnings.clear();
1124         p = anonR.createParameter((byte) 0);
1125         p.addType(c1);
1126         r1.addSuperRelation(anonR);
1127         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
1128         ve = errors.firstElement();
1129 //        printWarning(warnings);
1130 //        printError(errors);
1131         assertFalse(b);
1132         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
1133         anonR.removeParameter((byte) 0);
1134         p.removeType(c1);
1135         r1.removeSuperRelation(anonR);
1136         
1137         //NOK
1138         //relation r1(ofType _#) 
1139         //relation r3 subRelationOf r1 
1140         errors.clear();
1141         warnings.clear();
1142         p = r1.createParameter((byte)0);
1143         anonR.createParameter((byte) 0);
1144         p.addType(anonC);
1145         r3.addSuperRelation(r1);
1146         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
1147         ve = errors.firstElement();
1148 //        printWarning(warnings);
1149 //        printError(errors);
1150         assertFalse(b);
1151         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
1152         r1.removeParameter((byte)0);
1153         p.removeType(anonC);     
1154         r3.removeSuperRelation(r1);
1155         
1156         //NOK
1157         //relation _# nfp e#nfp
1158         //_# subRelationOf r1
1159         errors.clear();
1160         warnings.clear();
1161         r1.createParameter((byte) 0);
1162         anonR.addNFPValue(idnfp,ida);
1163         anonR.addSuperRelation(r1);
1164         anonR.createParameter((byte) 0);
1165         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
1166         ve = errors.firstElement();
1167 //        printWarning(warnings);
1168 //        printError(errors);
1169         assertFalse(b);
1170         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
1171         anonR.removeNFP(idnfp);
1172         anonR.removeSuperRelation(r1);
1173         
1174         //NOK
1175         //relation _# subRelationOf r1 
1176         //relation _# subRelationOf r3
1177         errors.clear();
1178         warnings.clear();
1179         anonR.addSuperRelation(r1);
1180         anonR.addSuperRelation(r3);
1181         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
1182         ve = errors.firstElement();
1183 //        printWarning(warnings);
1184 //        printError(errors);
1185         assertFalse(b);
1186         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
1187         anonR.removeSuperRelation(r1);
1188         anonR.removeSuperRelation(r3);
1189         
1190         //NOK
1191         //relation r1 subRelationOf _# 
1192         //relation r3 subRelationOf _#
1193         errors.clear();
1194         warnings.clear();
1195         anonR.addSubRelation(r1);
1196         r3.addSuperRelation(anonR);
1197         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
1198         ve = errors.firstElement();
1199 //        printWarning(warnings);
1200 //        printError(errors);
1201         assertFalse(b);
1202         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
1203         anonR.removeSubRelation(r1);
1204         r3.removeSuperRelation(anonR);
1205 
1206         ontology.removeRelation(r1);
1207         ontology.removeRelation(r3);
1208         ontology.removeRelation(anonR);
1209     }
1210     
1211     /*
1212      * check createRelationInstance method
1213      */
1214     public void testCreateRelationInstance() throws Exception {
1215         ontology = factory.createOntology(factory.createIRI(ns + getOntLocalName()));
1216         
1217         //NOK
1218         //relation _#
1219         //relationInstance r4(_#)
1220         errors.clear();
1221         warnings.clear();
1222         Relation anonR = factory.createRelation(factory.createAnonymousID());
1223         anonR.createParameter((byte) 0);
1224         ontology.addRelation(anonR);
1225         RelationInstance ri = factory.createRelationInstance(anonR);
1226         ontology.addRelationInstance(ri);
1227         b = w.isValid(ontology, WSML.WSML_FULL, errors, warnings); 
1228         ve = errors.firstElement();
1229 //        printWarning(warnings);
1230 //        printError(errors);
1231         assertFalse(b);
1232         assertTrue(ve.getReason().startsWith(ValidationErrorImpl.ANON_ID_ERR));
1233         anonR.removeRelationInstance(ri);
1234     }
1235     
1236 }
1237 
1238 /*
1239  * $Log$
1240  * Revision 1.10  2007/04/02 12:13:23  morcen
1241  * Generics support added to wsmo-api, wsmo4j and wsmo-test
1242  *
1243  * Revision 1.9  2006/03/28 14:04:38  nathaliest
1244  * *** empty log message ***
1245  *
1246  * Revision 1.8  2006/03/28 14:03:13  nathaliest
1247  * *** empty log message ***
1248  *
1249  * Revision 1.7  2006/03/28 13:57:36  nathaliest
1250  * added validator anonId tests to wsmo4jTests
1251  *
1252  * Revision 1.6  2006/03/28 08:16:53  vassil_momtchev
1253  * another new test another new error (please test better!)
1254  *
1255  * Revision 1.5  2006/03/28 07:56:16  nathaliest
1256  * fix
1257  *
1258  * Revision 1.4  2006/03/28 07:28:45  vassil_momtchev
1259  * new test added
1260  *
1261  * Revision 1.3  2006/03/27 16:35:02  nathaliest
1262  * changed anonId check
1263  *
1264  * Revision 1.2  2006/03/27 08:20:29  vassil_momtchev
1265  * new test added
1266  *
1267  * Revision 1.1  2006/03/23 16:12:14  nathaliest
1268  * moving the anon Id check to the validator
1269  *
1270  * Revision 1.7  2006/02/27 15:28:09  nathaliest
1271  * fixed anonId check
1272  *
1273  * Revision 1.6  2006/02/27 13:50:26  vassil_momtchev
1274  * testMutableEntityWithAnonId() modified to fail again
1275  *
1276  * Revision 1.5  2006/02/27 10:23:12  nathaliest
1277  * added new tests
1278  *
1279  * Revision 1.4  2006/02/23 10:28:16  vassil_momtchev
1280  * another test added
1281  *
1282  * Revision 1.3  2006/02/23 09:50:35  vassil_momtchev
1283  * new test added
1284  *
1285  * Revision 1.2  2006/02/13 22:45:53  nathaliest
1286  * added test cases
1287  *
1288  * Revision 1.1  2006/02/13 09:21:21  nathaliest
1289  * added AnonIds Check
1290  *
1291  */