Source Code Cross Referenced for EMBTestConfiguration.java in  » J2EE » JOnAS-4.8.6 » com » ibm » emb » junit » Java Source Code / Java DocumentationJava Source Code and Java Documentation

Java Source Code / Java Documentation
1. 6.0 JDK Core
2. 6.0 JDK Modules
3. 6.0 JDK Modules com.sun
4. 6.0 JDK Modules com.sun.java
5. 6.0 JDK Modules sun
6. 6.0 JDK Platform
7. Ajax
8. Apache Harmony Java SE
9. Aspect oriented
10. Authentication Authorization
11. Blogger System
12. Build
13. Byte Code
14. Cache
15. Chart
16. Chat
17. Code Analyzer
18. Collaboration
19. Content Management System
20. Database Client
21. Database DBMS
22. Database JDBC Connection Pool
23. Database ORM
24. Development
25. EJB Server geronimo
26. EJB Server GlassFish
27. EJB Server JBoss 4.2.1
28. EJB Server resin 3.1.5
29. ERP CRM Financial
30. ESB
31. Forum
32. GIS
33. Graphic Library
34. Groupware
35. HTML Parser
36. IDE
37. IDE Eclipse
38. IDE Netbeans
39. Installer
40. Internationalization Localization
41. Inversion of Control
42. Issue Tracking
43. J2EE
44. JBoss
45. JMS
46. JMX
47. Library
48. Mail Clients
49. Net
50. Parser
51. PDF
52. Portal
53. Profiler
54. Project Management
55. Report
56. RSS RDF
57. Rule Engine
58. Science
59. Scripting
60. Search Engine
61. Security
62. Sevlet Container
63. Source Control
64. Swing Library
65. Template Engine
66. Test Coverage
67. Testing
68. UML
69. Web Crawler
70. Web Framework
71. Web Mail
72. Web Server
73. Web Services
74. Web Services apache cxf 2.0.1
75. Web Services AXIS2
76. Wiki Engine
77. Workflow Engines
78. XML
79. XML UI
Java
Java Tutorial
Java Open Source
Jar File Download
Java Articles
Java Products
Java by API
Photoshop Tutorials
Maya Tutorials
Flash Tutorials
3ds-Max Tutorials
Illustrator Tutorials
GIMP Tutorials
C# / C Sharp
C# / CSharp Tutorial
C# / CSharp Open Source
ASP.Net
ASP.NET Tutorial
JavaScript DHTML
JavaScript Tutorial
JavaScript Reference
HTML / CSS
HTML CSS Reference
C / ANSI-C
C Tutorial
C++
C++ Tutorial
Ruby
PHP
Python
Python Tutorial
Python Open Source
SQL Server / T-SQL
SQL Server / T-SQL Tutorial
Oracle PL / SQL
Oracle PL/SQL Tutorial
PostgreSQL
SQL / MySQL
MySQL Tutorial
VB.Net
VB.Net Tutorial
Flash / Flex / ActionScript
VBA / Excel / Access / Word
XML
XML Tutorial
Microsoft Office PowerPoint 2007 Tutorial
Microsoft Office Excel 2007 Tutorial
Microsoft Office Word 2007 Tutorial
Java Source Code / Java Documentation » J2EE » JOnAS 4.8.6 » com.ibm.emb.junit 
Source Cross Referenced  Class Diagram Java Document (Java Doc) 


