From fd972e7f7edeee5eb410070e204a11a197703cf9 Mon Sep 17 00:00:00 2001
From: Dave Cramer <davec@fastcrypt.com>
Date: Tue, 1 Oct 2002 16:11:30 +0000
Subject: [PATCH] test files added by Kris Jurka
---
.../jdbc2/DatabaseMetaDataPropertiesTest.java | 339 ++++++++++++++++++
.../test/jdbc2/SerializeObject.java | 11 +
.../postgresql/test/jdbc2/SerializeTest.java | 47 +++
3 files changed, 397 insertions(+)
create mode 100644 src/interfaces/jdbc/org/postgresql/test/jdbc2/DatabaseMetaDataPropertiesTest.java
create mode 100644 src/interfaces/jdbc/org/postgresql/test/jdbc2/SerializeObject.java
create mode 100644 src/interfaces/jdbc/org/postgresql/test/jdbc2/SerializeTest.java
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
index 00000000000..18dee272340
--- /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
index 00000000000..c2dd6ccf489
--- /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
index 00000000000..73d512f5889
--- /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());
+ }
+ }
+
+}
--
GitLab