1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
|
/*
Derby - Class org.apache.derbyTesting.functionTests.tests.jdbc4.JDBC4FromJDBC3DataSourceTest
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to you under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package org.apache.derbyTesting.functionTests.tests.jdbc4;
import java.sql.Connection;
import javax.sql.ConnectionPoolDataSource;
import javax.sql.PooledConnection;
import javax.sql.StatementEvent;
import javax.sql.StatementEventListener;
import javax.sql.XADataSource;
import junit.framework.Test;
import org.apache.derbyTesting.junit.BaseJDBCTestCase;
import org.apache.derbyTesting.junit.BaseTestSuite;
import org.apache.derbyTesting.junit.J2EEDataSource;
import org.apache.derbyTesting.junit.JDBC;
import org.apache.derbyTesting.junit.TestConfiguration;
/**
* <p>
* This test ensures that when a JDBC 4 application instantiates a JDBC 3
* data source, that data source will return JDBC 4 connections even though
* the data source itself is not a JDBC 4 object.
* </p>
*
* <p>
* Note that after DERBY-5868 and DERBY-5880, all the data sources implement all JDBC 4.0 methods.
* </p>
*
* <p>
* Neither the client nor the embedded variants of the JDBC 3 data sources
* implement the full JDBC 4.1 interface.
* </p>
*/
public class JDBC4FromJDBC3DataSourceTest extends BaseJDBCTestCase {
/**
* Create a test with the given name.
* @param name name of the test.
*
*/
public JDBC4FromJDBC3DataSourceTest(String name)
{
super(name);
}
/**
* Return suite with all tests of the class.
*/
public static Test suite()
{
// Only run this test if we have a JDBC 4 JVM on full SE
if (JDBC.vmSupportsJDBC4() && JDBC.vmSupportsJNDI())
{
return TestConfiguration.forceJDBC3Suite(
JDBC4FromJDBC3DataSourceTest.class);
}
// Else return empty suite.
return new BaseTestSuite("JDBC 4 from JDBC 3 Data Sources");
}
/**
* Test that a JDBC 3 data source returns a JDBC 4 PooledConnection
* when running with a JDBC 4 JDK.
*/
public void testPooledConnection() throws Exception
{
ConnectionPoolDataSource ds = J2EEDataSource.getConnectionPoolDataSource();
checkJDBC4Interface(ds.getPooledConnection());
}
/**
* Test that a JDBC 3 data source returns a JDBC 4 XAConnection
* when running with a JDBC 4 JDK.
*/
public void testXAConnection() throws Exception
{
XADataSource ds = J2EEDataSource.getXADataSource();
checkJDBC4Interface(ds.getXAConnection());
}
/**
* Make sure that the received PooledConnection, which we assume came
* from a JDBC 3 data source, is nonetheless a JDBC 4 object.
*/
private void checkJDBC4Interface(PooledConnection pc)
throws Exception
{
// Create dummy event listener.
StatementEventListener listener =
new StatementEventListener()
{
public void statementClosed(StatementEvent event) {}
public void statementErrorOccurred(StatementEvent event) {}
};
/* Assert that metadata reports JDBC 4 for the connection, which
* it should even though the connection was created from a JDBC 3
* datasource.
*/
Connection conn = pc.getConnection();
assertEquals(4, conn.getMetaData().getJDBCMajorVersion());
conn.close();
conn = null;
/* The way we check to see if we actually have JDBC 4 objects is
* to call two methods that only exist in JDBC 4. These should
* succeed. Before DERBY-2488 they would fail with an Abstract
* MethodError.
*/
pc.addStatementEventListener(listener);
pc.removeStatementEventListener(listener);
pc.close();
}
}
|