001:        package com.ibm.emb.junit;
002:
003:        import java.io.BufferedWriter;
004:        import java.io.File;
005:        import java.io.FileWriter;
006:        import java.io.Serializable;
007:        import java.text.SimpleDateFormat;
008:        import java.util.Date;
009:        import java.util.PropertyResourceBundle;
010:
011:        /**
012:         * A utility class of which at most one instance can exist per VM. Use
013:         * EMBTestConfiguration.instance() to access this instance.
014:         */
015:        public class EMBTestConfiguration implements  Serializable {
016:
017:            /**
018:             *
019:             */
020:            private static final long serialVersionUID = 3689352100358664754L;
021:
022:            public static final String propertyFile = "EmbTestConfiguration";
023:
024:            protected String testClient;
025:
026:            protected String testClientIPAddress;
027:
028:            protected PropertyResourceBundle rb = null;
029:
030:            protected BufferedWriter traceWriter = null;
031:
032:            protected BufferedWriter logWriter = null;
033:
034:            protected BufferedWriter junitWriter = null;
035:
036:            protected String mediaDir = null;
037:
038:            protected boolean includeLongRunningTest = false;
039:
040:            protected boolean logKnownErrors = false;
041:
042:            protected boolean writeTrace = false;
043:
044:            protected boolean writeLog = false;
045:
046:            protected String bmpPictureName1 = null;
047:
048:            protected String bmpPictureName2 = null;
049:
050:            protected String jpgPictureName1 = null;
051:
052:            protected String jpgPictureName2 = null;
053:
054:            protected String mp3SoundName1 = null;
055:
056:            protected String mp3SoundName2 = null;
057:
058:            protected String playlistName1 = null;
059:
060:            protected String playlistName2 = null;
061:
062:            protected String mpegMovieName1 = null;
063:
064:            protected String wavSoundName1 = null;
065:
066:            protected String gzipCorruptFileName = null;
067:
068:            protected String nonEmbeddedMediaClassName = null;
069:
070:            protected String nonEmbeddedMediaFileExt = null;
071:
072:            protected String nonEmbeddedMediaFile = null;
073:
074:            protected String allMediaFormats = null;
075:
076:            protected String allMediaConverterSpecs = null;
077:
078:            protected String streamServerTypes = null;
079:
080:            protected String classSignatureFile = null;
081:
082:            protected String listOfClassNamesFile = null;
083:
084:            protected String xmlFile1 = null;
085:
086:            protected String xmlFile2 = null;
087:
088:            protected String invalidXMLFile1 = null;
089:
090:            protected String invalidXMLFile2 = null;
091:
092:            protected String queryLanguages = null;
093:
094:            protected String mediaListeners = null;
095:
096:            protected String maxMediaSize = null;
097:
098:            /**
099:             * The constructor could be made private to prevent others from
100:             * instantiating this class. But this would also make it impossible to
101:             * create instances of Singleton subclasses.
102:             */
103:            public EMBTestConfiguration() {
104:            }
105:
106:            /**
107:             * A handle to the unique Singleton instance.
108:             */
109:            static protected EMBTestConfiguration _instance = null;
110:
111:            /**
112:             * @return The unique instance of this class.
113:             */
114:            static public EMBTestConfiguration instance() {
115:                if (null == _instance) {
116:                    _instance = new EMBTestConfiguration();
117:                    _instance.initConfig();
118:                }
119:                return _instance;
120:            }
121:
122:            /**
123:             * initialize the configuration
124:             */
125:            public void initConfig() {
126:                try {
127:                    this .rb = (PropertyResourceBundle) PropertyResourceBundle
128:                            .getBundle(propertyFile);
129:                    EMBStaticHelper.testTrace("MEDIADIR="
130:                            + this .rb.getString("MEDIADIR"));
131:                    this .mediaDir = this .rb.getString("MEDIADIR");
132:
133:                    EMBStaticHelper.testTrace("includeLongRunningTest="
134:                            + this .rb.getString("includeLongRunningTest"));
135:                    if (this .rb.getString("includeLongRunningTest").equals("1")) {
136:                        this .setIncludeLongRunningTest(true);
137:                    }
138:                    EMBStaticHelper.testTrace("logKnownErrors="
139:                            + this .rb.getString("logKnownErrors"));
140:                    if (this .rb.getString("logKnownErrors").equals("1")) {
141:                        this .setLogKnownErrors(true);
142:                    }
143:
144:                    EMBStaticHelper.testTrace("writeTrace="
145:                            + this .rb.getString("writeTrace"));
146:                    if (this .rb.getString("writeTrace").equals("1")) {
147:                        this .setWriteTrace(true);
148:                    }
149:                    EMBStaticHelper.testTrace("writeLog="
150:                            + this .rb.getString("writeLog"));
151:                    if (this .rb.getString("writeLog").equals("1")) {
152:                        this .setWriteLog(true);
153:                    }
154:
155:                } catch (java.util.MissingResourceException e) {
156:                    EMBStaticHelper.testTrace("Resource " + propertyFile
157:                            + " not found");
158:                    e.printStackTrace();
159:                    throw new RuntimeException();
160:                }
161:
162:                File traceFile = null;
163:                File logFile = null;
164:                File junitFile = null;
165:                SimpleDateFormat df = new java.text.SimpleDateFormat(
166:                        "MMddyyyy_HHmmss");
167:                String timeString = df.format(new Date());
168:
169:                try {
170:                    FileWriter fwriter = null;
171:                    if (this .getWriteTrace()) {
172:                        traceFile = new File(getMediaDir() + File.separator
173:                                + "log" + File.separator
174:                                + this .rb.getString("TRACEFILE") + timeString
175:                                + ".log");
176:                        EMBStaticHelper.testTrace("traceFile = "
177:                                + traceFile.getAbsolutePath());
178:
179:                        traceFile.createNewFile();
180:                        fwriter = new FileWriter(traceFile);
181:                        this .traceWriter = new BufferedWriter(fwriter);
182:                    }
183:                    if (this .getWriteLog()) {
184:                        logFile = new File(getMediaDir() + File.separator
185:                                + "log" + File.separator
186:                                + this .rb.getString("LOGFILE") + timeString
187:                                + ".log");
188:                        EMBStaticHelper.testTrace("logFile = "
189:                                + logFile.getAbsolutePath());
190:                        logFile.createNewFile();
191:                        fwriter = new FileWriter(logFile);
192:                        this .logWriter = new BufferedWriter(fwriter);
193:                    }
194:                    junitFile = new File(getMediaDir() + File.separator + "log"
195:                            + File.separator + this .rb.getString("JUNITFILE")
196:                            + timeString + ".log");
197:                    EMBStaticHelper.testTrace("junitFile = "
198:                            + junitFile.getAbsolutePath());
199:                    junitFile.createNewFile();
200:                    fwriter = new FileWriter(junitFile);
201:                    this .junitWriter = new BufferedWriter(fwriter);
202:                } catch (Exception e) {
203:                    if (traceFile != null && logFile != null) {
204:                        EMBStaticHelper.testTrace("error creating traceFiles"
205:                                + traceFile.getAbsolutePath() + " or "
206:                                + logFile.getAbsolutePath());
207:                    } else {
208:                        EMBStaticHelper.testTrace("error creating traceFiles");
209:                    }
210:                    e.printStackTrace();
211:                }
212:
213:            }
214:
215:            /**
216:             * Gets the testComputer
217:             * @return Returns a String
218:             */
219:            public String getTestClient() {
220:                if (this .testClient == null) {
221:                    // EMBStaticHelper.testTrace("testClient=" +
222:                    // this.rb.getString("TESTCLIENT"));
223:                    this .setTestClient(this .rb.getString("TESTCLIENT"));
224:
225:                }
226:
227:                return this .testClient;
228:            }
229:
230:            /**
231:             * Sets the testComputer
232:             * @param testComputer The testComputer to set
233:             */
234:            public void setTestClient(String testComputer) {
235:                this .testClient = testComputer;
236:            }
237:
238:            /**
239:             * Gets the traceWriter
240:             * @return Returns a BufferedWriter
241:             */
242:            public BufferedWriter getTraceWriter() {
243:                return traceWriter;
244:            }
245:
246:            /**
247:             * Sets the traceWriter
248:             * @param traceWriter The traceWriter to set
249:             */
250:            public void setTraceWriter(BufferedWriter traceWriter) {
251:                this .traceWriter = traceWriter;
252:            }
253:
254:            /**
255:             * Gets the logWriter
256:             * @return Returns a BufferedWriter
257:             */
258:            public BufferedWriter getLogWriter() {
259:                return logWriter;
260:            }
261:
262:            /**
263:             * Sets the logWriter
264:             * @param logWriter The logWriter to set
265:             */
266:            public void setLogWriter(BufferedWriter logWriter) {
267:                this .logWriter = logWriter;
268:            }
269:
270:            /**
271:             * Gets the junitWriter
272:             * @return Returns a BufferedWriter
273:             */
274:            public BufferedWriter getJunitWriter() {
275:                return junitWriter;
276:            }
277:
278:            /**
279:             * Sets the junitWriter
280:             * @param junitWriter The junitWriter to set
281:             */
282:            public void setJunitWriter(BufferedWriter junitWriter) {
283:                this .junitWriter = junitWriter;
284:            }
285:
286:            /**
287:             * Gets the media directory
288:             */
289:            public String getMediaDir() {
290:                // return this.workingDir + File.separator + "media";
291:                return this .mediaDir;
292:            }
293:
294:            /**
295:             * Gets the includeLongRunningTest
296:             * @return Returns a boolean
297:             */
298:            public boolean getIncludeLongRunningTest() {
299:                return includeLongRunningTest;
300:            }
301:
302:            /**
303:             * Sets the includeLongRunningTest
304:             * @param includeLongRunningTest The includeLongRunningTest to set
305:             */
306:            public void setIncludeLongRunningTest(boolean includeLongRunningTest) {
307:                this .includeLongRunningTest = includeLongRunningTest;
308:            }
309:
310:            /**
311:             * Gets the jpgPictureName1
312:             * @return Returns a String
313:             */
314:            public String getJpgPictureName1() {
315:                if (this .jpgPictureName1 == null) {
316:                    EMBStaticHelper.testTrace("jpgPictureName1="
317:                            + this .rb.getString("jpgPictureName1"));
318:                    this .setJpgPictureName1(this .rb
319:                            .getString("jpgPictureName1"));
320:
321:                }
322:                return this .jpgPictureName1;
323:            }
324:
325:            /**
326:             * Sets the jpgPictureName1
327:             * @param jpgPictureName1 The jpgPictureName1 to set
328:             */
329:            public void setJpgPictureName1(String jpgPictureName1) {
330:                this .jpgPictureName1 = jpgPictureName1;
331:            }
332:
333:            /**
334:             * Gets the jpgPictureName2
335:             * @return Returns a String
336:             */
337:            public String getJpgPictureName2() {
338:                if (this .jpgPictureName2 == null) {
339:                    EMBStaticHelper.testTrace("jpgPictureName2="
340:                            + this .rb.getString("jpgPictureName2"));
341:                    this .setJpgPictureName2(this .rb
342:                            .getString("jpgPictureName2"));
343:
344:                }
345:                return this .jpgPictureName2;
346:            }
347:
348:            /**
349:             * Sets the jpgPictureName2
350:             * @param jpgPictureName2 The jpgPictureName2 to set
351:             */
352:            public void setJpgPictureName2(String jpgPictureName2) {
353:                this .jpgPictureName2 = jpgPictureName2;
354:            }
355:
356:            /**
357:             * Gets the bmpPictureName1
358:             * @return Returns a String
359:             */
360:            public String getBmpPictureName1() {
361:                if (this .bmpPictureName1 == null) {
362:                    EMBStaticHelper.testTrace("bmpPictureName1="
363:                            + this .rb.getString("bmpPictureName1"));
364:                    this .setBmpPictureName1(this .rb
365:                            .getString("bmpPictureName1"));
366:                }
367:                return this .bmpPictureName1;
368:            }
369:
370:            /**
371:             * Sets the bmpPictureName1
372:             * @param bmpPictureName1 The bmpPictureName1 to set
373:             */
374:            public void setBmpPictureName1(String bmpPictureName1) {
375:                this .bmpPictureName1 = bmpPictureName1;
376:            }
377:
378:            /**
379:             * Gets the bmpPictureName2
380:             * @return Returns a String
381:             */
382:            public String getBmpPictureName2() {
383:                if (this .bmpPictureName2 == null) {
384:                    EMBStaticHelper.testTrace("bmpPictureName2="
385:                            + this .rb.getString("bmpPictureName2"));
386:                    this .setBmpPictureName2(this .rb
387:                            .getString("bmpPictureName2"));
388:                }
389:                return this .bmpPictureName2;
390:            }
391:
392:            /**
393:             * Sets the bmpPictureName2
394:             * @param bmpPictureName2 The bmpPictureName2 to set
395:             */
396:            public void setBmpPictureName2(String bmpPictureName2) {
397:                this .bmpPictureName2 = bmpPictureName2;
398:            }
399:
400:            /**
401:             * Gets the mpegMovieName1
402:             * @return Returns a String
403:             */
404:            public String getMpegMovieName1() {
405:                if (this .mpegMovieName1 == null) {
406:                    EMBStaticHelper.testTrace("mpegMovieName1="
407:                            + this .rb.getString("mpegMovieName1"));
408:                    this .setMpegMovieName1(this .rb.getString("mpegMovieName1"));
409:                }
410:                return this .mpegMovieName1;
411:            }
412:
413:            /**
414:             * Sets the mpegMovieName1
415:             * @param mpegMovieName1 The mpegMovieName1 to set
416:             */
417:            public void setMpegMovieName1(String mpegMovieName1) {
418:                this .mpegMovieName1 = mpegMovieName1;
419:            }
420:
421:            /**
422:             * Gets the mp3SoundName1
423:             * @return Returns a String
424:             */
425:            public String getMp3SoundName1() {
426:                if (this .mp3SoundName1 == null) {
427:                    EMBStaticHelper.testTrace("mp3SoundName1="
428:                            + this .rb.getString("mp3SoundName1"));
429:                    this .setMp3SoundName1(this .rb.getString("mp3SoundName1"));
430:                }
431:                return this .mp3SoundName1;
432:            }
433:
434:            /**
435:             * Sets the mp3SoundName1
436:             * @param mp3SoundName1 The mp3SoundName1 to set
437:             */
438:            public void setMp3SoundName1(String mp3SoundName1) {
439:                this .mp3SoundName1 = mp3SoundName1;
440:            }
441:
442:            /**
443:             * Gets the mp3SoundName2
444:             * @return Returns a String
445:             */
446:            public String getMp3SoundName2() {
447:                if (this .mp3SoundName2 == null) {
448:                    EMBStaticHelper.testTrace("mp3SoundName2="
449:                            + this .rb.getString("mp3SoundName2"));
450:                    this .setMp3SoundName2(this .rb.getString("mp3SoundName2"));
451:                }
452:                return this .mp3SoundName2;
453:            }
454:
455:            /**
456:             * Sets the mp3SoundName2
457:             * @param mp3SoundName2 The mp3SoundName2 to set
458:             */
459:            public void setMp3SoundName2(String mp3SoundName2) {
460:                this .mp3SoundName2 = mp3SoundName2;
461:            }
462:
463:            /**
464:             * Gets the playlistName1
465:             * @return Returns a String
466:             */
467:            public String getPlaylistName1() {
468:                if (this .playlistName1 == null) {
469:                    EMBStaticHelper.testTrace("playlistName1="
470:                            + this .rb.getString("playlistName1"));
471:                    this .setPlaylistName1(this .rb.getString("playlistName1"));
472:                }
473:                return this .playlistName1;
474:            }
475:
476:            /**
477:             * Sets the playlistName1
478:             * @param playlistName1 The playlistName1 to set
479:             */
480:            public void setPlaylistName1(String playlistName1) {
481:                this .playlistName1 = playlistName1;
482:            }
483:
484:            /**
485:             * Gets the playlistName2
486:             * @return Returns a String
487:             */
488:            public String getPlaylistName2() {
489:                if (this .playlistName2 == null) {
490:                    EMBStaticHelper.testTrace("playlistName2="
491:                            + this .rb.getString("playlistName2"));
492:                    this .setPlaylistName2(this .rb.getString("playlistName2"));
493:                }
494:                return this .playlistName2;
495:            }
496:
497:            /**
498:             * Sets the playlistName2
499:             * @param playlistName2 The playlistName2 to set
500:             */
501:            public void setPlaylistName2(String playlistName2) {
502:                this .playlistName2 = playlistName2;
503:            }
504:
505:            /**
506:             * Gets the wavSoundName1
507:             * @return Returns a String
508:             */
509:            public String getWavSoundName1() {
510:                if (this .wavSoundName1 == null) {
511:                    EMBStaticHelper.testTrace("wavSoundName1="
512:                            + this .rb.getString("wavSoundName1"));
513:                    this .setWavSoundName1(this .rb.getString("wavSoundName1"));
514:                }
515:                return this .wavSoundName1;
516:            }
517:
518:            /**
519:             * Sets the wavSoundName1
520:             * @param wavSoundName1 The wavSoundName1 to set
521:             */
522:            public void setWavSoundName1(String wavSoundName1) {
523:                this .wavSoundName1 = wavSoundName1;
524:            }
525:
526:            /**
527:             * Gets the writeTrace
528:             * @return Returns a boolean
529:             */
530:            public boolean getWriteTrace() {
531:                return writeTrace;
532:            }
533:
534:            /**
535:             * Sets the writeTrace
536:             * @param writeTrace The writeTrace to set
537:             */
538:            public void setWriteTrace(boolean writeTrace) {
539:                this .writeTrace = writeTrace;
540:            }
541:
542:            /**
543:             * Gets the writeLog
544:             * @return Returns a boolean
545:             */
546:            public boolean getWriteLog() {
547:                return writeLog;
548:            }
549:
550:            /**
551:             * Sets the writeLog
552:             * @param writeLog The writeLog to set
553:             */
554:            public void setWriteLog(boolean writeLog) {
555:                this .writeLog = writeLog;
556:            }
557:
558:            /**
559:             * Gets the logKnownErrors
560:             * @return Returns a boolean
561:             */
562:            public boolean getLogKnownErrors() {
563:                return logKnownErrors;
564:            }
565:
566:            /**
567:             * Sets the logKnownErrors
568:             * @param logKnownErrors The logKnownErrors to set
569:             */
570:            public void setLogKnownErrors(boolean logKnownErrors) {
571:                this .logKnownErrors = logKnownErrors;
572:            }
573:
574:            /**
575:             * Gets the testClientIPAddress
576:             * @return Returns a String
577:             */
578:            public String getTestClientIPAddress() {
579:                if (this .testClientIPAddress == null) {
580:                    EMBStaticHelper.testTrace("TESTCLIENTIPADDRESS="
581:                            + this .rb.getString("TESTCLIENTIPADDRESS"));
582:                    this .setTestClientIPAddress(this .rb
583:                            .getString("TESTCLIENTIPADDRESS"));
584:                }
585:                return testClientIPAddress;
586:            }
587:
588:            /**
589:             * Sets the testClientIPAddress
590:             * @param testClientIPAddress The testClientIPAddress to set
591:             */
592:            public void setTestClientIPAddress(String testClientIPAddress) {
593:                this .testClientIPAddress = testClientIPAddress;
594:            }
595:
596:            /**
597:             * Gets the gzipCorruptFileName
598:             * @return Returns a String
599:             */
600:            public String getGzipCorruptFileName() {
601:                if (this .gzipCorruptFileName == null) {
602:                    EMBStaticHelper.testTrace("gzipCorruptFileName="
603:                            + this .rb.getString("gzipCorruptFileName"));
604:                    this .setGzipCorruptFileName(this .rb
605:                            .getString("gzipCorruptFileName"));
606:
607:                }
608:                return this .gzipCorruptFileName;
609:            }
610:
611:            /**
612:             * Sets the gzipCorruptFileName
613:             * @param gzipCorruptFileName The gzipCorruptFileName to set
614:             */
615:            public void setGzipCorruptFileName(String gzipCorruptFileName) {
616:                this .gzipCorruptFileName = gzipCorruptFileName;
617:            }
618:
619:            /**
620:             * Gets the nonEmbeddedMediaClassName
621:             * @return Returns a String
622:             */
623:            public String getNonEmbeddedMediaClassName() {
624:                if (this .nonEmbeddedMediaClassName == null) {
625:                    EMBStaticHelper.testTrace("nonEmbeddedMediaClassName="
626:                            + this .rb.getString("nonEmbeddedMediaClassName"));
627:                    this .setNonEmbeddedMediaClassName(this .rb
628:                            .getString("nonEmbeddedMediaClassName"));
629:                }
630:                return this .nonEmbeddedMediaClassName;
631:            }
632:
633:            /**
634:             * Sets the nonEmbeddedMediaClassName
635:             * @param nonEmbeddedMediaClassName The nonEmbeddedMediaClassName to set
636:             */
637:            public void setNonEmbeddedMediaClassName(
638:                    String nonEmbeddedMediaClassName) {
639:                this .nonEmbeddedMediaClassName = nonEmbeddedMediaClassName;
640:            }
641:
642:            /**
643:             * Gets the nonEmbeddedMediaFileExt
644:             * @return Returns a String
645:             */
646:            public String getNonEmbeddedMediaFileExt() {
647:                if (this .nonEmbeddedMediaFileExt == null) {
648:                    EMBStaticHelper.testTrace("nonEmbeddedMediaFileExt="
649:                            + this .rb.getString("nonEmbeddedMediaFileExt"));
650:                    this .setNonEmbeddedMediaFileExt(this .rb
651:                            .getString("nonEmbeddedMediaFileExt"));
652:                }
653:                return this .nonEmbeddedMediaFileExt;
654:            }
655:
656:            /**
657:             * Sets the nonEmbeddedMediaFileExt
658:             * @param nonEmbeddedMediaFileExt The nonEmbeddedMediaFileExt to set
659:             */
660:            public void setNonEmbeddedMediaFileExt(
661:                    String nonEmbeddedMediaFileExt) {
662:                this .nonEmbeddedMediaFileExt = nonEmbeddedMediaFileExt;
663:            }
664:
665:            /**
666:             * Gets the nonEmbeddedMediaFile
667:             * @return Returns a String
668:             */
669:            public String getNonEmbeddedMediaFile() {
670:                if (this .nonEmbeddedMediaFile == null) {
671:                    EMBStaticHelper.testTrace("nonEmbeddedMediaFile="
672:                            + this .rb.getString("nonEmbeddedMediaFile"));
673:                    this .setNonEmbeddedMediaFile(this .rb
674:                            .getString("nonEmbeddedMediaFile"));
675:                }
676:                return this .nonEmbeddedMediaFile;
677:            }
678:
679:            /**
680:             * Sets the nonEmbeddedMediaFile
681:             * @param nonEmbeddedMediaFile The nonEmbeddedMediaFile to set
682:             */
683:            public void setNonEmbeddedMediaFile(String nonEmbeddedMediaFile) {
684:                this .nonEmbeddedMediaFile = nonEmbeddedMediaFile;
685:            }
686:
687:            /**
688:             * Gets the allMediaFormats
689:             * @return Returns a String
690:             */
691:            public String getAllMediaFormats() {
692:                if (this .allMediaFormats == null) {
693:                    // EMBStaticHelper.testTrace("allMediaFormats=" +
694:                    // this.rb.getString("allMediaFormats"));
695:                    this .setAllMediaFormats(this .rb
696:                            .getString("allMediaFormats"));
697:                }
698:                return this .allMediaFormats;
699:            }
700:
701:            /**
702:             * Sets the allMediaFormats
703:             * @param allMediaFormats The allMediaFormats to set
704:             */
705:            public void setAllMediaFormats(String allMediaFormats) {
706:                this .allMediaFormats = allMediaFormats;
707:            }
708:
709:            /**
710:             * Gets the allMediaConverterSpecs
711:             * @return Returns a String
712:             */
713:            public String getAllMediaConverterSpecs() {
714:                if (this .allMediaConverterSpecs == null) {
715:                    EMBStaticHelper.testTrace("allMediaConverterSpecs="
716:                            + this .rb.getString("allMediaConverterSpecs"));
717:                    this .setAllMediaConverterSpecs(this .rb
718:                            .getString("allMediaConverterSpecs"));
719:                }
720:                return this .allMediaConverterSpecs;
721:            }
722:
723:            /**
724:             * Sets the allMediaConverterSpecs
725:             * @param allMediaConverterSpecs The allMediaConverterSpecs to set
726:             */
727:            public void setAllMediaConverterSpecs(String allMediaConverterSpecs) {
728:                this .allMediaConverterSpecs = allMediaConverterSpecs;
729:            }
730:
731:            /**
732:             * Gets the streamServerTypes
733:             * @return Returns a string
734:             */
735:            public String getStreamServerTypes() {
736:                if (this .streamServerTypes == null) {
737:                    EMBStaticHelper.testTrace("streamServerTypes="
738:                            + this .rb.getString("streamServerTypes"));
739:                    this .setStreamServerTypes(this .rb
740:                            .getString("streamServerTypes"));
741:                }
742:                return this .streamServerTypes;
743:            }
744:
745:            /**
746:             * Sets the streamServerTypes
747:             * @param streamServerTypes The streamServerTypes to set
748:             */
749:            public void setStreamServerTypes(String streamServerTypes) {
750:                this .streamServerTypes = streamServerTypes;
751:            }
752:
753:            /**
754:             * Gets the classSignatureFile
755:             * @return Returns a string
756:             */
757:            public String getClassSignatureFile() {
758:                if (this .classSignatureFile == null) {
759:                    EMBStaticHelper.testTrace("classSignatureFile="
760:                            + this .rb.getString("classSignatureFile"));
761:                    this .setClassSignatureFile(this .rb
762:                            .getString("classSignatureFile"));
763:                }
764:                return this .classSignatureFile;
765:            }
766:
767:            /**
768:             * Sets the classSignatureFile
769:             * @param classSignatureFile The classSignatureFile to set
770:             */
771:            public void setClassSignatureFile(String classSignatureFile) {
772:                this .classSignatureFile = classSignatureFile;
773:            }
774:
775:            /**
776:             * Gets the listOfClassNamesFile
777:             * @return Returns a string
778:             */
779:            public String getListOfClassNamesFile() {
780:                if (this .listOfClassNamesFile == null) {
781:                    EMBStaticHelper.testTrace("listOfClassNamesFile="
782:                            + this .rb.getString("listOfClassNamesFile"));
783:                    this .setListOfClassNamesFile(this .rb
784:                            .getString("listOfClassNamesFile"));
785:                }
786:                return this .listOfClassNamesFile;
787:            }
788:
789:            /**
790:             * Sets the listOfClassNamesFile
791:             * @param listOfClassNamesFile The listOfClassNamesFile to set
792:             */
793:            public void setListOfClassNamesFile(String listOfClassNamesFile) {
794:                this .listOfClassNamesFile = listOfClassNamesFile;
795:            }
796:
797:            /**
798:             * Gets the xmlFile1
799:             * @return Returns a string
800:             */
801:            public String getXMLFile1() {
802:                if (this .xmlFile1 == null) {
803:                    EMBStaticHelper.testTrace("xmlFile1="
804:                            + this .rb.getString("xmlFile1"));
805:                    this .setXMLFile1(this .rb.getString("xmlFile1"));
806:                }
807:                return this .xmlFile1;
808:            }
809:
810:            /**
811:             * Sets the xmlFile1
812:             * @param xmlFile1 The xmlFile1 to set
813:             */
814:            public void setXMLFile1(String xmlFile1) {
815:                this .xmlFile1 = xmlFile1;
816:            }
817:
818:            /**
819:             * Gets the xmlFile2
820:             * @return Returns a string
821:             */
822:            public String getXMLFile2() {
823:                if (this .xmlFile2 == null) {
824:                    EMBStaticHelper.testTrace("xmlFile2="
825:                            + this .rb.getString("xmlFile2"));
826:                    this .setXMLFile2(this .rb.getString("xmlFile2"));
827:                }
828:                return this .xmlFile2;
829:            }
830:
831:            /**
832:             * Sets the xmlFile2
833:             * @param xmlFile2 The xmlFile2 to set
834:             */
835:            public void setXMLFile2(String xmlFile2) {
836:                this .xmlFile2 = xmlFile2;
837:            }
838:
839:            /**
840:             * Gets the invalidXMLFile1
841:             * @return Returns a string
842:             */
843:            public String getInvalidXMLFile1() {
844:                if (this .invalidXMLFile1 == null) {
845:                    EMBStaticHelper.testTrace("invalidXMLFile1="
846:                            + this .rb.getString("invalidXMLFile1"));
847:                    this .setInvalidXMLFile1(this .rb
848:                            .getString("invalidXMLFile1"));
849:                }
850:                return this .invalidXMLFile1;
851:            }
852:
853:            /**
854:             * Sets the invalidXMLFile1
855:             * @param invalidXMLFile1 The invalidXMLFile1 to set
856:             */
857:            public void setInvalidXMLFile1(String invalidXMLFile1) {
858:                this .invalidXMLFile1 = invalidXMLFile1;
859:            }
860:
861:            /**
862:             * Gets the invalidXMLFile2
863:             * @return Returns a string
864:             */
865:            public String getInvalidXMLFile2() {
866:                if (this .invalidXMLFile2 == null) {
867:                    EMBStaticHelper.testTrace("invalidXMLFile2="
868:                            + this .rb.getString("invalidXMLFile2"));
869:                    this .setInvalidXMLFile2(this .rb
870:                            .getString("invalidXMLFile2"));
871:                }
872:                return this .invalidXMLFile1;
873:            }
874:
875:            /**
876:             * Sets the invalidXMLFile2
877:             * @param invalidXMLFile2 The invalidXMLFile2 to set
878:             */
879:            public void setInvalidXMLFile2(String invalidXMLFile2) {
880:                this .invalidXMLFile2 = invalidXMLFile2;
881:            }
882:
883:            /**
884:             * Gets the queryLanguages
885:             * @return Returns a string
886:             */
887:            public String getQueryLanguages() {
888:                if (this .queryLanguages == null) {
889:                    EMBStaticHelper.testTrace("queryLanguages="
890:                            + this .rb.getString("queryLanguages"));
891:                    this .setQueryLanguages(this .rb.getString("queryLanguages"));
892:                }
893:                return this .queryLanguages;
894:            }
895:
896:            /**
897:             * Sets the queryLanguages
898:             * @param queryLanguages The queryLanguages to set
899:             */
900:            public void setQueryLanguages(String queryLanguages) {
901:                this .queryLanguages = queryLanguages;
902:            }
903:
904:            /**
905:             * Gets the mediaListeners
906:             * @return Returns a string
907:             */
908:            public String getMediaListeners() {
909:                if (this .mediaListeners == null) {
910:                    EMBStaticHelper.testTrace("mediaListeners="
911:                            + this .rb.getString("mediaListeners"));
912:                    this .setMediaListeners(this .rb.getString("mediaListeners"));
913:                }
914:                return this .mediaListeners;
915:            }
916:
917:            /**
918:             * Sets the mediaListeners
919:             * @param mediaListeners The mediaListeners to set
920:             */
921:            public void setMediaListeners(String mediaListeners) {
922:                this .mediaListeners = mediaListeners;
923:            }
924:
925:            /**
926:             * Gets the maxMediaSize
927:             * @return Returns a string
928:             */
929:            public String getMaxMediaSize() {
930:                if (this .maxMediaSize == null) {
931:                    EMBStaticHelper.testTrace("maxMediaSize="
932:                            + this .rb.getString("maxMediaSize"));
933:                    this .setMaxMediaSize(this .rb.getString("maxMediaSize"));
934:                }
935:                return this .maxMediaSize;
936:            }
937:
938:            /**
939:             * Sets the maxMediaSize
940:             * @param maxMediaSize The maxMediaSize to set
941:             */
942:            public void setMaxMediaSize(String maxMediaSize) {
943:                this.maxMediaSize = maxMediaSize;
944:            }
945:        }
www.java2java.com | Contact Us
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.