From ee37205bb3dc6cebd16ebddfd22a89890d90cc71 Mon Sep 17 00:00:00 2001 From: wenshao Date: Thu, 15 Sep 2011 22:52:54 +0000 Subject: [PATCH] =?UTF-8?q?=E5=AE=8C=E5=96=84mock=E5=92=8C=E6=B5=8B?= =?UTF-8?q?=E8=AF=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit git-svn-id: http://code.alibabatech.com/svn/druid/trunk@776 b9813039-fb51-4c41-a8b9-e21c2acb5095 --- .../druid/mock/MockCallableStatement.java | 118 +++++++-------- .../basic/PoolableCallableStatementTest.java | 139 +++++++++++++++++- .../basic/PoolablePreparedStatementTest.java | 94 +++++++----- 3 files changed, 247 insertions(+), 104 deletions(-) diff --git a/src/main/java/com/alibaba/druid/mock/MockCallableStatement.java b/src/main/java/com/alibaba/druid/mock/MockCallableStatement.java index aaa79e9bd0..8541914b41 100644 --- a/src/main/java/com/alibaba/druid/mock/MockCallableStatement.java +++ b/src/main/java/com/alibaba/druid/mock/MockCallableStatement.java @@ -308,68 +308,67 @@ public class MockCallableStatement extends MockPreparedStatement implements Call @Override public URL getURL(int parameterIndex) throws SQLException { - - return null; + return (URL) getObject(parameterIndex); } @Override - public void setURL(String parameterName, URL val) throws SQLException { - + public void setURL(String parameterName, URL x) throws SQLException { + setObject(parameterName, x); } @Override public void setNull(String parameterName, int sqlType) throws SQLException { - + setObject(parameterName, null); } @Override public void setBoolean(String parameterName, boolean x) throws SQLException { - + setObject(parameterName, x); } @Override public void setByte(String parameterName, byte x) throws SQLException { - + setObject(parameterName, x); } @Override public void setShort(String parameterName, short x) throws SQLException { - + setObject(parameterName, x); } @Override public void setInt(String parameterName, int x) throws SQLException { - + setObject(parameterName, x); } @Override public void setLong(String parameterName, long x) throws SQLException { - + setObject(parameterName, x); } @Override public void setFloat(String parameterName, float x) throws SQLException { - + setObject(parameterName, x); } @Override public void setDouble(String parameterName, double x) throws SQLException { - + setObject(parameterName, x); } @Override public void setBigDecimal(String parameterName, BigDecimal x) throws SQLException { - + setObject(parameterName, x); } @Override public void setString(String parameterName, String x) throws SQLException { - + setObject(parameterName, x); } @Override public void setBytes(String parameterName, byte[] x) throws SQLException { - + setObject(parameterName, x); } @Override @@ -379,62 +378,62 @@ public class MockCallableStatement extends MockPreparedStatement implements Call @Override public void setTime(String parameterName, Time x) throws SQLException { - + setObject(parameterName, x); } @Override public void setTimestamp(String parameterName, Timestamp x) throws SQLException { - + setObject(parameterName, x); } @Override public void setAsciiStream(String parameterName, InputStream x, int length) throws SQLException { - + setObject(parameterName, x); } @Override public void setBinaryStream(String parameterName, InputStream x, int length) throws SQLException { - + setObject(parameterName, x); } @Override public void setObject(String parameterName, Object x, int targetSqlType, int scale) throws SQLException { - + setObject(parameterName, x); } @Override public void setObject(String parameterName, Object x, int targetSqlType) throws SQLException { - + setObject(parameterName, x); } @Override public void setObject(String parameterName, Object x) throws SQLException { - + setObject(Integer.parseInt(parameterName), x); } @Override - public void setCharacterStream(String parameterName, Reader reader, int length) throws SQLException { - + public void setCharacterStream(String parameterName, Reader x, int length) throws SQLException { + setObject(parameterName, x); } @Override public void setDate(String parameterName, Date x, Calendar cal) throws SQLException { - + setObject(parameterName, x); } @Override public void setTime(String parameterName, Time x, Calendar cal) throws SQLException { - + setObject(parameterName, x); } @Override public void setTimestamp(String parameterName, Timestamp x, Calendar cal) throws SQLException { - + setObject(parameterName, x); } @Override public void setNull(String parameterName, int sqlType, String typeName) throws SQLException { - + setObject(parameterName, null); } @Override @@ -539,14 +538,12 @@ public class MockCallableStatement extends MockPreparedStatement implements Call @Override public NClob getNClob(int parameterIndex) throws SQLException { - - return null; + return (NClob) getObject(parameterIndex); } @Override public NClob getNClob(String parameterName) throws SQLException { - - return null; + return (NClob) getObject(parameterName); } @Override @@ -562,104 +559,97 @@ public class MockCallableStatement extends MockPreparedStatement implements Call @Override public SQLXML getSQLXML(String parameterName) throws SQLException { - - return null; + return (SQLXML) getObject(parameterName); } @Override public String getNString(int parameterIndex) throws SQLException { - - return null; + return (String) getObject(parameterIndex); } @Override public String getNString(String parameterName) throws SQLException { - - return null; + return (String) getObject(parameterName); } @Override public Reader getNCharacterStream(int parameterIndex) throws SQLException { - - return null; + return (Reader) getObject(parameterIndex); } @Override public Reader getNCharacterStream(String parameterName) throws SQLException { - - return null; + return (Reader) getObject(parameterName); } @Override public Reader getCharacterStream(int parameterIndex) throws SQLException { - - return null; + return (Reader) getObject(parameterIndex); } @Override public Reader getCharacterStream(String parameterName) throws SQLException { - - return null; + return (Reader) getObject(parameterName); } @Override public void setBlob(String parameterName, Blob x) throws SQLException { - + setObject(parameterName, x); } @Override public void setClob(String parameterName, Clob x) throws SQLException { - + setObject(parameterName, x); } @Override public void setAsciiStream(String parameterName, InputStream x, long length) throws SQLException { - + setObject(parameterName, x); } @Override public void setBinaryStream(String parameterName, InputStream x, long length) throws SQLException { - + setObject(parameterName, x); } @Override - public void setCharacterStream(String parameterName, Reader reader, long length) throws SQLException { - + public void setCharacterStream(String parameterName, Reader x, long length) throws SQLException { + setObject(parameterName, x); } @Override public void setAsciiStream(String parameterName, InputStream x) throws SQLException { - + setObject(parameterName, x); } @Override public void setBinaryStream(String parameterName, InputStream x) throws SQLException { - + setObject(parameterName, x); } @Override - public void setCharacterStream(String parameterName, Reader reader) throws SQLException { - + public void setCharacterStream(String parameterName, Reader x) throws SQLException { + setObject(parameterName, x); } @Override - public void setNCharacterStream(String parameterName, Reader value) throws SQLException { - + public void setNCharacterStream(String parameterName, Reader x) throws SQLException { + setObject(parameterName, x); } @Override - public void setClob(String parameterName, Reader reader) throws SQLException { - + public void setClob(String parameterName, Reader x) throws SQLException { + setObject(parameterName, x); } @Override - public void setBlob(String parameterName, InputStream inputStream) throws SQLException { - + public void setBlob(String parameterName, InputStream x) throws SQLException { + setObject(parameterName, x); } @Override - public void setNClob(String parameterName, Reader reader) throws SQLException { - + public void setNClob(String parameterName, Reader x) throws SQLException { + setObject(parameterName, x); } } diff --git a/src/test/java/com/alibaba/druid/bvt/pool/basic/PoolableCallableStatementTest.java b/src/test/java/com/alibaba/druid/bvt/pool/basic/PoolableCallableStatementTest.java index 49c8a5181b..52dcbeb31d 100644 --- a/src/test/java/com/alibaba/druid/bvt/pool/basic/PoolableCallableStatementTest.java +++ b/src/test/java/com/alibaba/druid/bvt/pool/basic/PoolableCallableStatementTest.java @@ -1,5 +1,6 @@ package com.alibaba.druid.bvt.pool.basic; +import java.io.Reader; import java.sql.SQLException; import java.sql.Types; @@ -28,10 +29,10 @@ public class PoolableCallableStatementTest extends TestCase { }; Assert.assertEquals(0, raw.getParameters().size()); - raw.registerOutParameter(1, Types.INTEGER); + stmt.registerOutParameter(1, Types.INTEGER); Assert.assertEquals(1, raw.getParameters().size()); - raw.registerOutParameter(2, Types.DECIMAL, 10); + stmt.registerOutParameter(2, Types.DECIMAL, 10); Assert.assertEquals(2, raw.getParameters().size()); } @@ -241,7 +242,7 @@ public class PoolableCallableStatementTest extends TestCase { } Assert.assertNotNull(error); } - + { SQLException error = null; try { @@ -403,7 +404,7 @@ public class PoolableCallableStatementTest extends TestCase { } Assert.assertNotNull(error); } - + { SQLException error = null; try { @@ -415,4 +416,134 @@ public class PoolableCallableStatementTest extends TestCase { } } + + public void test_getNClob() throws Exception { + + stmt.getNClob(1); + stmt.getNClob("1"); + + { + SQLException error = null; + try { + stmt.getNClob("0"); + } catch (SQLException ex) { + error = ex; + } + Assert.assertNotNull(error); + } + + { + SQLException error = null; + try { + stmt.getNClob("0"); + } catch (SQLException ex) { + error = ex; + } + Assert.assertNotNull(error); + } + } + + public void test_getNString() throws Exception { + + stmt.getNString(1); + stmt.getNString("1"); + + { + SQLException error = null; + try { + stmt.getNString("0"); + } catch (SQLException ex) { + error = ex; + } + Assert.assertNotNull(error); + } + + { + SQLException error = null; + try { + stmt.getNString("0"); + } catch (SQLException ex) { + error = ex; + } + Assert.assertNotNull(error); + } + } + + public void test_getNCharacterStream() throws Exception { + + stmt.getNCharacterStream(1); + stmt.getNCharacterStream("1"); + + { + SQLException error = null; + try { + stmt.getNCharacterStream("0"); + } catch (SQLException ex) { + error = ex; + } + Assert.assertNotNull(error); + } + + { + SQLException error = null; + try { + stmt.getNCharacterStream("0"); + } catch (SQLException ex) { + error = ex; + } + Assert.assertNotNull(error); + } + } + + public void test_getCharacterStream() throws Exception { + + stmt.getCharacterStream(1); + stmt.getCharacterStream("1"); + + { + SQLException error = null; + try { + stmt.getCharacterStream("0"); + } catch (SQLException ex) { + error = ex; + } + Assert.assertNotNull(error); + } + + { + SQLException error = null; + try { + stmt.getCharacterStream("0"); + } catch (SQLException ex) { + error = ex; + } + Assert.assertNotNull(error); + } + } + + public void test_updateCharacterStream_2() throws Exception { + + stmt.setCharacterStream(1, (Reader) null, 1L); + stmt.setCharacterStream("1", (Reader) null, 1L); + + { + SQLException error = null; + try { + stmt.setCharacterStream("0", (Reader) null, 1L); + } catch (SQLException ex) { + error = ex; + } + Assert.assertNotNull(error); + } + + { + SQLException error = null; + try { + stmt.setCharacterStream(0, (Reader) null, 1L); + } catch (SQLException ex) { + error = ex; + } + Assert.assertNotNull(error); + } + } } diff --git a/src/test/java/com/alibaba/druid/bvt/pool/basic/PoolablePreparedStatementTest.java b/src/test/java/com/alibaba/druid/bvt/pool/basic/PoolablePreparedStatementTest.java index 68dc7953d1..7d30bd40b5 100644 --- a/src/test/java/com/alibaba/druid/bvt/pool/basic/PoolablePreparedStatementTest.java +++ b/src/test/java/com/alibaba/druid/bvt/pool/basic/PoolablePreparedStatementTest.java @@ -1,6 +1,7 @@ package com.alibaba.druid.bvt.pool.basic; import java.io.InputStream; +import java.io.Reader; import java.math.BigDecimal; import java.sql.Date; import java.sql.SQLException; @@ -33,6 +34,11 @@ public class PoolablePreparedStatementTest extends TestCase { }; } + protected void tearDown() throws Exception { + stmt.clearParameters(); + Assert.assertEquals(0, raw.getParameters().size()); + } + public void test_basic() throws Exception { Assert.assertEquals(raw, stmt.getRawPreparedStatement()); Assert.assertEquals(raw, stmt.getRawStatement()); @@ -101,12 +107,12 @@ public class PoolablePreparedStatementTest extends TestCase { Assert.assertNotNull(error); } } - + public void test_setInt() throws Exception { stmt.setInt(1, Integer.MAX_VALUE); - + Assert.assertEquals(new Integer(Integer.MAX_VALUE), raw.getParameters().get(0)); - + { SQLException error = null; try { @@ -117,12 +123,12 @@ public class PoolablePreparedStatementTest extends TestCase { Assert.assertNotNull(error); } } - + public void test_setLong() throws Exception { stmt.setLong(1, Long.MAX_VALUE); - + Assert.assertEquals(new Long(Long.MAX_VALUE), raw.getParameters().get(0)); - + { SQLException error = null; try { @@ -133,12 +139,12 @@ public class PoolablePreparedStatementTest extends TestCase { Assert.assertNotNull(error); } } - + public void test_setFloat() throws Exception { stmt.setFloat(1, Float.MAX_VALUE); - + Assert.assertEquals(new Float(Float.MAX_VALUE), raw.getParameters().get(0)); - + { SQLException error = null; try { @@ -149,12 +155,12 @@ public class PoolablePreparedStatementTest extends TestCase { Assert.assertNotNull(error); } } - + public void test_setDouble() throws Exception { stmt.setDouble(1, Double.MAX_VALUE); - + Assert.assertEquals(new Double(Double.MAX_VALUE), raw.getParameters().get(0)); - + { SQLException error = null; try { @@ -165,12 +171,12 @@ public class PoolablePreparedStatementTest extends TestCase { Assert.assertNotNull(error); } } - + public void test_setBigDecimal() throws Exception { stmt.setBigDecimal(1, BigDecimal.TEN); - + Assert.assertEquals(BigDecimal.TEN, raw.getParameters().get(0)); - + { SQLException error = null; try { @@ -181,12 +187,12 @@ public class PoolablePreparedStatementTest extends TestCase { Assert.assertNotNull(error); } } - + public void test_setString() throws Exception { stmt.setString(1, "中国"); - + Assert.assertEquals("中国", raw.getParameters().get(0)); - + { SQLException error = null; try { @@ -197,13 +203,13 @@ public class PoolablePreparedStatementTest extends TestCase { Assert.assertNotNull(error); } } - + public void test_setBytes() throws Exception { byte[] bytes = "中国".getBytes(); stmt.setBytes(1, bytes); - + Assert.assertEquals(true, Arrays.equals(bytes, (byte[]) raw.getParameters().get(0))); - + { SQLException error = null; try { @@ -214,13 +220,13 @@ public class PoolablePreparedStatementTest extends TestCase { Assert.assertNotNull(error); } } - + public void test_setDate() throws Exception { Date value = new Date(System.currentTimeMillis()); stmt.setDate(1, value); - + Assert.assertEquals(value, raw.getParameters().get(0)); - + { SQLException error = null; try { @@ -231,13 +237,13 @@ public class PoolablePreparedStatementTest extends TestCase { Assert.assertNotNull(error); } } - + public void test_setTimestamp() throws Exception { Timestamp value = new Timestamp(System.currentTimeMillis()); stmt.setTimestamp(1, value); - + Assert.assertEquals(value, raw.getParameters().get(0)); - + { SQLException error = null; try { @@ -248,13 +254,13 @@ public class PoolablePreparedStatementTest extends TestCase { Assert.assertNotNull(error); } } - + public void test_setAsciiStream() throws Exception { InputStream value = null; stmt.setAsciiStream(1, value); - + Assert.assertEquals(value, raw.getParameters().get(0)); - + { SQLException error = null; try { @@ -265,14 +271,14 @@ public class PoolablePreparedStatementTest extends TestCase { Assert.assertNotNull(error); } } - + @SuppressWarnings("deprecation") public void test_setUnicodeStream() throws Exception { InputStream value = null; stmt.setUnicodeStream(1, value, 0); - + Assert.assertEquals(value, raw.getParameters().get(0)); - + { SQLException error = null; try { @@ -283,14 +289,14 @@ public class PoolablePreparedStatementTest extends TestCase { Assert.assertNotNull(error); } } - + @SuppressWarnings("deprecation") public void test_setBinaryStream() throws Exception { InputStream value = null; stmt.setBinaryStream(1, value, 0); - + Assert.assertEquals(value, raw.getParameters().get(0)); - + { SQLException error = null; try { @@ -301,4 +307,20 @@ public class PoolablePreparedStatementTest extends TestCase { Assert.assertNotNull(error); } } + + + public void test_updateCharacterStream_2() throws Exception { + + stmt.setCharacterStream(1, (Reader) null, 1L); + + { + SQLException error = null; + try { + stmt.setCharacterStream(0, (Reader) null, 1L); + } catch (SQLException ex) { + error = ex; + } + Assert.assertNotNull(error); + } + } }