You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@jena.apache.org by rv...@apache.org on 2013/06/10 20:18:36 UTC
svn commit: r1491551 - in /jena/Experimental/jena-jdbc:
jena-jdbc-core/src/test/java/org/apache/jena/jdbc/results/
jena-jdbc-core/src/test/java/org/apache/jena/jdbc/statements/
jena-jdbc-driver-tdb/src/test/java/org/apache/jena/jdbc/tdb/connections/
je...
Author: rvesse
Date: Mon Jun 10 18:18:35 2013
New Revision: 1491551
URL: http://svn.apache.org/r1491551
Log:
More tests for JDBC result sets, improve TDB tests clean up
Modified:
jena/Experimental/jena-jdbc/jena-jdbc-core/src/test/java/org/apache/jena/jdbc/results/AbstractResultSetTests.java
jena/Experimental/jena-jdbc/jena-jdbc-core/src/test/java/org/apache/jena/jdbc/statements/AbstractJenaStatementTests.java
jena/Experimental/jena-jdbc/jena-jdbc-driver-tdb/src/test/java/org/apache/jena/jdbc/tdb/connections/TestTdbDiskConnection.java
jena/Experimental/jena-jdbc/jena-jdbc-driver-tdb/src/test/java/org/apache/jena/jdbc/tdb/connections/TestTdbMemConnection.java
jena/Experimental/jena-jdbc/jena-jdbc-driver-tdb/src/test/java/org/apache/jena/jdbc/tdb/metadata/TestTdbConnectionMetadata.java
jena/Experimental/jena-jdbc/jena-jdbc-driver-tdb/src/test/java/org/apache/jena/jdbc/tdb/results/TestTdbDiskResultSets.java
jena/Experimental/jena-jdbc/jena-jdbc-driver-tdb/src/test/java/org/apache/jena/jdbc/tdb/results/TestTdbMemResultSets.java
Modified: jena/Experimental/jena-jdbc/jena-jdbc-core/src/test/java/org/apache/jena/jdbc/results/AbstractResultSetTests.java
URL: http://svn.apache.org/viewvc/jena/Experimental/jena-jdbc/jena-jdbc-core/src/test/java/org/apache/jena/jdbc/results/AbstractResultSetTests.java?rev=1491551&r1=1491550&r2=1491551&view=diff
==============================================================================
--- jena/Experimental/jena-jdbc/jena-jdbc-core/src/test/java/org/apache/jena/jdbc/results/AbstractResultSetTests.java (original)
+++ jena/Experimental/jena-jdbc/jena-jdbc-core/src/test/java/org/apache/jena/jdbc/results/AbstractResultSetTests.java Mon Jun 10 18:18:35 2013
@@ -19,17 +19,29 @@
package org.apache.jena.jdbc.results;
import java.io.InputStream;
+import java.io.Reader;
import java.math.BigDecimal;
import java.sql.Array;
+import java.sql.Blob;
+import java.sql.Clob;
import java.sql.Date;
+import java.sql.NClob;
+import java.sql.Ref;
import java.sql.ResultSet;
+import java.sql.RowId;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
+import java.sql.SQLWarning;
+import java.sql.SQLXML;
+import java.sql.Time;
+import java.sql.Timestamp;
import java.util.Calendar;
import org.apache.jena.jdbc.JdbcCompatibility;
+import org.apache.jena.jdbc.connections.JenaConnection;
import org.apache.jena.jdbc.results.metadata.AskResultsMetadata;
import org.apache.jena.jdbc.results.metadata.TripleResultsMetadata;
+import org.apache.jena.jdbc.statements.JenaStatement;
import org.apache.log4j.BasicConfigurator;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
@@ -1901,4 +1913,1232 @@ public abstract class AbstractResultSetT
rset.close();
}
}
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_25() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateBlob(1, (Blob)null);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_26() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateBlob("s", (Blob)null);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_27() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateBlob(1, (InputStream)null);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_28() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateBlob("s", (InputStream)null);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_29() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateBlob(1, (InputStream)null, 0);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_30() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateBlob("s", (InputStream)null, 0);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_31() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateBoolean(1, true);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_32() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateBoolean("s", true);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_33() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateByte(1, (byte)123);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_34() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateByte("s", (byte)123);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_35() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateBytes(1, new byte[0]);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_36() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateBytes("s", new byte[0]);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_37() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateCharacterStream(1, (Reader)null);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_38() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateCharacterStream("s", (Reader)null);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_39() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateCharacterStream(1, (Reader)null, 0);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_40() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateCharacterStream("s", (Reader)null, 0);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_41() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateCharacterStream(1, (Reader)null, 0l);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_42() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateCharacterStream("s", (Reader)null, 0l);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_43() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateClob(1, (Clob)null);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_44() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateClob("s", (Clob)null);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_45() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateClob(1, (Reader)null);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_46() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateClob("s", (Reader)null);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_47() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateClob(1, (Reader)null, 0);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_48() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateClob("s", (Reader)null, 0);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_49() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateDate(1, (Date)null);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_50() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateDate("s", (Date)null);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_51() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateDouble(1, 123d);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_52() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateDouble("s", 123d);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_53() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateFloat(1, 123f);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_54() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateFloat("s", 123f);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_55() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateInt(1, 123);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_56() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateInt("s", 123);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_57() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateLong(1, 123l);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_58() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateLong("s", 123l);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_59() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateNCharacterStream(1, (Reader)null);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_60() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateNCharacterStream("s", (Reader)null);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_61() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateNCharacterStream(1, (Reader)null, 0);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_62() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateNCharacterStream("s", (Reader)null, 0);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_63() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateNCharacterStream(1, (Reader)null, 0l);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_64() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateNCharacterStream("s", (Reader)null, 0l);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_65() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateNClob(1, (NClob)null);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_66() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateNClob("s", (NClob)null);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_67() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateNClob(1, (Reader)null);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_68() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateNClob("s", (Reader)null);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_69() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateNClob(1, (Reader)null, 0);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_70() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateNClob("s", (Reader)null, 0);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_71() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateNull(1);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_72() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateNull("s");
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_73() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateObject(1, null);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_74() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateObject("s", null);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_75() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateObject(1, null, 0);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_76() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateObject("s", null, 0);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_77() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateRef(1, (Ref)null);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_78() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateRef("s", (Ref)null);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_79() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateRowId(1, (RowId)null);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_80() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateRowId("s", (RowId)null);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_81() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateSQLXML(1, (SQLXML)null);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_82() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateSQLXML("s", (SQLXML)null);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_83() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateShort(1, (short)123);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_84() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateShort("s", (short)123);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_85() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateString(1, "");
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_86() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateString("s", "");
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_87() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateTime(1, (Time)null);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_88() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateTime("s", (Time)null);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_89() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateTimestamp(1, (Timestamp)null);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_90() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateTimestamp("s", (Timestamp)null);
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Tests error cases around trying to update the result set which is not
+ * supported
+ *
+ * @throws SQLException
+ */
+ @Test(expected = SQLFeatureNotSupportedException.class)
+ public void results_bad_updates_91() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ try {
+ rset.updateRow();
+ } finally {
+ rset.close();
+ }
+ }
+
+ /**
+ * Check warnings usage
+ *
+ * @throws SQLException
+ */
+ @Test
+ public void results_warnings_01() throws SQLException {
+ ResultSet rset = this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ Assert.assertNull(rset.getWarnings());
+
+ rset.close();
+ }
+
+ /**
+ * Check warnings usage
+ *
+ * @throws SQLException
+ */
+ @Test
+ public void results_warnings_02() throws SQLException {
+ JenaResultSet rset = (JenaResultSet)this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ Assert.assertNull(rset.getWarnings());
+ rset.setWarning("Test");
+ Assert.assertNotNull(rset.getWarnings());
+ rset.clearWarnings();
+ Assert.assertNull(rset.getWarnings());
+
+ rset.close();
+ }
+
+ /**
+ * Check warnings usage
+ *
+ * @throws SQLException
+ */
+ @Test
+ public void results_warnings_03() throws SQLException {
+ JenaResultSet rset = (JenaResultSet) this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ Assert.assertNull(rset.getWarnings());
+ rset.setWarning("Test", new Exception());
+ Assert.assertNotNull(rset.getWarnings());
+ rset.clearWarnings();
+ Assert.assertNull(rset.getWarnings());
+
+ rset.close();
+ }
+
+ /**
+ * Check warnings usage
+ *
+ * @throws SQLException
+ */
+ @Test
+ public void results_warnings_04() throws SQLException {
+ JenaResultSet rset = (JenaResultSet) this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ Assert.assertNull(rset.getWarnings());
+ rset.setWarning(new SQLWarning());
+ Assert.assertNotNull(rset.getWarnings());
+ rset.clearWarnings();
+ Assert.assertNull(rset.getWarnings());
+
+ rset.close();
+ }
+
+ /**
+ * Check warnings usage
+ *
+ * @throws SQLException
+ */
+ @Test
+ public void results_warnings_05() throws SQLException {
+ JenaResultSet rset = (JenaResultSet) this.createResults(ds, "SELECT * WHERE { ?s ?p ?o }");
+
+ Assert.assertNull(rset.getWarnings());
+ rset.setWarning("A");
+ Assert.assertNotNull(rset.getWarnings());
+ rset.setWarning("B");
+ Assert.assertNotNull(rset.getWarnings());
+ Assert.assertNotNull(rset.getWarnings().getNextWarning());
+ rset.clearWarnings();
+ Assert.assertNull(rset.getWarnings());
+
+ rset.close();
+ }
}
Modified: jena/Experimental/jena-jdbc/jena-jdbc-core/src/test/java/org/apache/jena/jdbc/statements/AbstractJenaStatementTests.java
URL: http://svn.apache.org/viewvc/jena/Experimental/jena-jdbc/jena-jdbc-core/src/test/java/org/apache/jena/jdbc/statements/AbstractJenaStatementTests.java?rev=1491551&r1=1491550&r2=1491551&view=diff
==============================================================================
--- jena/Experimental/jena-jdbc/jena-jdbc-core/src/test/java/org/apache/jena/jdbc/statements/AbstractJenaStatementTests.java (original)
+++ jena/Experimental/jena-jdbc/jena-jdbc-core/src/test/java/org/apache/jena/jdbc/statements/AbstractJenaStatementTests.java Mon Jun 10 18:18:35 2013
@@ -3497,7 +3497,7 @@ public abstract class AbstractJenaStatem
}
@Test
- public void prepared_statement_stters_82() throws SQLException {
+ public void prepared_statement_setters_82() throws SQLException {
JenaConnection conn = this.getConnection();
JenaPreparedStatement stmt = (JenaPreparedStatement) conn.prepareStatement("SELECT * WHERE { ?s ?p ? }");
Modified: jena/Experimental/jena-jdbc/jena-jdbc-driver-tdb/src/test/java/org/apache/jena/jdbc/tdb/connections/TestTdbDiskConnection.java
URL: http://svn.apache.org/viewvc/jena/Experimental/jena-jdbc/jena-jdbc-driver-tdb/src/test/java/org/apache/jena/jdbc/tdb/connections/TestTdbDiskConnection.java?rev=1491551&r1=1491550&r2=1491551&view=diff
==============================================================================
--- jena/Experimental/jena-jdbc/jena-jdbc-driver-tdb/src/test/java/org/apache/jena/jdbc/tdb/connections/TestTdbDiskConnection.java (original)
+++ jena/Experimental/jena-jdbc/jena-jdbc-driver-tdb/src/test/java/org/apache/jena/jdbc/tdb/connections/TestTdbDiskConnection.java Mon Jun 10 18:18:35 2013
@@ -27,11 +27,14 @@ import org.apache.jena.jdbc.connections.
import org.apache.jena.jdbc.connections.JenaConnection;
import org.apache.jena.jdbc.tdb.connections.TDBConnection;
import org.apache.jena.jdbc.utils.TestUtils;
+import org.junit.After;
import org.junit.Rule;
import org.junit.rules.TemporaryFolder;
import com.hp.hpl.jena.query.Dataset;
+import com.hp.hpl.jena.tdb.StoreConnection;
import com.hp.hpl.jena.tdb.TDBFactory;
+import com.hp.hpl.jena.tdb.base.file.Location;
/**
* Tests for the {@link DatasetConnection} backed by a purely in-memory testing
@@ -46,6 +49,14 @@ public class TestTdbDiskConnection exten
*/
@Rule
public TemporaryFolder tempDir = new TemporaryFolder();
+
+ /**
+ * Cleans up resources used to avoid process memory leaks
+ */
+ @After
+ public void cleanupTest() {
+ StoreConnection.expel(new Location(tempDir.getRoot().getAbsolutePath()), true);
+ }
@Override
protected JenaConnection getConnection() throws SQLException {
Modified: jena/Experimental/jena-jdbc/jena-jdbc-driver-tdb/src/test/java/org/apache/jena/jdbc/tdb/connections/TestTdbMemConnection.java
URL: http://svn.apache.org/viewvc/jena/Experimental/jena-jdbc/jena-jdbc-driver-tdb/src/test/java/org/apache/jena/jdbc/tdb/connections/TestTdbMemConnection.java?rev=1491551&r1=1491550&r2=1491551&view=diff
==============================================================================
--- jena/Experimental/jena-jdbc/jena-jdbc-driver-tdb/src/test/java/org/apache/jena/jdbc/tdb/connections/TestTdbMemConnection.java (original)
+++ jena/Experimental/jena-jdbc/jena-jdbc-driver-tdb/src/test/java/org/apache/jena/jdbc/tdb/connections/TestTdbMemConnection.java Mon Jun 10 18:18:35 2013
@@ -27,9 +27,12 @@ import org.apache.jena.jdbc.connections.
import org.apache.jena.jdbc.connections.JenaConnection;
import org.apache.jena.jdbc.tdb.connections.TDBConnection;
import org.apache.jena.jdbc.utils.TestUtils;
+import org.junit.After;
import com.hp.hpl.jena.query.Dataset;
+import com.hp.hpl.jena.tdb.StoreConnection;
import com.hp.hpl.jena.tdb.TDBFactory;
+import com.hp.hpl.jena.tdb.base.file.Location;
/**
* Tests for the {@link DatasetConnection} backed by a purely in-memory testing
@@ -37,6 +40,14 @@ import com.hp.hpl.jena.tdb.TDBFactory;
*
*/
public class TestTdbMemConnection extends AbstractJenaConnectionTests {
+
+ /**
+ * Clean up test resources
+ */
+ @After
+ public void cleanupTest() {
+ StoreConnection.expel(Location.mem(), true);
+ }
@Override
protected JenaConnection getConnection() throws SQLException {
Modified: jena/Experimental/jena-jdbc/jena-jdbc-driver-tdb/src/test/java/org/apache/jena/jdbc/tdb/metadata/TestTdbConnectionMetadata.java
URL: http://svn.apache.org/viewvc/jena/Experimental/jena-jdbc/jena-jdbc-driver-tdb/src/test/java/org/apache/jena/jdbc/tdb/metadata/TestTdbConnectionMetadata.java?rev=1491551&r1=1491550&r2=1491551&view=diff
==============================================================================
--- jena/Experimental/jena-jdbc/jena-jdbc-driver-tdb/src/test/java/org/apache/jena/jdbc/tdb/metadata/TestTdbConnectionMetadata.java (original)
+++ jena/Experimental/jena-jdbc/jena-jdbc-driver-tdb/src/test/java/org/apache/jena/jdbc/tdb/metadata/TestTdbConnectionMetadata.java Mon Jun 10 18:18:35 2013
@@ -28,8 +28,11 @@ import org.apache.jena.jdbc.JdbcCompatib
import org.apache.jena.jdbc.connections.JenaConnection;
import org.apache.jena.jdbc.metadata.results.AbstractDatabaseMetadataTests;
import org.apache.jena.jdbc.tdb.connections.TDBConnection;
+import org.junit.After;
+import com.hp.hpl.jena.tdb.StoreConnection;
import com.hp.hpl.jena.tdb.TDBFactory;
+import com.hp.hpl.jena.tdb.base.file.Location;
/**
* Tests database metadata for TDB connections
@@ -37,6 +40,14 @@ import com.hp.hpl.jena.tdb.TDBFactory;
*
*/
public class TestTdbConnectionMetadata extends AbstractDatabaseMetadataTests {
+
+ /**
+ * Cleans up resources used by tests
+ */
+ @After
+ public void cleanupTest() {
+ StoreConnection.expel(Location.mem(), true);
+ }
@Override
protected JenaConnection getConnection() throws SQLException {
Modified: jena/Experimental/jena-jdbc/jena-jdbc-driver-tdb/src/test/java/org/apache/jena/jdbc/tdb/results/TestTdbDiskResultSets.java
URL: http://svn.apache.org/viewvc/jena/Experimental/jena-jdbc/jena-jdbc-driver-tdb/src/test/java/org/apache/jena/jdbc/tdb/results/TestTdbDiskResultSets.java?rev=1491551&r1=1491550&r2=1491551&view=diff
==============================================================================
--- jena/Experimental/jena-jdbc/jena-jdbc-driver-tdb/src/test/java/org/apache/jena/jdbc/tdb/results/TestTdbDiskResultSets.java (original)
+++ jena/Experimental/jena-jdbc/jena-jdbc-driver-tdb/src/test/java/org/apache/jena/jdbc/tdb/results/TestTdbDiskResultSets.java Mon Jun 10 18:18:35 2013
@@ -26,22 +26,25 @@ import org.junit.Rule;
import org.junit.rules.TemporaryFolder;
import com.hp.hpl.jena.query.Dataset;
+import com.hp.hpl.jena.tdb.StoreConnection;
import com.hp.hpl.jena.tdb.TDBFactory;
+import com.hp.hpl.jena.tdb.base.file.Location;
/**
* Tests for result sets using a disk backed TDB dataset
- *
+ *
*/
public class TestTdbDiskResultSets extends AbstractTdbResultSetTests {
/**
- * Temporary directory rule used to guarantee a unique temporary folder for each test method
+ * Temporary directory rule used to guarantee a unique temporary folder for
+ * each test method
*/
@Rule
public TemporaryFolder tempDir = new TemporaryFolder();
private Dataset currDataset;
-
+
/**
* Cleans up after the tests by ensuring that the TDB dataset is closed
*/
@@ -50,14 +53,15 @@ public class TestTdbDiskResultSets exten
if (currDataset != null) {
currDataset.close();
}
+ StoreConnection.expel(new Location(tempDir.getRoot().getAbsolutePath()), true);
}
-
+
@Override
protected Dataset prepareDataset(Dataset ds) throws SQLException {
if (this.currDataset != null) {
this.currDataset.close();
}
-
+
Dataset tdb = TDBFactory.createDataset(tempDir.getRoot().getAbsolutePath());
TestUtils.copyDataset(ds, tdb, true);
this.currDataset = tdb;
Modified: jena/Experimental/jena-jdbc/jena-jdbc-driver-tdb/src/test/java/org/apache/jena/jdbc/tdb/results/TestTdbMemResultSets.java
URL: http://svn.apache.org/viewvc/jena/Experimental/jena-jdbc/jena-jdbc-driver-tdb/src/test/java/org/apache/jena/jdbc/tdb/results/TestTdbMemResultSets.java?rev=1491551&r1=1491550&r2=1491551&view=diff
==============================================================================
--- jena/Experimental/jena-jdbc/jena-jdbc-driver-tdb/src/test/java/org/apache/jena/jdbc/tdb/results/TestTdbMemResultSets.java (original)
+++ jena/Experimental/jena-jdbc/jena-jdbc-driver-tdb/src/test/java/org/apache/jena/jdbc/tdb/results/TestTdbMemResultSets.java Mon Jun 10 18:18:35 2013
@@ -24,7 +24,9 @@ import org.apache.jena.jdbc.utils.TestUt
import org.junit.After;
import com.hp.hpl.jena.query.Dataset;
+import com.hp.hpl.jena.tdb.StoreConnection;
import com.hp.hpl.jena.tdb.TDBFactory;
+import com.hp.hpl.jena.tdb.base.file.Location;
/**
* Tests for result sets using a in-memory TDB dataset
@@ -42,6 +44,7 @@ public class TestTdbMemResultSets extend
if (currDataset != null) {
currDataset.close();
}
+ StoreConnection.expel(Location.mem(), true);
}
@Override