test files added by Kris Jurka

diff --git a/src/interfaces/jdbc/org/postgresql/test/jdbc2/DatabaseMetaDataPropertiesTest.java b/src/interfaces/jdbc/org/postgresql/test/jdbc2/DatabaseMetaDataPropertiesTest.java
new file mode 100644 (file)
index 0000000..18dee27
--- /dev/null
+++ b/src/interfaces/jdbc/org/postgresql/test/jdbc2/DatabaseMetaDataPropertiesTest.java
@@ -0,0 +1,339 @@
+package org.postgresql.test.jdbc2;
+
+import org.postgresql.test.TestUtil;
+import junit.framework.TestCase;
+import java.sql.*;
+
+/*
+ * TestCase to test the internal functionality of
+ * org.postgresql.jdbc2.DatabaseMetaData's various properties.
+ * Methods which return a ResultSet are tested elsewhere.
+ * This avoids a complicated setUp/tearDown for something like
+ * assertTrue(dbmd.nullPlusNonNullIsNull());
+ */
+
+public class DatabaseMetaDataPropertiesTest extends TestCase
+{
+
+       private Connection con;
+       /*
+        * Constructor
+        */
+       public DatabaseMetaDataPropertiesTest(String name)
+       {
+               super(name);
+       }
+
+       protected void setUp() throws Exception
+       {
+               con = TestUtil.openDB();
+       }
+       protected void tearDown() throws Exception
+       {
+               TestUtil.closeDB( con );
+       }
+
+       /*
+        * The spec says this may return null, but we always do!
+        */
+       public void testGetMetaData()
+       {
+               try
+               {
+
+                       DatabaseMetaData dbmd = con.getMetaData();
+                       assertNotNull(dbmd);
+
+               }
+               catch (SQLException ex)
+               {
+                       fail(ex.getMessage());
+               }
+       }
+
+       /*
+        * Test default capabilities
+        */
+       public void testCapabilities()
+       {
+               try
+               {
+
+                       DatabaseMetaData dbmd = con.getMetaData();
+                       assertNotNull(dbmd);
+
+                       assertTrue(dbmd.allProceduresAreCallable());
+                       assertTrue(dbmd.allTablesAreSelectable()); // not true all the time
+
+                       // This should always be false for postgresql (at least for 7.x)
+                       assertTrue(!dbmd.isReadOnly());
+
+                       // does the backend support this yet? The protocol does...
+                       assertTrue(!dbmd.supportsMultipleResultSets());
+
+                       // yes, as multiple backends can have transactions open
+                       assertTrue(dbmd.supportsMultipleTransactions());
+
+                       assertTrue(dbmd.supportsMinimumSQLGrammar());
+                       assertTrue(!dbmd.supportsCoreSQLGrammar());
+                       assertTrue(!dbmd.supportsExtendedSQLGrammar());
+                       if (TestUtil.haveMinimumServerVersion(con,"7.3"))
+                               assertTrue(dbmd.supportsANSI92EntryLevelSQL());
+                       else
+                               assertTrue(!dbmd.supportsANSI92EntryLevelSQL());
+                       assertTrue(!dbmd.supportsANSI92IntermediateSQL());
+                       assertTrue(!dbmd.supportsANSI92FullSQL());
+
+                       assertTrue(!dbmd.supportsIntegrityEnhancementFacility());
+
+               }
+               catch (SQLException ex)
+               {
+                       fail(ex.getMessage());
+               }
+       }
+
+
+       public void testJoins()
+       {
+               try
+               {
+
+                       DatabaseMetaData dbmd = con.getMetaData();
+                       assertNotNull(dbmd);
+
+                       assertTrue(dbmd.supportsOuterJoins());
+                       assertTrue(dbmd.supportsFullOuterJoins());
+                       assertTrue(dbmd.supportsLimitedOuterJoins());
+
+               }
+               catch (SQLException ex)
+               {
+                       fail(ex.getMessage());
+               }
+       }
+
+       public void testCursors()
+       {
+               try
+               {
+
+                       DatabaseMetaData dbmd = con.getMetaData();
+                       assertNotNull(dbmd);
+
+                       assertTrue(!dbmd.supportsPositionedDelete());
+                       assertTrue(!dbmd.supportsPositionedUpdate());
+
+               }
+               catch (SQLException ex)
+               {
+                       fail(ex.getMessage());
+               }
+       }
+
+       public void testValues()
+       {
+               try {
+                       DatabaseMetaData dbmd = con.getMetaData();
+                       assertNotNull(dbmd);
+                       int indexMaxKeys = dbmd.getMaxColumnsInIndex();
+                       if (TestUtil.haveMinimumServerVersion(con,"7.3")) {
+                               assertEquals(indexMaxKeys,32);
+                       } else {
+                               assertEquals(indexMaxKeys,16);
+                       }
+               } catch (SQLException sqle) {
+                       fail(sqle.getMessage());
+               }
+       }
+
+       public void testNulls()
+       {
+               try
+               {
+
+                       DatabaseMetaData dbmd = con.getMetaData();
+                       assertNotNull(dbmd);
+
+                       assertTrue(!dbmd.nullsAreSortedAtStart());
+                       assertTrue( dbmd.nullsAreSortedAtEnd() != TestUtil.haveMinimumServerVersion(con,"7.2"));
+                       assertTrue( dbmd.nullsAreSortedHigh() == TestUtil.haveMinimumServerVersion(con,"7.2"));
+                       assertTrue(!dbmd.nullsAreSortedLow());
+
+                       assertTrue(dbmd.nullPlusNonNullIsNull());
+
+                       assertTrue(dbmd.supportsNonNullableColumns());
+
+               }
+               catch (SQLException ex)
+               {
+                       fail(ex.getMessage());
+               }
+       }
+
+       public void testLocalFiles()
+       {
+               try
+               {
+
+                       DatabaseMetaData dbmd = con.getMetaData();
+                       assertNotNull(dbmd);
+
+                       assertTrue(!dbmd.usesLocalFilePerTable());
+                       assertTrue(!dbmd.usesLocalFiles());
+
+               }
+               catch (SQLException ex)
+               {
+                       fail(ex.getMessage());
+               }
+       }
+
+       public void testIdentifiers()
+       {
+               try
+               {
+
+                       DatabaseMetaData dbmd = con.getMetaData();
+                       assertNotNull(dbmd);
+
+                       assertTrue(!dbmd.supportsMixedCaseIdentifiers()); // always false
+                       assertTrue(dbmd.supportsMixedCaseQuotedIdentifiers());  // always true
+
+                       assertTrue(!dbmd.storesUpperCaseIdentifiers());   // always false
+                       assertTrue(dbmd.storesLowerCaseIdentifiers());    // always true
+                       assertTrue(!dbmd.storesUpperCaseQuotedIdentifiers()); // always false
+                       assertTrue(!dbmd.storesLowerCaseQuotedIdentifiers()); // always false
+                       assertTrue(!dbmd.storesMixedCaseQuotedIdentifiers()); // always false
+
+                       assertTrue(dbmd.getIdentifierQuoteString().equals("\""));
+
+
+               }
+               catch (SQLException ex)
+               {
+                       fail(ex.getMessage());
+               }
+       }
+
+       public void testTables()
+       {
+               try
+               {
+
+                       DatabaseMetaData dbmd = con.getMetaData();
+                       assertNotNull(dbmd);
+
+                       // we can add columns
+                       assertTrue(dbmd.supportsAlterTableWithAddColumn());
+
+                       // we can only drop columns in >= 7.3
+                       if (TestUtil.haveMinimumServerVersion(con,"7.3")) {
+                               assertTrue(dbmd.supportsAlterTableWithDropColumn());
+                       } else {
+                               assertTrue(!dbmd.supportsAlterTableWithDropColumn());
+                       }
+               }
+               catch (SQLException ex)
+               {
+                       fail(ex.getMessage());
+               }
+       }
+
+       public void testSelect()
+       {
+               try
+               {
+
+                       DatabaseMetaData dbmd = con.getMetaData();
+                       assertNotNull(dbmd);
+
+                       // yes we can?: SELECT col a FROM a;
+                       assertTrue(dbmd.supportsColumnAliasing());
+
+                       // yes we can have expressions in ORDERBY
+                       assertTrue(dbmd.supportsExpressionsInOrderBy());
+
+                       // Yes, an ORDER BY clause can contain columns that are not in the
+                       // SELECT clause.
+                       assertTrue(dbmd.supportsOrderByUnrelated());
+
+                       assertTrue(dbmd.supportsGroupBy());
+                       assertTrue(dbmd.supportsGroupByUnrelated());
+                       assertTrue(dbmd.supportsGroupByBeyondSelect()); // needs checking
+
+               }
+               catch (SQLException ex)
+               {
+                       fail(ex.getMessage());
+               }
+       }
+
+       public void testDBParams()
+       {
+               try
+               {
+
+                       DatabaseMetaData dbmd = con.getMetaData();
+                       assertNotNull(dbmd);
+
+                       assertTrue(dbmd.getURL().equals(TestUtil.getURL()));
+                       assertTrue(dbmd.getUserName().equals(TestUtil.getUser()));
+
+               }
+               catch (SQLException ex)
+               {
+                       fail(ex.getMessage());
+               }
+       }
+
+       public void testDbProductDetails()
+       {
+               try
+               {
+                       assertTrue(con instanceof org.postgresql.PGConnection);
+                       org.postgresql.jdbc2.AbstractJdbc2Connection pc = (org.postgresql.jdbc2.AbstractJdbc2Connection) con;
+
+                       DatabaseMetaData dbmd = con.getMetaData();
+                       assertNotNull(dbmd);
+
+                       assertTrue(dbmd.getDatabaseProductName().equals("PostgreSQL"));
+                       //The test below doesn't make sense to me, it tests that
+                       //the version of the driver = the version of the database it is connected to
+                       //since the driver should be backwardly compatible this test is commented out
+                       //assertTrue(dbmd.getDatabaseProductVersion().startsWith(
+                       //                 Integer.toString(pc.getDriver().getMajorVersion())
+                       //                 + "."
+                       //                 + Integer.toString(pc.getDriver().getMinorVersion())));
+                       assertTrue(dbmd.getDriverName().equals("PostgreSQL Native Driver"));
+
+               }
+               catch (SQLException ex)
+               {
+                       fail(ex.getMessage());
+               }
+       }
+
+       public void testDriverVersioning()
+       {
+               try
+               {
+                       assertTrue(con instanceof org.postgresql.PGConnection);
+                       org.postgresql.jdbc2.AbstractJdbc2Connection pc = (org.postgresql.jdbc2.AbstractJdbc2Connection) con;
+
+                       DatabaseMetaData dbmd = con.getMetaData();
+                       assertNotNull(dbmd);
+
+                       assertTrue(dbmd.getDriverVersion().equals(pc.getDriver().getVersion()));
+                       assertTrue(dbmd.getDriverMajorVersion() == pc.getDriver().getMajorVersion());
+                       assertTrue(dbmd.getDriverMinorVersion() == pc.getDriver().getMinorVersion());
+
+
+               }
+               catch (SQLException ex)
+               {
+                       fail(ex.getMessage());
+               }
+       }
+}
+

