DatabaseSchemaManagerTest


1   /*
2    * Copyright (c) 2003 - 2007 OpenSubsystems s.r.o. Slovak Republic. All rights reserved.
3    * 
4    * Project: OpenSubsystems
5    * 
6    * $Id: DatabaseSchemaManagerTest.java,v 1.10 2007/01/07 06:14:20 bastafidli Exp $
7    * 
8    * This program is free software; you can redistribute it and/or modify
9    * it under the terms of the GNU General Public License as published by
10   * the Free Software Foundation; version 2 of the License. 
11   * 
12   * This program is distributed in the hope that it will be useful,
13   * but WITHOUT ANY WARRANTY; without even the implied warranty of
14   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15   * GNU General Public License for more details.
16   * 
17   * You should have received a copy of the GNU General Public License
18   * along with this program; if not, write to the Free Software
19   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
20   */
21  
22  package org.opensubsystems.core.persist.db;
23  
24  import java.util.Properties  ;
25  
26  import junit.framework.TestCase;
27  
28  import org.opensubsystems.core.persist.db.driver.DatabaseTestSchema;
29  import org.opensubsystems.core.persist.db.driver.db2.DB2DatabaseTestSchema;
30  import org.opensubsystems.core.persist.db.driver.hsqldb.HsqlDBDatabaseTestSchema;
31  import org.opensubsystems.core.persist.db.driver.maxdb.MaxDBDatabaseTestSchema;
32  import org.opensubsystems.core.persist.db.driver.mssql.MSSQLDatabaseTestSchema;
33  import org.opensubsystems.core.persist.db.driver.mysql.MySQLDatabaseTestSchema;
34  import org.opensubsystems.core.persist.db.driver.oracle.OracleDatabaseTestSchema;
35  import org.opensubsystems.core.persist.db.driver.postgresql.PostgreSQLDatabaseTestSchema;
36  import org.opensubsystems.core.persist.db.driver.sapdb.SapDBDatabaseTestSchema;
37  import org.opensubsystems.core.persist.db.driver.sybase.SybaseDatabaseTestSchema;
38  import org.opensubsystems.core.util.Config;
39  
40  /**
41   * Tests for manager of database schema classes.
42   * 
43   * @version $Id: DatabaseSchemaManagerTest.java,v 1.10 2007/01/07 06:14:20 bastafidli Exp $
44   * @author Miro Halas
45   * @code.reviewer Miro Halas
46   * @code.reviewed Initial revision
47   */
48  public class DatabaseSchemaManagerTest extends TestCase
49  {
50     // Tests ////////////////////////////////////////////////////////////////////
51  
52     /**
53      * Constructor for DatabaseSchemaManagerTest.
54      * @param arg0 - name of the test
55      */
56     public DatabaseSchemaManagerTest(
57        String   arg0
58     )
59     {
60        super(arg0);
61     }
62  
63     /**
64      * Set up environment for the test case.
65      * 
66      * @throws Exception - an error has occured during setting up test
67      */
68     protected void setUp(
69     ) throws Exception  
70     {
71        super.setUp();
72     }
73  
74     /**
75      * Restore original environment after the test case.
76      * 
77      * @throws Exception - an error has occured during tearing down up test
78      */
79     protected void tearDown() throws Exception  
80     {
81        super.tearDown();
82     }
83  
84     /**
85      * Test getSchemaInstance method 
86      * 
87      * @throws Exception - and error has occured  
88      */
89     public void testGetSchemaInstance(
90     ) throws Exception  
91     {
92        Config originalInstance;
93        
94        originalInstance = Config.getInstance();
95        try
96        {
97           Object                  test;
98           Object                  test2;
99           Object                  test3;
100          DatabaseSchemaManager schemaManager = new DatabaseSchemaManager();
101          
102          // Create instance of schema for current database
103          test = schemaManager.getSchemaInstance(DatabaseTestSchema.class);
104          assertNotNull("Cannot instantiate class", test);      
105          assertTrue("Must be instance of DatabaseSchema", 
106                     test instanceof DatabaseSchema);
107          assertTrue("Must be instance of DatabaseTestSchema", 
108                     test instanceof DatabaseTestSchema);
109          switch (DatabaseImpl.getInstance().getDatabaseType())
110          {
111             case (Database.HSQLDB_DATABASE_TYPE) :
112             {
113                assertTrue("Must be instance of HsqlDBDatabaseTestSchema", 
114                           test instanceof HsqlDBDatabaseTestSchema);
115                break;
116             }
117             case (Database.SAPDB_DATABASE_TYPE) :
118             {
119                assertTrue("Must be instance of SapDBDatabaseTestSchema", 
120                           test instanceof SapDBDatabaseTestSchema);
121                break;               
122             }
123             case (Database.MAXDB_DATABASE_TYPE) :
124             {
125                assertTrue("Must be instance of MaxDBDatabaseTestSchema", 
126                           test instanceof MaxDBDatabaseTestSchema);
127                break;               
128             }
129             case (Database.POSTGRESQL_DATABASE_TYPE) :
130             {
131                assertTrue("Must be instance of PostgreSQLDatabaseTestSchema", 
132                           test instanceof PostgreSQLDatabaseTestSchema);
133                break;               
134             }
135             case (Database.MYSQL_DATABASE_TYPE) :
136             {
137                assertTrue("Must be instance of MySQLDatabaseTestSchema", 
138                           test instanceof MySQLDatabaseTestSchema);
139                break;               
140             }
141             case (Database.MSSQL_DATABASE_TYPE) :
142             {
143                assertTrue("Must be instance of MSSQLDatabaseTestSchema", 
144                           test instanceof MSSQLDatabaseTestSchema);
145                break;               
146             }
147             case (Database.DB2_DATABASE_TYPE) :
148             {
149                assertTrue("Must be instance of DB2DatabaseTestSchema", 
150                           test instanceof DB2DatabaseTestSchema);
151                break;               
152             }
153             case (Database.SYBASE_DATABASE_TYPE) :
154             {
155                assertTrue("Must be instance of SybaseDatabaseTestSchema", 
156                           test instanceof SybaseDatabaseTestSchema);
157                break;               
158             }
159             case (Database.ORACLE_DATABASE_TYPE) :
160             {
161                assertTrue("Must be instance of OracleDatabaseTestSchema", 
162                           test instanceof OracleDatabaseTestSchema);
163                break;               
164             }
165             default:
166             {
167                fail("Unknown database type");
168             }
169          }
170 
171          // Now make sure that the instance is cached, ask for it again and we
172          // should get the same
173          test2 = schemaManager.getSchemaInstance(DatabaseTestSchema.class);
174          assertTrue("The database schema is not cached.", test == test2);
175          
176          // Now create new configuration file which will instruct the class 
177          // factory to create completely different class when asked for the 
178          // default class. This allows us configurable overriding
179          Properties   predefinedProperties = new Properties  ();
180          switch (DatabaseImpl.getInstance().getDatabaseType())
181          {
182             case (Database.HSQLDB_DATABASE_TYPE) :
183             {
184                // Put some other database schema to test This still override
185                // whatever the environment says
186                predefinedProperties.put(DatabaseTestSchema.class.getName(), 
187                                         SapDBDatabaseTestSchema.class.getName());
188                break;
189             }
190             case (Database.SAPDB_DATABASE_TYPE) :
191             {
192                // Put some other database schema to test This still override
193                // whatever the environment says
194                predefinedProperties.put(DatabaseTestSchema.class.getName(), 
195                                         MaxDBDatabaseTestSchema.class.getName());
196                break;               
197             }
198             case (Database.MAXDB_DATABASE_TYPE) :
199             {
200                // Put some other database schema to test This still override
201                // whatever the environment says
202                predefinedProperties.put(DatabaseTestSchema.class.getName(), 
203                                         PostgreSQLDatabaseTestSchema.class.getName());
204                break;               
205             }
206             case (Database.POSTGRESQL_DATABASE_TYPE) :
207             {
208                // Put some other database schema to test This still override
209                // whatever the environment says
210                predefinedProperties.put(DatabaseTestSchema.class.getName(), 
211                                         MySQLDatabaseTestSchema.class.getName());
212                break;               
213             }
214             case (Database.MYSQL_DATABASE_TYPE) :
215             {
216                // Put some other database schema to test This still override
217                // whatever the environment says
218                predefinedProperties.put(DatabaseTestSchema.class.getName(), 
219                                         MSSQLDatabaseTestSchema.class.getName());
220                break;               
221             }
222             case (Database.MSSQL_DATABASE_TYPE) :
223             {
224                // Put some other database schema to test This still override
225                // whatever the environment says
226                predefinedProperties.put(DatabaseTestSchema.class.getName(), 
227                                         DB2DatabaseTestSchema.class.getName());
228                break;               
229             }
230             case (Database.DB2_DATABASE_TYPE) :
231             {
232                // Put some other database schema to test This still override
233                // whatever the environment says
234                predefinedProperties.put(DatabaseTestSchema.class.getName(), 
235                                         SybaseDatabaseTestSchema.class.getName());
236                break;               
237             }
238             case (Database.SYBASE_DATABASE_TYPE) :
239             {
240                // Put some other database schema to test This still override
241                // whatever the environment says
242                predefinedProperties.put(DatabaseTestSchema.class.getName(), 
243                                         OracleDatabaseTestSchema.class.getName());
244                break;               
245             }
246             case (Database.ORACLE_DATABASE_TYPE) :
247             {
248                // Put some other database schema to test This still override
249                // whatever the environment says
250                predefinedProperties.put(DatabaseTestSchema.class.getName(), 
251                                         HsqlDBDatabaseTestSchema.class.getName());
252                break;               
253             }
254             default:
255             {
256                fail("Unknown database type");
257             }
258          }
259          // Now reset the default configuration file to use our properties
260          Config.setInstance(new Config(predefinedProperties));
261       
262          // And now ask for the class and we should get the original class
263          // since it is cached
264          test = schemaManager.getSchemaInstance(DatabaseTestSchema.class);
265          assertNotNull("Cannot instantiate class", test);      
266          assertTrue("Must be instance of DatabaseSchema", 
267                     test instanceof DatabaseSchema);
268          assertTrue("Must be instance of DatabaseTestSchema", 
269                     test instanceof DatabaseTestSchema);
270          switch (DatabaseImpl.getInstance().getDatabaseType())
271          {
272             case (Database.HSQLDB_DATABASE_TYPE) :
273             {
274                assertTrue("Must be instance of HsqlDBDatabaseTestSchema", 
275                           test instanceof HsqlDBDatabaseTestSchema);
276                break;
277             }
278             case (Database.SAPDB_DATABASE_TYPE) :
279             {
280                assertTrue("Must be instance of SapDBDatabaseTestSchema", 
281                           test instanceof SapDBDatabaseTestSchema);
282                break;               
283             }
284             case (Database.MAXDB_DATABASE_TYPE) :
285             {
286                assertTrue("Must be instance of MaxDBDatabaseTestSchema", 
287                           test instanceof MaxDBDatabaseTestSchema);
288                break;               
289             }
290             case (Database.POSTGRESQL_DATABASE_TYPE) :
291             {
292                assertTrue("Must be instance of PostgreSQLDatabaseTestSchema", 
293                           test instanceof PostgreSQLDatabaseTestSchema);
294                break;               
295             }
296             case (Database.MYSQL_DATABASE_TYPE) :
297             {
298                assertTrue("Must be instance of MySQLDatabaseTestSchema", 
299                           test instanceof MySQLDatabaseTestSchema);
300                break;               
301             }
302             case (Database.MSSQL_DATABASE_TYPE) :
303             {
304                assertTrue("Must be instance of MSSQLDatabaseTestSchema", 
305                           test instanceof MSSQLDatabaseTestSchema);
306                break;               
307             }
308             case (Database.DB2_DATABASE_TYPE) :
309             {
310                assertTrue("Must be instance of DB2DatabaseTestSchema", 
311                           test instanceof DB2DatabaseTestSchema);
312                break;               
313             }
314             case (Database.SYBASE_DATABASE_TYPE) :
315             {
316                assertTrue("Must be instance of SybaseDatabaseTestSchema", 
317                           test instanceof SybaseDatabaseTestSchema);
318                break;               
319             }
320             case (Database.ORACLE_DATABASE_TYPE) :
321             {
322                assertTrue("Must be instance of OracleDatabaseTestSchema", 
323                           test instanceof OracleDatabaseTestSchema);
324                break;               
325             }
326             default:
327             {
328                fail("Unknown database type");
329             }
330          }
331          assertTrue("The database schema is not cached.", test == test2);
332          
333          // But if we create new instance of schema manager, nothing will be
334          // cached and we should get the misconfigured class
335          schemaManager = new DatabaseSchemaManager();
336          test3 = schemaManager.getSchemaInstance(DatabaseTestSchema.class);
337          assertNotNull("Cannot instantiate class", test);      
338          assertTrue("Must be instance of DatabaseSchema", 
339                     test instanceof DatabaseSchema);
340          assertTrue("Must be instance of DatabaseTestSchema", 
341                     test instanceof DatabaseTestSchema);
342          switch (DatabaseImpl.getInstance().getDatabaseType())
343          {
344             case (Database.HSQLDB_DATABASE_TYPE) :
345             {
346                assertTrue("Must be instance of SapDBDatabaseTestSchema", 
347                           test3 instanceof SapDBDatabaseTestSchema);
348                break;
349             }
350             case (Database.SAPDB_DATABASE_TYPE) :
351             {
352                assertTrue("Must be instance of PostgreSQLDatabaseTestSchema", 
353                           test3 instanceof MaxDBDatabaseTestSchema);
354                break;               
355             }
356             case (Database.MAXDB_DATABASE_TYPE) :
357             {
358                assertTrue("Must be instance of PostgreSQLDatabaseTestSchema", 
359                           test3 instanceof PostgreSQLDatabaseTestSchema);
360                break;               
361             }
362             case (Database.POSTGRESQL_DATABASE_TYPE) :
363             {
364                assertTrue("Must be instance of MySQLDatabaseTestSchema", 
365                           test3 instanceof MySQLDatabaseTestSchema);
366                break;               
367             }
368             case (Database.MYSQL_DATABASE_TYPE) :
369             {
370                assertTrue("Must be instance of MSSQLDatabaseTestSchema", 
371                           test3 instanceof MSSQLDatabaseTestSchema);
372                break;               
373             }
374             case (Database.MSSQL_DATABASE_TYPE) :
375             {
376                assertTrue("Must be instance of DB2DatabaseTestSchema", 
377                           test3 instanceof DB2DatabaseTestSchema);
378                break;               
379             }
380             case (Database.DB2_DATABASE_TYPE) :
381             {
382                assertTrue("Must be instance of SybaseDatabaseTestSchema", 
383                           test3 instanceof SybaseDatabaseTestSchema);
384                break;               
385             }
386             case (Database.SYBASE_DATABASE_TYPE) :
387             {
388                assertTrue("Must be instance of OracleDatabaseTestSchema", 
389                           test3 instanceof OracleDatabaseTestSchema);
390                break;               
391             }
392             case (Database.ORACLE_DATABASE_TYPE) :
393             {
394                assertTrue("Must be instance of HsqlDBDatabaseTestSchema", 
395                           test3 instanceof HsqlDBDatabaseTestSchema);
396                break;               
397             }
398             default:
399             {
400                fail("Unknown database type");
401             }
402          }
403          // And since This is new instance, the cached copy should be different
404          // from the previous ones
405          assertFalse("The database schema is not cached.", test == test3);
406       }
407       finally
408       {
409          // Reset the default config instance since other tests may depend on it
410          Config.setInstance(originalInstance);
411       }
412    }
413 
414    /**
415     * Test getInstance method 
416     * 
417     * @throws Exception - and error has occured  
418     */
419    public void testGetInstance(
420    ) throws Exception  
421    {
422       Config originalInstance;
423       
424       originalInstance = Config.getInstance();
425       try
426       {
427          Object   test;
428          Object   test2;
429          
430          // Create instance of schema for current database
431          test = DatabaseSchemaManager.getInstance(DatabaseTestSchema.class);
432          assertNotNull("Cannot instantiate class", test);      
433          assertTrue("Must be instance of DatabaseSchema", 
434                     test instanceof DatabaseSchema);
435          assertTrue("Must be instance of DatabaseTestSchema", 
436                     test instanceof DatabaseTestSchema);
437          switch (DatabaseImpl.getInstance().getDatabaseType())
438          {
439             case (Database.HSQLDB_DATABASE_TYPE) :
440             {
441                assertTrue("Must be instance of HsqlDBDatabaseTestSchema", 
442                           test instanceof HsqlDBDatabaseTestSchema);
443                break;
444             }
445             case (Database.SAPDB_DATABASE_TYPE) :
446             {
447                assertTrue("Must be instance of SapDBDatabaseTestSchema", 
448                           test instanceof SapDBDatabaseTestSchema);
449                break;               
450             }
451             case (Database.MAXDB_DATABASE_TYPE) :
452             {
453                assertTrue("Must be instance of MaxDBDatabaseTestSchema", 
454                           test instanceof MaxDBDatabaseTestSchema);
455                break;               
456             }
457             case (Database.POSTGRESQL_DATABASE_TYPE) :
458             {
459                assertTrue("Must be instance of PostgreSQLDatabaseTestSchema", 
460                           test instanceof PostgreSQLDatabaseTestSchema);
461                break;               
462             }
463             case (Database.MYSQL_DATABASE_TYPE) :
464             {
465                assertTrue("Must be instance of MySQLDatabaseTestSchema", 
466                           test instanceof MySQLDatabaseTestSchema);
467                break;               
468             }
469             case (Database.MSSQL_DATABASE_TYPE) :
470             {
471                assertTrue("Must be instance of MSSQLDatabaseTestSchema", 
472                           test instanceof MSSQLDatabaseTestSchema);
473                break;               
474             }
475             case (Database.DB2_DATABASE_TYPE) :
476             {
477                assertTrue("Must be instance of DB2DatabaseTestSchema", 
478                           test instanceof DB2DatabaseTestSchema);
479                break;               
480             }
481             case (Database.SYBASE_DATABASE_TYPE) :
482             {
483                assertTrue("Must be instance of SybaseDatabaseTestSchema", 
484                           test instanceof SybaseDatabaseTestSchema);
485                break;               
486             }
487             case (Database.ORACLE_DATABASE_TYPE) :
488             {
489                assertTrue("Must be instance of OracleDatabaseTestSchema", 
490                           test instanceof OracleDatabaseTestSchema);
491                break;               
492             }
493             default:
494             {
495                fail("Unknown database type");
496             }
497          }
498 
499          // Now make sure that the instance is cached, ask for it again and we
500          // should get the same
501          test2 = DatabaseSchemaManager.getInstance(DatabaseTestSchema.class);
502          assertTrue("The database schema is not cached.", test == test2);
503          
504          // Now create new configuration file which will instruct the class 
505          // factory to create completely different class when asked for the 
506          // default class. This allows us configurable overriding
507          Properties   predefinedProperties = new Properties  ();
508          switch (DatabaseImpl.getInstance().getDatabaseType())
509          {
510             case (Database.HSQLDB_DATABASE_TYPE) :
511             {
512                // Put some other database schema to test This still override
513                // whatever the environment says
514                predefinedProperties.put(DatabaseTestSchema.class.getName(), 
515                                         SapDBDatabaseTestSchema.class.getName());
516                break;
517             }
518             case (Database.SAPDB_DATABASE_TYPE) :
519             {
520                // Put some other database schema to test This still override
521                // whatever the environment says
522                predefinedProperties.put(DatabaseTestSchema.class.getName(), 
523                                         MaxDBDatabaseTestSchema.class.getName());
524                break;               
525             }
526             case (Database.MAXDB_DATABASE_TYPE) :
527             {
528                // Put some other database schema to test This still override
529                // whatever the environment says
530                predefinedProperties.put(DatabaseTestSchema.class.getName(), 
531                                         PostgreSQLDatabaseTestSchema.class.getName());
532                break;               
533             }
534             case (Database.POSTGRESQL_DATABASE_TYPE) :
535             {
536                // Put some other database schema to test This still override
537                // whatever the environment says
538                predefinedProperties.put(DatabaseTestSchema.class.getName(), 
539                                         MySQLDatabaseTestSchema.class.getName());
540                break;               
541             }
542             case (Database.MYSQL_DATABASE_TYPE) :
543             {
544                // Put some other database schema to test This still override
545                // whatever the environment says
546                predefinedProperties.put(DatabaseTestSchema.class.getName(), 
547                                         MSSQLDatabaseTestSchema.class.getName());
548                break;               
549             }
550             case (Database.MSSQL_DATABASE_TYPE) :
551             {
552                // Put some other database schema to test This still override
553                // whatever the environment says
554                predefinedProperties.put(DatabaseTestSchema.class.getName(), 
555                                         DB2DatabaseTestSchema.class.getName());
556                break;               
557             }
558             case (Database.DB2_DATABASE_TYPE) :
559             {
560                // Put some other database schema to test This still override
561                // whatever the environment says
562                predefinedProperties.put(DatabaseTestSchema.class.getName(), 
563                                         SybaseDatabaseTestSchema.class.getName());
564                break;               
565             }
566             case (Database.SYBASE_DATABASE_TYPE) :
567             {
568                // Put some other database schema to test This still override
569                // whatever the environment says
570                predefinedProperties.put(DatabaseTestSchema.class.getName(), 
571                                         OracleDatabaseTestSchema.class.getName());
572                break;               
573             }
574             case (Database.ORACLE_DATABASE_TYPE) :
575             {
576                // Put some other database schema to test This still override
577                // whatever the environment says
578                predefinedProperties.put(DatabaseTestSchema.class.getName(), 
579                                         HsqlDBDatabaseTestSchema.class.getName());
580                break;               
581             }
582             default:
583             {
584                fail("Unknown database type");
585             }
586          }
587          // Now reset the default configuration file to use our properties
588          Config.setInstance(new Config(predefinedProperties));
589       
590          // And now ask for the class and we should get the original class
591          // since it is cached
592          test = DatabaseSchemaManager.getInstance(DatabaseTestSchema.class);
593          assertNotNull("Cannot instantiate class", test);      
594          assertTrue("Must be instance of DatabaseSchema", 
595                     test instanceof DatabaseSchema);
596          assertTrue("Must be instance of DatabaseTestSchema", 
597                     test instanceof DatabaseTestSchema);
598          switch (DatabaseImpl.getInstance().getDatabaseType())
599          {
600             case (Database.HSQLDB_DATABASE_TYPE) :
601             {
602                assertTrue("Must be instance of HsqlDBDatabaseTestSchema", 
603                           test instanceof HsqlDBDatabaseTestSchema);
604                break;
605             }
606             case (Database.SAPDB_DATABASE_TYPE) :
607             {
608                assertTrue("Must be instance of SapDBDatabaseTestSchema", 
609                           test instanceof SapDBDatabaseTestSchema);
610                break;               
611             }
612             case (Database.MAXDB_DATABASE_TYPE) :
613             {
614                assertTrue("Must be instance of MaxDBDatabaseTestSchema", 
615                           test instanceof MaxDBDatabaseTestSchema);
616                break;               
617             }
618             case (Database.POSTGRESQL_DATABASE_TYPE) :
619             {
620                assertTrue("Must be instance of PostgreSQLDatabaseTestSchema", 
621                           test instanceof PostgreSQLDatabaseTestSchema);
622                break;               
623             }
624             case (Database.MYSQL_DATABASE_TYPE) :
625             {
626                assertTrue("Must be instance of MySQLDatabaseTestSchema", 
627                           test instanceof MySQLDatabaseTestSchema);
628                break;               
629             }
630             case (Database.MSSQL_DATABASE_TYPE) :
631             {
632                assertTrue("Must be instance of MSSQLDatabaseTestSchema", 
633                           test instanceof MSSQLDatabaseTestSchema);
634                break;               
635             }
636             case (Database.DB2_DATABASE_TYPE) :
637             {
638                assertTrue("Must be instance of DB2DatabaseTestSchema", 
639                           test instanceof DB2DatabaseTestSchema);
640                break;               
641             }
642             case (Database.SYBASE_DATABASE_TYPE) :
643             {
644                assertTrue("Must be instance of SybaseDatabaseTestSchema", 
645                           test instanceof SybaseDatabaseTestSchema);
646                break;               
647             }
648             case (Database.ORACLE_DATABASE_TYPE) :
649             {
650                assertTrue("Must be instance of OracleDatabaseTestSchema", 
651                           test instanceof OracleDatabaseTestSchema);
652                break;               
653             }
654             default:
655             {
656                fail("Unknown database type");
657             }
658          }
659       }
660       finally
661       {
662          // Reset the default config instance since other tests may depend on it
663          Config.setInstance(originalInstance);
664       }
665    }
666 }
667
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags