test files added by Kris Jurka

src/interfaces/jdbc/org/postgresql/test/jdbc2/DatabaseMetaDataPropertiesTest.java

+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());
+		}
+	}
+}
+

src/interfaces/jdbc/org/postgresql/test/jdbc2/SerializeObject.java

+package org.postgresql.test.jdbc2;
+
+import java.io.Serializable;
+
+public class SerializeObject implements Serializable {
+
+	public int intcol;
+	public double doublecol;
+	public String stringcol;
+
+}

src/interfaces/jdbc/org/postgresql/test/jdbc2/SerializeTest.java

+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());
+		}
+	}
+
+}