2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017-2019 AT&T Intellectual Property. All rights reserved.
6 * ================================================================================
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 * ============LICENSE_END=========================================================
21 package org.onap.policy.pap.xacml.rest.components;
23 import static org.junit.Assert.fail;
26 import java.io.IOException;
27 import java.nio.file.Path;
28 import java.nio.file.Paths;
29 import java.util.Date;
30 import java.util.List;
32 import javax.persistence.EntityManager;
33 import javax.persistence.EntityManagerFactory;
34 import javax.persistence.Persistence;
35 import javax.persistence.PersistenceException;
36 import javax.persistence.Query;
38 import org.apache.commons.io.FileUtils;
39 import org.apache.commons.io.IOUtils;
40 import org.junit.After;
41 import org.junit.Assert;
42 import org.junit.Before;
43 import org.junit.Ignore;
44 import org.junit.Test;
45 import org.mockito.Mockito;
46 import org.onap.policy.common.logging.flexlogger.FlexLogger;
47 import org.onap.policy.common.logging.flexlogger.Logger;
48 import org.onap.policy.pap.xacml.rest.components.PolicyDBDao.PolicyDBDaoTestClass;
49 import org.onap.policy.rest.XACMLRestProperties;
50 import org.onap.policy.rest.adapter.PolicyRestAdapter;
51 import org.onap.policy.rest.dao.PolicyDBException;
52 import org.onap.policy.rest.jpa.GroupEntity;
53 import org.onap.policy.rest.jpa.PdpEntity;
54 import org.onap.policy.rest.jpa.PolicyEntity;
55 import org.onap.policy.xacml.api.pap.OnapPDPGroup;
56 import org.onap.policy.xacml.std.pap.StdEngine;
57 import org.onap.policy.xacml.std.pap.StdPDPGroup;
58 import org.onap.policy.xacml.util.XACMLPolicyWriter;
60 import com.att.research.xacml.api.pap.PAPException;
61 import com.att.research.xacml.util.XACMLProperties;
63 import oasis.names.tc.xacml._3_0.core.schema.wd_17.PolicyType;
64 import oasis.names.tc.xacml._3_0.core.schema.wd_17.TargetType;
66 public class PolicyDBDaoTest extends Mockito{
68 private static Logger logger = FlexLogger.getLogger(PolicyDBDaoTest.class);
70 PolicyDBDaoTestClass d;
73 EntityManagerFactory emf;
74 private Path repository;
75 StdEngine stdEngine = null;
78 public void init() throws PAPException, IOException{
79 System.setProperty(XACMLProperties.XACML_PROPERTIES_NAME,"src/test/resources/xacml.pap.properties");
80 emf = Persistence.createEntityManagerFactory("testPapPU");
81 EntityManager em = emf.createEntityManager();
82 em.getTransaction().begin();
84 em.createQuery("DELETE FROM PolicyDBDaoEntity").executeUpdate();
85 em.createQuery("DELETE FROM PolicyEntity").executeUpdate();
86 em.createQuery("DELETE FROM ConfigurationDataEntity").executeUpdate();
87 em.createQuery("DELETE FROM ActionBodyEntity").executeUpdate();
88 em.createQuery("DELETE FROM PdpEntity").executeUpdate();
89 em.createQuery("DELETE FROM GroupEntity").executeUpdate();
91 em.getTransaction().commit();
93 logger.error("Exception Occured"+e);
94 em.getTransaction().rollback();
98 dbd = PolicyDBDao.getPolicyDBDaoInstance(emf);
99 dbd2 = PolicyDBDao.getPolicyDBDaoInstance(emf);
100 } catch (Exception e) {
104 d = PolicyDBDao.getPolicyDBDaoTestClass();
105 PolicyDBDao.setJunit(true);
106 repository = Paths.get("src/test/resources/pdps");
107 stdEngine = new StdEngine(repository);
108 dbd.setPapEngine(stdEngine);
112 public void cleanUp(){
113 PolicyDBDao.setJunit(false);
114 EntityManager em = emf.createEntityManager();
115 em.getTransaction().begin();
117 em.createQuery("DELETE FROM PolicyDBDaoEntity").executeUpdate();
118 em.createQuery("DELETE FROM PolicyEntity").executeUpdate();
119 em.createQuery("DELETE FROM ConfigurationDataEntity").executeUpdate();
120 em.createQuery("DELETE FROM ActionBodyEntity").executeUpdate();
121 em.createQuery("DELETE FROM PdpEntity").executeUpdate();
122 em.createQuery("DELETE FROM GroupEntity").executeUpdate();
124 em.getTransaction().commit();
125 } catch(Exception e){
126 em.getTransaction().rollback();
130 FileUtils.forceDelete(new File("src/test/resources/junitTestCreatedDirectory"));
131 } catch (IOException e) {
137 public void getConfigFileTest(){
138 PolicyRestAdapter pra = new PolicyRestAdapter();
139 pra.setConfigType(ConfigPolicy.JSON_CONFIG);
140 String configFile = d.getConfigFile("Config_mypolicy.xml", "org.onap", pra);
141 Assert.assertEquals("org.onap.Config_mypolicy.json", configFile);
142 //yes, we can do action files too even though they don't have configs
143 configFile = d.getConfigFile("Action_mypolicy.xml", "org.onap", pra);
144 Assert.assertEquals("org.onap.Action_mypolicy.json", configFile);
148 public void getPolicyNameAndVersionFromPolicyFileNameTest() throws PolicyDBException {
149 String policyName = "com.Decision_testname.1.xml";
150 String[] expectedNameAndVersion = new String[2];
151 expectedNameAndVersion[0] = "com.Decision_testname";
152 expectedNameAndVersion[1] = "1";
153 String[] actualNameAndVersion = d.getPolicyNameAndVersionFromPolicyFileName(policyName);
154 Assert.assertArrayEquals(expectedNameAndVersion, actualNameAndVersion);
158 public void getNameScopeAndVersionFromPdpPolicyTest() {
159 String fileName = "com.Decision_testname.1.xml";
160 String[] expectedArray = new String[3];
161 expectedArray[0] = "Decision_testname.1.xml";
162 expectedArray[2] = "1";
163 expectedArray[1] = "com";
165 String[] returnArray = d.getNameScopeAndVersionFromPdpPolicy(fileName);
166 Assert.assertArrayEquals(expectedArray, returnArray);
170 public void getPdpPolicyNameTest() {
171 String name = "Decision_testname.1.json";
172 String scope = "com";
173 String expectedFinalname = "com.Decision_testname.1.xml";
175 String finalname = d.getPdpPolicyName(name, scope);
176 Assert.assertEquals(expectedFinalname, finalname);
180 public void getPolicySubFileTest() {
181 String name = "Config_testname.1.json";
182 String subFileType = "Config";
184 Path path = d.getPolicySubFile(name, subFileType);
185 Assert.assertNull(path);
189 public void createFromPolicyObject(){
190 Policy policyObject = new ConfigPolicy();
191 policyObject.policyAdapter = new PolicyRestAdapter();
192 policyObject.policyAdapter.setConfigName("testpolicy1");
193 policyObject.policyAdapter.setPolicyDescription("my description");
194 policyObject.policyAdapter.setConfigBodyData("this is my test config file");
195 policyObject.policyAdapter.setPolicyName("SampleTest1206");
196 policyObject.policyAdapter.setConfigType(ConfigPolicy.OTHER_CONFIG);
197 policyObject.policyAdapter.setPolicyType("Config");
198 policyObject.policyAdapter.setDomainDir("com");
199 policyObject.policyAdapter.setVersion("1");
200 policyObject.policyAdapter.setHighestVersion(1);
201 PolicyType policyTypeObject = new PolicyType();
202 policyObject.policyAdapter.setPolicyData(policyTypeObject);
203 ClassLoader classLoader = getClass().getClassLoader();
204 PolicyType policyConfig = new PolicyType();
205 policyConfig.setVersion(Integer.toString(1));
206 policyConfig.setPolicyId("");
207 policyConfig.setTarget(new TargetType());
208 policyObject.policyAdapter.setData(policyConfig);
209 mock(XACMLPolicyWriter.class);
211 policyObject.policyAdapter.setParentPath(IOUtils.toString(classLoader.getResourceAsStream("Config_SampleTest1206.1.xml")));
212 } catch (Exception e2) {
216 PolicyDBDaoTransaction transaction = dbd.getNewTransaction();
218 transaction.createPolicy(policyObject, "testuser1");
219 transaction.commitTransaction();
220 } catch(Exception e){
221 transaction.rollbackTransaction();
225 EntityManager getData = emf.createEntityManager();
226 Query getDataQuery = getData.createQuery("SELECT p FROM PolicyEntity p WHERE p.scope=:scope AND p.policyName=:name");
227 getDataQuery.setParameter("scope", "com");
228 getDataQuery.setParameter("name","Config_SampleTest1206.1.xml");
229 PolicyEntity result = null;
231 result = (PolicyEntity)getDataQuery.getSingleResult();
232 } catch(Exception e){
233 logger.error("Exception Occured"+e);
238 expectedData = IOUtils.toString(classLoader.getResourceAsStream("Config_SampleTest1206.1.xml"));
239 } catch (IOException e1) {
242 Assert.assertEquals(expectedData, result.getPolicyData());
246 transaction.commitTransaction();
247 Assert.assertFalse(transaction.isTransactionOpen());
251 public void groupTransactions(){
252 PolicyDBDaoTransaction group = dbd.getNewTransaction();
253 String groupName = "test group 1";
255 group.createGroup(PolicyDBDao.createNewPDPGroupId(groupName), groupName, "this is a test group","testuser");
256 group.commitTransaction();
257 } catch(Exception e){
258 group.rollbackTransaction();
259 logger.error("Exception Occured"+e);
262 EntityManager em = emf.createEntityManager();
263 Query getGroup = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
264 getGroup.setParameter("groupId", PolicyDBDao.createNewPDPGroupId(groupName));
265 getGroup.setParameter("deleted", false);
266 List<?> groups = getGroup.getResultList();
267 if(groups.size() != 1){
270 GroupEntity groupEntity = (GroupEntity)groups.get(0);
272 Assert.assertEquals(groupName, groupEntity.getgroupName());
273 Assert.assertEquals("this is a test group", groupEntity.getDescription());
274 group = dbd.getNewTransaction();
276 OnapPDPGroup groupToDelete = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId(groupName),Paths.get("/"));
277 group.deleteGroup(groupToDelete, null,"testuser");
278 group.commitTransaction();
279 } catch(Exception e){
280 group.rollbackTransaction();
281 logger.error("Exception Occured"+e);
284 em = emf.createEntityManager();
285 getGroup = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
286 getGroup.setParameter("groupId", PolicyDBDao.createNewPDPGroupId(groupName));
287 getGroup.setParameter("deleted", false);
288 groups = getGroup.getResultList();
289 if(groups.size() != 0){
290 System.out.println("Group size: "+groups.size());
294 //add a pdp to a group
295 group = dbd.getNewTransaction();
297 group.createGroup(PolicyDBDao.createNewPDPGroupId(groupName), groupName, "test group", "testuser");
298 group.commitTransaction();
299 } catch(Exception e){
300 group.rollbackTransaction();
301 logger.error("Exception Occured"+e);
304 group = dbd.getNewTransaction();
306 group.addPdpToGroup("http://localhost:4344/pdp/", PolicyDBDao.createNewPDPGroupId(groupName), "primary", "the main pdp", 3232, "testuser");
307 group.commitTransaction();
308 } catch(Exception e){
309 group.rollbackTransaction();
310 logger.error("Exception Occured"+e);
313 em = emf.createEntityManager();
314 Query getPdp = em.createQuery("SELECT p FROM PdpEntity p WHERE p.pdpId=:pdpId AND p.deleted=:deleted");
315 getPdp.setParameter("pdpId", "http://localhost:4344/pdp/");
316 getPdp.setParameter("deleted", false);
317 List<?> pdps = getPdp.getResultList();
318 if(pdps.size() != 1){
319 System.out.println("Group size: "+pdps.size());
322 PdpEntity pdp = (PdpEntity)pdps.get(0);
323 Assert.assertEquals(groupName, pdp.getGroup().getgroupName());
324 Assert.assertEquals(pdp.getPdpName(), "primary");
326 group = dbd.getNewTransaction();
328 group.removePdpFromGroup("http://localhost:4344/pdp/","testuser");
329 group.commitTransaction();
330 } catch(Exception e){
331 group.rollbackTransaction();
332 logger.error("Exception Occured"+e);
335 em = emf.createEntityManager();
336 getPdp = em.createQuery("SELECT p FROM PdpEntity p WHERE p.pdpId=:pdpId AND p.deleted=:deleted");
337 getPdp.setParameter("pdpId", "http://localhost:4344/pdp/");
338 getPdp.setParameter("deleted", false);
339 pdps = getPdp.getResultList();
340 if(pdps.size() != 0){
341 System.out.println("Group size: "+pdps.size());
346 //add some pdps to groups
347 group = dbd.getNewTransaction();
349 group.createGroup(PolicyDBDao.createNewPDPGroupId("testgroup1"), "testgroup1", "test group", "testuser");
350 group.commitTransaction();
351 } catch(Exception e){
352 group.rollbackTransaction();
353 logger.error("Exception Occured"+e);
356 group = dbd.getNewTransaction();
358 group.createGroup(PolicyDBDao.createNewPDPGroupId("testgroup2"), "testgroup2", "test group", "testuser");
359 group.commitTransaction();
360 } catch(Exception e){
361 group.rollbackTransaction();
362 logger.error("Exception Occured"+e);
366 group = dbd.getNewTransaction();
368 group.addPdpToGroup("http://localhost:4344/pdp/", PolicyDBDao.createNewPDPGroupId("testgroup1"), "primary", "the main pdp", 3232, "testuser");
369 group.commitTransaction();
370 } catch(Exception e){
371 group.rollbackTransaction();
372 logger.error("Exception Occured"+e);
375 group = dbd.getNewTransaction();
377 group.addPdpToGroup("http://localhost:4345/pdp/", PolicyDBDao.createNewPDPGroupId("testgroup1"), "secondary", "the second pdp", 3233, "testuser");
378 group.commitTransaction();
379 } catch(Exception e){
380 group.rollbackTransaction();
381 logger.error("Exception Occured"+e);
384 em = emf.createEntityManager();
385 getPdp = em.createQuery("SELECT p FROM PdpEntity p WHERE p.deleted=:deleted");
386 getPdp.setParameter("deleted", false);
387 pdps = getPdp.getResultList();
388 for(Object o : pdps){
389 Assert.assertEquals("testgroup1",((PdpEntity)o).getGroup().getgroupName());
393 group = dbd.getNewTransaction();
395 OnapPDPGroup groupToDelete = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId("testgroup1"),Paths.get("/"));
396 OnapPDPGroup groupToMoveTo = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId("testgroup2"),Paths.get("/"));
397 group.deleteGroup(groupToDelete, groupToMoveTo,"testuser");
398 group.commitTransaction();
399 } catch(Exception e){
400 group.rollbackTransaction();
401 logger.error("Exception Occured"+e);
404 em = emf.createEntityManager();
405 getGroup = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
406 getGroup.setParameter("groupId", "testgroup1");
407 getGroup.setParameter("deleted", false);
408 groups = getGroup.getResultList();
409 if(groups.size() != 0){
410 System.out.println("Group size: "+groups.size());
415 em = emf.createEntityManager();
416 getPdp = em.createQuery("SELECT p FROM PdpEntity p WHERE p.deleted=:deleted");
417 getPdp.setParameter("deleted", false);
418 pdps = getPdp.getResultList();
419 for(Object o : pdps){
420 Assert.assertEquals("testgroup2",((PdpEntity)o).getGroup().getgroupName());
424 group = dbd.getNewTransaction();
426 OnapPDPGroup groupToDelete = new StdPDPGroup(PolicyDBDao.createNewPDPGroupId("testgroup2"),Paths.get("/"));
427 OnapPDPGroup groupToMoveTo = null;
428 group.deleteGroup(groupToDelete, groupToMoveTo,"testuser");
429 group.commitTransaction();
431 } catch(PolicyDBException pe){
432 //good, can't delete group with pdps
433 group.rollbackTransaction();
434 } catch(Exception e){
435 group.rollbackTransaction();
436 logger.error("Exception Occured"+e);
441 OnapPDPGroup pdpGroup = new StdPDPGroup("testgroup2", false, "newtestgroup2", "this is my new description", Paths.get("/"));
442 group = dbd.getNewTransaction();
444 group.updateGroup(pdpGroup, "testuser");
445 group.commitTransaction();
446 }catch (Exception e){
447 logger.error("Exception Occured"+e);
448 group.rollbackTransaction();
451 em = emf.createEntityManager();
452 getGroup = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
453 getGroup.setParameter("groupId", "newtestgroup2");
454 getGroup.setParameter("deleted", false);
455 groups = getGroup.getResultList();
456 if(groups.size() != 1){
457 System.out.println("Group size: "+groups.size());
461 em = emf.createEntityManager();
462 getGroup = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted");
463 getGroup.setParameter("groupId", "testgroup2");
464 getGroup.setParameter("deleted", false);
465 groups = getGroup.getResultList();
466 if(groups.size() != 0){
467 System.out.println("Group size: "+groups.size());
475 public void threadingStabilityTest(){
476 if(logger.isDebugEnabled()){
477 logger.debug("\n\n****************************"
478 + "threadingStabilityTest() entry"
479 + "******************************\n\n");
482 PolicyDBDaoTransaction t = dbd.getNewTransaction();
483 Assert.assertTrue(t.isTransactionOpen());
485 //Add 1000 ms to the timeout just to be sure it actually times out
486 int sleepTime = Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT)) + 1000;
487 if(logger.isDebugEnabled()){
488 Date date= new java.util.Date();
489 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
490 + "\n sleepTime = " + sleepTime
491 + "\n TimeStamp = " + date.getTime()
494 Thread.sleep(sleepTime);
495 } catch (InterruptedException e) {
496 logger.error("Exception Occured"+e);
498 if(logger.isDebugEnabled()){
499 Date date= new java.util.Date();
500 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
501 + "\n Assert.assertFalse(t.isTransactionOpen() = " + t.isTransactionOpen() + ")"
502 + "\n TimeStamp = " + date.getTime()
505 Assert.assertFalse(t.isTransactionOpen());
508 if(logger.isDebugEnabled()){
509 Date date= new java.util.Date();
510 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
511 + "\n a = dbd.getNewTransaction() "
512 + "\n TimeStamp = " + date.getTime()
515 PolicyDBDaoTransaction a = dbd.getNewTransaction();
516 if(logger.isDebugEnabled()){
517 Date date= new java.util.Date();
518 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
519 + "\n Assert.assertTrue(a.isTransactionOpen() = " + a.isTransactionOpen() + ")"
520 + "\n TimeStamp = " + date.getTime()
523 Assert.assertTrue(a.isTransactionOpen());
526 //Add 1000 ms to the timeout just to be sure it actually times out
527 int sleepTime = Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT)) + 1000;
528 if(logger.isDebugEnabled()){
529 Date date= new java.util.Date();
530 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
531 + "\n sleepTime = " + sleepTime
532 + "\n TimeStamp = " + date.getTime()
535 Thread.sleep(sleepTime);
536 } catch (InterruptedException e) {
537 logger.error("Exception Occured"+e);
539 if(logger.isDebugEnabled()){
540 Date date= new java.util.Date();
541 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
542 + "\n b = dbd.getNewTransaction() "
543 + "\n TimeStamp = " + date.getTime()
546 PolicyDBDaoTransaction b = dbd.getNewTransaction();
547 if(logger.isDebugEnabled()){
548 Date date= new java.util.Date();
549 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
550 + "\n Assert.assertFalse(a.isTransactionOpen() = " + a.isTransactionOpen() + ")"
551 + "\n TimeStamp = " + date.getTime()
554 Assert.assertFalse(a.isTransactionOpen());
555 if(logger.isDebugEnabled()){
556 Date date= new java.util.Date();
557 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
558 + "\n Assert.assertTrue(b.isTransactionOpen() = " + b.isTransactionOpen() + ")"
559 + "\n TimeStamp = " + date.getTime()
562 Assert.assertTrue(b.isTransactionOpen());
567 //Now let's test the transaction wait time timeout. Shorten the wait time to 1000 ms
568 System.setProperty(XACMLRestProperties.PROP_PAP_TRANS_WAIT,"1000");
569 //And let's lengthen the transaction timeout to 5000 ms
570 System.setProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT,"5000");
572 PolicyDBDaoTransaction t1 = dbd.getNewTransaction();
573 if(logger.isDebugEnabled()){
574 Date date= new java.util.Date();
575 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
576 + "\n Assert.assertTrue(t1.isTransactionOpen() = " + t1.isTransactionOpen() + ")"
577 + "\n TimeStamp = " + date.getTime()
580 Assert.assertTrue(t1.isTransactionOpen());
581 //while it is open, get another from a different DB Dao so it will not collide on the synchronized code segment
582 //but will collide at the DB. Remember that the wait time is only 1000 ms
584 //Now the 2nd transaction has a wait timeout in 1000 ms
585 PolicyDBDaoTransaction t2 = dbd2.getNewTransaction();
587 * Give it plenty of time to time out the second transaction
588 * It will actually hang right here until it either gets the lock from the DB or the
589 * request for the DB lock times out. The timers are very sloppy so, I have given
590 * this plenty of leeway.
593 if(logger.isDebugEnabled()){
594 Date date= new java.util.Date();
595 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
596 + "\n Thread.sleep(3000)"
597 + "\n TimeStamp = " + date.getTime()
601 if(logger.isDebugEnabled()){
602 Date date= new java.util.Date();
603 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
604 + "\n Assert.assertTrue(t1.isTransactionOpen() = " + t1.isTransactionOpen() + ")"
605 + "\n Assert.assertFalse(t2.isTransactionOpen() = " + t2.isTransactionOpen() + ")"
606 + "\n TimeStamp = " + date.getTime()
609 //Assert.assertTrue(t1.isTransactionOpen());
610 //Assert.assertFalse(t2.isTransactionOpen());
612 Assert.fail("\n\nTransaction timeout of 1000 ms exceeded without a PersistenceException\n\n");
613 } catch (PersistenceException e) {
615 if(logger.isDebugEnabled()){
616 Date date= new java.util.Date();
617 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() "
618 + "\n SUCCESS! Transaction Wait Timeout worked!"
619 + "\n Caught PersistenceException = " + e
620 + "\n TimeStamp = " + date.getTime()
623 } catch (Exception e) {
624 // failure due to some other reason
625 if(logger.isDebugEnabled()){
626 Date date= new java.util.Date();
627 logger.debug("\n\nPolicyDBDaoTest.threadingStabilityTest() FAILURE"
628 + "\n Caught Exception = " + e
629 + "\n TimeStamp = " + date.getTime()
632 logger.error("Exception Occured"+e);
636 if(logger.isDebugEnabled()){
637 Date date= new java.util.Date();
638 logger.debug("\n\nthreadingStabilityTest() exit"
639 + "\n TimeStamp = " + date.getTime()