Source code: Database/OJBDatabaseMgrTest.java
1 /*--- formatted by Jindent 2.1, (www.c-lab.de/~jindent) ---*/
2
3 package Database;
4
5 import java.util.*;
6 import junit.framework.*;
7 import org.omg.DsObservationAccess.*;
8 import gov.lanl.COAS.*;
9 import gov.lanl.COAS.ojb.*;
10 import gov.lanl.Database.*;
11 import gov.lanl.Utility.*;
12 /**
13 * JUnit test class for OJBDatabaseMgr
14 *
15 *
16 * @author koenig
17 * @version $Revision: 1.5 $ $Date: 2001/10/05 20:30:23 $
18 */
19
20 /**
21 * ***********************************
22 * Copyright Notice
23 * Copyright (c) 1999, Regents of the University of California. All rights reserved.
24 *
25 * DISCLAIMER
26 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS
27 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
28 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
29 * SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
30 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
31 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
32 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
33 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
34 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
35 * DAMAGE.
36 * ************************************
37 */
38
39 public class OJBDatabaseMgrTest extends TestCase {
40
41 // the database manager
42 DatabaseMgr dbMgr;
43
44 // the persistent object factory
45 PersistentObjectFactory persObjFact;
46
47 // the test data (don't change it in any of the test methods!)
48 PersistentObject[] obsData_Seq;
49
50 // the mapper
51 static Qualifier2AttributeMapper mapper;
52
53 // the test data file to use
54 static String loadFile = "TestObsData.xml";
55 // the type of the database
56 static String databaseType = "OJB";
57 // the url to the database
58 static String databaseURL = "config//repository.xml";
59 // the persistent object to use
60 static String persistentProperties = "persistent.properties";
61
62 // QualifiedCode 2 DBField mapping
63 static String personIdCode = "DNS:omg.org/DSObservationAccess/HL72.3/PID/PatientIDInternalID";
64 static String startTimeCode = "DNS:omg.org/DSObservationAccess/HL72.3/OBR/ObservationDate_Time";
65 static String stopTimeCode = "DNS:omg.org/DSObservationAccess/HL72.3/OBR/ObservationEndDate_Time";
66 static String signingCode = "DNS:OpenEMed.org/QualifierCode/SigningInformation";
67
68 // the parser to use (HL7 / String)
69 static String parserName = "HL7";
70
71 // create an empty object (database manager will retrieve appropriate class depending on this object)
72 static PersistentObject emptyObsData_ = null;
73
74 ConfigProperties props;
75
76
77 /**
78 * Constructor declaration
79 *
80 *
81 * @param testName
82 *
83 * @see
84 */
85 public OJBDatabaseMgrTest(java.lang.String testName) {
86 super(testName);
87 init();
88 }
89
90 /**
91 * Method declaration
92 *
93 *
94 * @param args
95 *
96 * @see
97 */
98 public static void main(java.lang.String[] args) {
99 if (args.length >= 2) {
100 if (args[0].equals("-repository")) {
101 databaseURL = args[1];
102 }
103 }
104 junit.textui.TestRunner.run(suite());
105 }
106
107 /**
108 * Method declaration
109 *
110 *
111 * @return
112 *
113 * @see
114 */
115 public static Test suite() {
116 return new TestSuite(OJBDatabaseMgrTest.class);
117 }
118
119
120 /**
121 * Test of retrieveElement method, of class gov.lanl.Database.OJBDatabaseMgr.
122 */
123 public void testRetrieveElement() {
124 System.out.println();
125 System.out.println("testRetrieveElement");
126
127
128 // the original variables
129 PersistentObject obsData_1 = obsData_Seq[0];
130
131 // the retrieved variables
132 PersistentObject obsData_1r;
133
134 try {
135 // test 1 : retrieve the object by obsId
136 String obsId = obsData_1.getObjectId();
137 System.out.println("retrieving object by obsId '" + obsId + "'");
138 dbMgr.txn_begin();
139 obsData_1r =(PersistentObject)dbMgr.retrieveElement( emptyObsData_, "obsId", obsId);
140 assertEquals( "Objects should been the same obsId after retrieval", obsData_1.getObjectId(), obsData_1r.getObjectId());
141 dbMgr.txn_commit();
142 System.out.println("done");
143
144
145 } catch (Throwable e) {
146 fail( e.getMessage());
147 }
148 }
149
150
151
152 /**
153 * Test of retrieveElement method, of class gov.lanl.Database.OJBDatabaseMgr.
154 */
155 public void testRetrieveElementDeep() {
156 System.out.println();
157 System.out.println("testRetrieveElement (deep/shallow)");
158
159 // the original variables
160 PersistentObject obsData_1 = obsData_Seq[0];
161
162 // the retrieved variables
163 AbstractObservationData_ obsData_1r;
164
165
166 int flag = 0;
167 String flagStr = "";
168
169 try {
170 // run test twice with flag=DEEP and flag=SHALLOW
171 for (int i=0; i<2; i++) {
172 switch (i) {
173 case 0: {
174 flag = dbMgr.SHALLOW;
175 flagStr = "SHALLOW";
176 break;
177 }
178 case 1: {
179 flag = dbMgr.DEEP;
180 flagStr = "DEEP";
181 break;
182 }
183 }
184
185
186
187 // test 1 : retrieve the object by obsId
188 String obsId = obsData_1.getObjectId();
189 System.out.println("retrieving object by obsId '" + obsId + "' (" + flagStr + ")");
190 dbMgr.txn_begin();
191 obsData_1r =(AbstractObservationData_)dbMgr.retrieveElement( emptyObsData_, "obsId", obsId, flag );
192 assertEquals( "Objects should been the same obsId after retrieval", obsData_1.getObjectId(), obsData_1r.getObjectId());
193
194 Iterator compIterator = obsData_1r.getComposites();
195 if (flag == dbMgr.DEEP) {
196 assertTrue("Composite vector is empty (" + flagStr + "-retrieval)", compIterator.hasNext() == true);
197 } else {
198 assertTrue("Composite vector isn't empty (" + flagStr + "-retrieval)", compIterator.hasNext() == false);
199 }
200
201 dbMgr.txn_commit();
202 System.out.println("done");
203
204 flag = dbMgr.DEEP;
205 }
206 } catch (Throwable e) {
207 fail( e.getMessage());
208 }
209 }
210
211
212
213 /**
214 * Test of updateElement method, of class gov.lanl.Database.OJBDatabaseMgr.
215 */
216 public void testUpdateElement() {
217 System.out.println();
218 System.out.println("testUpdateElement");
219 // the original variables
220 AbstractObservationData_ obsData_3 = (AbstractObservationData_)obsData_Seq[3];
221
222 // the retrieved variables
223 AbstractObservationData_ obsData_3r;
224
225 try {
226 // test 1 : change the code of an observation
227 String obsId = obsData_3.getObjectId();
228
229 String oldCode = obsData_3.code;
230 String newCode = "99999";
231 //String newCode = "DNS:OpenEMed.org/NEW_CODE";
232 System.out.println("Changing code from '" + oldCode + "' to '" + newCode + "' for observation '" + obsId + "'");
233 obsData_3.code = newCode;
234
235 dbMgr.txn_begin();
236 dbMgr.updateElement( obsData_3);
237 dbMgr.txn_commit();
238
239 // retrieve the element to check if update was ok
240 System.out.println("retrieving object '" + obsId + "'");
241
242 dbMgr.txn_begin();
243 obsData_3r =(AbstractObservationData_)dbMgr.retrieveElement( emptyObsData_, "obsId", obsId);
244 assertEquals( "Object should been the new code after retrieval", obsData_3r.code, newCode);
245 dbMgr.txn_commit();
246 System.out.println("done");
247
248
249 } catch (Throwable e) {
250 fail( e.getMessage());
251 }
252 }
253
254 /**
255 * Test of deleteElement method, of class gov.lanl.Database.OJBDatabaseMgr.
256 */
257 public void testDeleteElement() {
258 System.out.println();
259 System.out.println("testDeleteElement");
260
261 // the original variables
262 AbstractObservationData_ obsData_2 = (AbstractObservationData_)obsData_Seq[2];
263
264 // the retrieved variables
265 AbstractObservationData_ obsData_2r = null;
266
267 try {
268 String obsId = obsData_2.getObjectId();
269 try {
270 System.out.println( "deleting '" + obsId + "'");
271 dbMgr.txn_begin();
272 dbMgr.deleteElement( obsData_2);
273 dbMgr.txn_commit();
274
275 } catch (Throwable e) {
276 fail( e.getMessage());
277 }
278
279 try {
280 System.out.println( "trying to retrieve '" + obsId + "'");
281
282 dbMgr.txn_begin();
283 obsData_2r =(AbstractObservationData_)dbMgr.retrieveElement( emptyObsData_, "obsId", obsId);
284 dbMgr.txn_commit();
285 } catch (DBException e) {
286 dbMgr.txn_abort();
287 }
288
289 assertNull( "Object should be null", obsData_2r);
290 System.out.println("done");
291
292 } catch (NoObjectIdException e) {
293 fail( e.getMessage());
294 }
295 }
296
297
298 /**
299 * Test of insertElement method, of class gov.lanl.Database.OJBDatabaseMgr.
300 */
301 public void testInsertElement() {
302 System.out.println();
303 System.out.println("testInsertElement");
304
305 // the original variables
306 AbstractObservationData_ obsData_2 = (AbstractObservationData_)obsData_Seq[2];
307
308 // the retrieved variables
309 AbstractObservationData_ obsData_2r = null;
310
311 org.omg.CORBA.Any[] value = new org.omg.CORBA.Any[] {
312 org.omg.CORBA.ORB.init().create_any() };
313 value[0].insert_string( "INSERTION_TEST");
314
315 ObservationDataStruct obsData = new ObservationDataStruct( "DNS:OpenEMed.org/INSERTION",
316 new ObservationDataStruct[0], new ObservationDataStruct[0], value);
317
318 // the object to insert
319 AbstractObservationData_ obsData_2i = (AbstractObservationData_) persObjFact.createPersistentObject(obsData);
320
321
322 // test 1 :
323 try {
324 String obsId = obsData_2i.getObjectId();
325 try {
326 // object already in the database?
327 dbMgr.txn_begin();
328 obsData_2r =(AbstractObservationData_)dbMgr.retrieveElement( emptyObsData_, "obsId", obsId);
329 if (obsData_2r != null)
330 dbMgr.deleteElement( obsData_2r);
331 dbMgr.txn_commit();
332 } catch (DBException e) {
333 // normal case
334 dbMgr.txn_abort();
335 }
336
337 // insert the object into the database
338 try {
339 System.out.println( "inserting '" + obsId + "' into database");
340 dbMgr.txn_begin();
341 dbMgr.insertElement( obsData_2i, null);
342 dbMgr.txn_commit();
343
344 System.out.println( "done! - Retrieving object...");
345 dbMgr.txn_begin();
346 obsData_2r = null;
347 obsData_2r =(AbstractObservationData_)dbMgr.retrieveElement( emptyObsData_, "obsId", obsId);
348
349 assertEquals( "Objects should been the same after insertion", obsData_2r.getObjectId(), obsData_2i.getObjectId());
350 dbMgr.txn_commit();
351
352 // clean up
353 System.out.println("Deleting '" + obsId + "' from database" );
354
355 dbMgr.txn_begin();
356 dbMgr.deleteElement( obsData_2r);
357 dbMgr.txn_commit();
358
359 } catch (Throwable e) {
360 fail( e.getMessage());
361 } finally {
362 System.out.println("done");
363 }
364 } catch (NoObjectIdException e) {
365 fail( e.getMessage());
366 }
367 }
368
369
370 /**
371 * Test of accessElements method, of class gov.lanl.Database.OJBDatabaseMgr.
372 */
373 public void testAccessElements() {
374 System.out.println();
375 System.out.println("testAccessElements");
376
377 // get a CodeMapper instance
378 CodeMapper codeMapper = CodeMapper.getInstance();
379 // the retrieved variables
380 AbstractObservationData_ obsData_r;
381 AbstractObservationData_ obsData_a;
382
383 try {
384 // get the id for this code from the codeMapper.getId
385 String codeId = codeMapper.getId( "DNS:OpenEMed.org/TraitCode/Summary", true, false); // parameters: code, isTopLevel, addToCodeList
386 Hashtable table = new Hashtable();
387 table.put( "code", codeId);
388 table.put( "personId", "DNS:OpenEMed.org////10005");
389 // create a new filter
390 SearchFilter filter = DBMgrFactory.createFilter();
391 filter.matchSet( table, SearchFilter.AND, SearchFilter.EQUAL);
392
393 dbMgr.txn_begin();
394 Vector result = dbMgr.retrieveElements( emptyObsData_, filter, dbMgr.SHALLOW);
395
396 assertNotNull( "Result set is null", result);
397 obsData_r = (AbstractObservationData_)result.firstElement();
398
399 assertNotNull( "Object is null after retrieval", obsData_r);
400 Iterator compIterator = obsData_r.getComposites();
401 assertTrue("The composite vector should be empty after SHALLOW retrieval", compIterator.hasNext() == false );
402
403
404 // test the accessElements method
405 result = dbMgr.accessElements( obsData_r, null, null);
406 obsData_a = (AbstractObservationData_)result.firstElement();
407
408 assertNotNull( "Objects is null after retrieval", obsData_a);
409 compIterator = obsData_a.getComposites();
410 assertTrue("The composite vector should not be empty after accessElements", compIterator.hasNext() == false );
411
412 dbMgr.txn_commit();
413 System.out.println("done");
414
415 } catch (Throwable e) {
416 fail( e.getMessage());
417 }
418 }
419
420 /**
421 * Test of retrieveElements method, of class gov.lanl.Database.OJBDatabaseMgr.
422 */
423 public void testRetrieveElementsByVector() {
424 System.out.println();
425 System.out.println("testRetrieveElements for 'dbMgr.retrieveElements(Object obj, String[] elements, String[] name)'");
426
427 // get a CodeMapper instance
428 CodeMapper codeMapper = CodeMapper.getInstance();
429 try {
430
431 // test 1:
432 // get the id for this code from the codeMapper
433 String codeId = codeMapper.getId( "DNS:OpenEMed.org/TraitCode/Summary", true, true); // parameters: code, isTopLevel, addToCodeList
434
435 String[] elements = new String[2];
436 String[] values = new String[2];
437 elements[0] = "code";
438 elements[1] = "personId";
439 values[0] = codeId;
440 values[1] = "DNS:OpenEMed.org////10006";
441
442 System.out.println("retrieving objects with filter vector ");
443 dbMgr.txn_begin();
444 Vector result = dbMgr.retrieveElements( emptyObsData_, elements, values);
445
446 // result vector should have 2 entries
447 int size = result.size();
448 assertEquals( "The result vector is not oft the expected size", size, 2);
449 dbMgr.txn_commit();
450 System.out.println("done");
451
452
453
454 // test 2:
455 elements = new String[2];
456 values = new String[2];
457 elements[0] = "code";
458 elements[1] = "personId";
459 values[0] = codeMapper.getId( "DNS:OpenEMed.org/TraitCode/Summary", true, false); // parameters: code, isTopLevel, addToCodeList
460 values[1] = "DNS:OpenEMed.org////10005";
461
462 System.out.println("retrieving objects with filter vector ");
463 dbMgr.txn_begin();
464 result = dbMgr.retrieveElements( emptyObsData_, elements, values);
465
466 // result vector should have 1 entries
467 assertEquals( "The result vector is not of the expected size", result.size(), 1);
468 dbMgr.txn_commit();
469 System.out.println("done");
470
471
472 } catch (Throwable e) {
473 fail( e.getMessage());
474 }
475 }
476
477
478 /**
479 * Test of retrieveElements method, of class gov.lanl.Database.OJBDatabaseMgr.
480 */
481 public void testRetrieveElementsByFilter() {
482 System.out.println();
483 System.out.println("testRetrieveElements for 'dbMgr.retrieveElements(Object obj, SearchFilter query, int deep)'");
484
485 int filterTests = 12;
486
487 // the filter to use
488 SearchFilter filter = DBMgrFactory.createFilter();
489 // the expected elements in the result set
490 int resultElements = 0;
491 // first iteration with deep parameter set to true
492 int deep = dbMgr.SHALLOW;
493
494
495 for (int j=0; j<2; j++) {
496 // iterate through the test with different filters
497 for (int i=0; i<filterTests; i++) {
498 // clear object cache
499 ojb.broker.cache.ObjectCacheFactory.getObjectCache().clear();
500
501 resultElements = getFilter( filter, i);
502 try {
503 System.out.println("retrieving objects with search filter " + filter.toString());
504 dbMgr.txn_begin();
505 Vector result = dbMgr.retrieveElements( emptyObsData_, filter, deep);
506
507 assertNotNull( "Result set is null", result);
508 assertTrue( "Result set is empty ", !result.isEmpty());
509
510 AbstractObservationData_ obsData = (AbstractObservationData_)result.firstElement();
511
512 // result vector should have 'resultElement' entries
513 int realSize = result.size();
514 assertEquals( "The result vector is not of the expected size", realSize, resultElements);
515 Iterator compIterator = obsData.getComposites();
516 // check composite vector only for root objects
517 if (obsData.getParentObjId().length() == 0) {
518 if (deep == dbMgr.DEEP) {
519 // the composite vector should be filled
520 assertTrue("The composite vector is empty", compIterator.hasNext() == true);
521
522 //Object compObj = compIterator.next();
523 // composite vector should be OjbObservationData and not a proxy
524 //assertTrue("The composite vector shouldn't be a proxy object after a DEEP retrieval", !(compObj instanceof ojb.broker.VirtualProxy));
525
526 } else { // deep = dbMgr.SHALLOW
527 //assertTrue("The composite vector should be a proxy object after a SHALLOW retrieval", compObj instanceof ojb.broker.VirtualProxy);
528 assertTrue("The composite vector should be empty after SHALLOW retrieval", compIterator.hasNext() == false );
529 }
530 }
531 dbMgr.txn_commit();
532 System.out.println("done");
533
534 } catch (Throwable e) {
535 fail( "Filter: j=" + j + " i=" + i + ", " + e.getMessage());
536 }
537 } // end for i
538
539 // second iteration with deep parameter set to false
540 deep = dbMgr.DEEP;
541
542 } // end for j
543
544 }
545
546
547
548 /**
549 * Dispatcher method to create different kinds of searchFilter
550 *
551 */
552 protected int getFilter( SearchFilter filter, int i) {
553 // if adding filter, don't forget to update 'filterTests' in testRetrieveElementsByFilter!!!
554
555 // get a CodeMapper instance
556 CodeMapper codeMapper = CodeMapper.getInstance();
557
558 int expected = 0;
559 try {
560 switch (i) {
561 case 0: {
562 String value = DBMgrFactory.getWildChar() + "5";
563 filter.compareFilter( "personId", value, SearchFilter.LIKE);
564 return 8;
565 }
566 case 1: {
567 filter.compareFilter( "personId", "DNS:OpenEMed.org////10005", SearchFilter.EQUAL);
568 return 8;
569 }
570 case 2: {
571 filter.compareFilter( "startTime", "19950831180000", SearchFilter.GREATER_EQUAL);
572 return 47;
573 }
574 case 3: {
575 String[] values = new String[3];
576 values[0] = codeMapper.getId( "This is not a code in the DB!", true, false); // parameters: code, isTopLevel, addToCodeList
577 values[1] = codeMapper.getId( "DNS:OpenEMed.org/TraitCode/ImageStudy", true, false);
578 values[2] = codeMapper.getId( "DNS:OpenEMed.org/TraitCode/Immunology", true, false);
579 filter.matchList( "code", values, SearchFilter.IN);
580 return 3;
581 }
582 case 4: {
583 String[] values = new String[2];
584 values[0] = codeMapper.getId( "DNS:OpenEMed.org/TraitCode/ImageStudy", true, false);
585 values[1] = codeMapper.getId( "DNS:OpenEMed.org/TraitCode/Immunology", true, false);
586 filter.matchList( "code", values, SearchFilter.NOT_IN);
587 return 147;
588 }
589 case 5: {
590 Vector values = new Vector();
591 values.add( codeMapper.getId( "XXXXXXXXXXXXXXXXXXXXXXXXXXX", true, false));
592 values.add( codeMapper.getId( "DNS:OpenEMed.org/TraitCode/ImageStudy", true, false));
593 values.add( codeMapper.getId( "DNS:OpenEMed.org/TraitCode/Immunology", true, false));
594 filter.matchList( "code", values, SearchFilter.IN);
595 return 3; }
596 case 6: {
597 Vector values = new Vector();
598 values.add( codeMapper.getId( "DNS:OpenEMed.org/TraitCode/ImageStudy", true, false));
599 values.add( codeMapper.getId( "DNS:OpenEMed.org/TraitCode/Immunology", true, false));
600 filter.matchList( "code", values, SearchFilter.NOT_IN);
601 return 147;
602 }
603 case 7: {
604 filter.matchValue( "personId", "DNS:OpenEMed.org////10005", SearchFilter.IN);
605 return 8;
606 }
607 case 8: {
608 filter.matchValue( "personId", "DNS:OpenEMed.org////10005", SearchFilter.NOT_IN);
609 return 142;
610 }
611 case 9: {
612 String[] values = new String[3];
613 values[0] = codeMapper.getId( "DNS:OpenEMed.org/TraitCode/ImageStudy", true, false);
614 values[1] = "19921111T000000";
615 values[2] = "DNS:OpenEMed.org////10006";
616 String[] elements = new String[3];
617 elements[0] = "code";
618 elements[1] = "startTime";
619 elements[2] = "personId";
620 filter.matchSet(elements, values, SearchFilter.AND);
621 return 1;
622 }
623 case 10: {
624 String[] values = new String[4];
625 values[0] = codeMapper.getId( "DNS:OpenEMed.org/TraitCode/ImageStudy", true, false);
626 values[1] = "19921111T000000";
627 values[2] = "DNS:OpenEMed.org////10005";
628 values[3] = codeMapper.getId( "DNS:omg.org/DSObservationAccess/HL72.3/OBR/SpecimenSource", true, false);
629 String[] elements = new String[4];
630 elements[0] = "code";
631 elements[1] = "startTime";
632 elements[2] = "personId";
633 elements[3] = "code";
634 filter.matchSet( elements, values, SearchFilter.OR);
635 return 66;
636 }
637 case 11: {
638 Hashtable table = new Hashtable();
639 table.put( "code", codeMapper.getId( "DNS:OpenEMed.org/TraitCode/ImageStudy", true, false));
640 table.put( "startTime", "19921111T000000");
641 table.put( "personId", "DNS:OpenEMed.org////10006");
642 filter.matchSet( table, SearchFilter.AND, SearchFilter.EQUAL);
643 return 1;
644 }
645 default: {
646 System.out.println( "No more filters available!");
647 //filter = DBMgrFactory.createFilter();
648 expected = 0;
649 }
650 }
651 } catch (DBException e) {
652 System.err.println( "Can't create search filter " + e);
653 return 0;
654 }
655 return expected;
656 }
657
658
659
660
661
662
663
664
665
666 /**
667 * Test of getNextSeq method, of class gov.lanl.Database.OJBDatabaseMgr
668 */
669 public void testGetNextSeq() {
670 System.out.println();
671 System.out.println("testGetNextSeq");
672
673 long seq1 = dbMgr.getNextSeq(emptyObsData_.getClass(), "obsId");
674 long seq2 = dbMgr.getNextSeq(emptyObsData_.getClass(), "obsId");
675 assertTrue("continous call to getNextSeq delivered same sequence number",!( String.valueOf( seq1).equals( String.valueOf(seq2))));
676
677 System.out.println("done");
678
679 }
680
681
682 /**
683 * This method is only called once at construction time
684 */
685 protected void init() {
686
687 props = new ConfigProperties();
688 props.setProperty("personId", personIdCode);
689 props.setProperty("startTime", startTimeCode);
690 props.setProperty("stopTime", stopTimeCode);
691 props.setProperty("signingFlag", signingCode);
692
693 props.setProperty("parser", parserName);
694
695 // the mapper
696 mapper = Qualifier2AttributeMapper.getInstance(props);
697
698
699 }
700
701 /**
702 * overriden template method
703 */
704 protected void setUp() {
705 // initialisation
706 // get a database manager
707 dbMgr = DBMgrFactory.createDbMgr(databaseURL, databaseType);
708 if (dbMgr == null) {
709 fail("Can't get DatabaseMgr");
710 }
711
712 // create an empty object
713 if (emptyObsData_ == null)
714 emptyObsData_ = new OjbObservationData_();
715
716 // initialize codeMapper
717 CodeMapper codeMapper = CodeMapper.getInstance( props);
718
719 // set ObjectFactory properties
720 dbMgr.setObjectFactory( persistentProperties);
721 // get ObjectFactory
722 persObjFact = dbMgr.getObjectFactory();
723 if (persObjFact == null) {
724 fail("Can't get ObjectFactory");
725 }
726
727 // debug: remove_me
728 //java.sql.DriverManager.setLogStream(java.lang.System.out);
729
730
731 // load the data from the file
732 ObservationDataStruct[] obsDataSeq = loadObsData( loadFile);
733 // get the persistent object
734 obsData_Seq = createPersistentObsData( obsDataSeq);
735
736 // store data in the database
737 storeData( obsData_Seq);
738
739 // clear object cache
740 ojb.broker.cache.ObjectCacheFactory.getObjectCache().clear();
741 }
742
743
744 /**
745 * overriden template method
746 */
747 protected void tearDown() {
748 // delete data from database
749 dbMgr.txn_abort();
750 deleteData( obsData_Seq);
751 }
752
753
754 /**
755 * Loads the test data from TestObsData.xml
756 */
757 protected ObservationDataStruct[] loadObsData(String loadFile) {
758 try {
759 // create a DomTree out of the xml file
760 Xml2DomDoc x2dd = new Xml2DomDoc(new org.xml.sax.InputSource(loadFile));
761
762 // create observation data from the DomTree
763 DomDoc2ObsData dd2od = new DomDoc2ObsData(x2dd.getDomDoc());
764 ObservationDataStruct[] obsDataSeq = dd2od.getObsDataSeq();
765
766 return obsDataSeq;
767
768 } catch (Exception e) {
769 fail(e.getMessage());
770 }
771
772 return null;
773 }
774
775 /**
776 * Convert ObservationData to persistent PersistentObject
777 */
778 protected PersistentObject[] createPersistentObsData(ObservationDataStruct[] obsDataSeq) {
779 try {
780
781 int elements = obsDataSeq.length;
782 PersistentObject[] obsData_Seq = new PersistentObject[ elements];
783
784 for (int i=0; i<elements; i++) {
785 // create persistent object
786 obsData_Seq[i] = (PersistentObject) persObjFact.createPersistentObject(obsDataSeq[ i]);
787 }
788 return obsData_Seq;
789
790 } catch (Exception e) {
791 fail(e.getMessage());
792 }
793
794 return null;
795 }
796
797 /**
798 * Insert data into database
799 */
800 protected void storeData( PersistentObject[] obsData_Seq) {
801 try {
802 for (int i = 0; i < obsData_Seq.length; i++) {
803 dbMgr.txn_begin();
804 PersistentObject persObj = obsData_Seq[i];
805 dbMgr.insertElement(persObj, null);
806 dbMgr.txn_commit();
807 }
808 } catch (DBException e) {
809 fail(e.getMessage());
810 }
811 }
812
813 /**
814 * Delet data from database
815 */
816 protected void deleteData( PersistentObject[] obsData_Seq) {
817 try {
818 for (int i = 0; i < obsData_Seq.length; i++) {
819 dbMgr.txn_begin();
820 dbMgr.deleteElement(obsData_Seq[i]);
821 dbMgr.txn_commit();
822 }
823 } catch (DBException e) {
824 fail(e.getMessage());
825 }
826 }
827
828 }
829
830
831
832 /*--- formatting done in "OpenEMed Convention" style on 02-22-2001 ---*/
833