diff --git a/src/interfaces/jdbc/org/postgresql/test/jdbc2/SerializeObject.java b/src/interfaces/jdbc/org/postgresql/test/jdbc2/SerializeObject.java
new file mode 100644 (file)
index 0000000..c2dd6cc
--- /dev/null
+++ b/src/interfaces/jdbc/org/postgresql/test/jdbc2/SerializeObject.java
@@ -0,0 +1,11 @@
+package org.postgresql.test.jdbc2;
+
+import java.io.Serializable;
+
+public class SerializeObject implements Serializable {
+
+       public int intcol;
+       public double doublecol;
+       public String stringcol;
+
+}

diff --git a/src/interfaces/jdbc/org/postgresql/test/jdbc2/SerializeTest.java b/src/interfaces/jdbc/org/postgresql/test/jdbc2/SerializeTest.java
new file mode 100644 (file)
index 0000000..73d512f
--- /dev/null
+++ b/src/interfaces/jdbc/org/postgresql/test/jdbc2/SerializeTest.java
@@ -0,0 +1,47 @@
+package org.postgresql.test.jdbc2;
+
+import org.postgresql.test.TestUtil;
+import junit.framework.TestCase;
+import java.sql.*;
+import org.postgresql.util.Serialize;
+
+public class SerializeTest extends TestCase {
+
+       private Connection conn;
+       private SerializeObject serobj;
+       private Serialize ser;
+
+       public SerializeTest(String name) {
+               super(name);
+       }
+
+       protected void setUp() throws Exception {
+               conn = TestUtil.openDB();
+               serobj = new SerializeObject();
+               serobj.intcol = 1;
+               serobj.doublecol = 3.4;
+               serobj.stringcol = "Hello";
+               TestUtil.dropTable(conn,Serialize.toPostgreSQL(conn,serobj.getClass().getName()));
+               Serialize.create(conn, serobj);
+               Serialize.create(conn, serobj);
+               ser = new Serialize(conn,serobj);
+       }
+
+       protected void tearDown() throws Exception {
+               TestUtil.dropTable(conn,Serialize.toPostgreSQL(conn,serobj.getClass().getName()));
+       }
+
+       public void testCreateSerialize() {
+               try {
+                       long oid = ser.storeObject(serobj);
+                       SerializeObject serobj2 = (SerializeObject)ser.fetch(oid);
+                       assertNotNull(serobj2);
+                       assertEquals(serobj.intcol,serobj2.intcol);
+                       assertTrue(Math.abs(serobj.doublecol-serobj2.doublecol) < 0.0001);
+                       assertTrue(serobj.stringcol.equals(serobj2.stringcol));
+               } catch (SQLException sqle) {
+                       fail(sqle.getMessage());
+               }
+       }
+
+}