← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/libpgjava/oneiric

« back to all changes in this revision

Viewing changes to src/interfaces/jdbc/org/postgresql/test/jdbc2/TimestampTest.java

  • Committer: Bazaar Package Importer
  • Author(s): Arnaud Vandyck
  • Date: 2005-04-21 14:25:11 UTC
  • mfrom: (1.2.1 upstream) (2.1.1 warty)
  • Revision ID: james.westby@ubuntu.com-20050421142511-wibh5vc31fkrorx7
Tags: 7.4.7-3
Built with sources...

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/interfaces/jdbc/org/postgresql/test/jdbc2/TimestampTest.java
1
1
package org.postgresql.test.jdbc2;
2
2
 
3
 
import org.postgresql.test.JDBC2Tests;
 
3
import org.postgresql.test.TestUtil;
4
4
import junit.framework.TestCase;
5
5
import java.sql.*;
6
6
 
7
7
/*
8
 
 * $Id: TimestampTest.java,v 1.6 2001/11/19 22:33:39 momjian Exp $
9
 
 *
10
 
 * This has been the most controversial pair of methods since 6.5 was released!
11
 
 *
12
 
 * From now on, any changes made to either getTimestamp or setTimestamp
13
 
 * MUST PASS this TestCase!!!
 
8
 * $Id: TimestampTest.java,v 1.12 2003/09/22 04:55:00 barry Exp $
 
9
 *
 
10
 * Test get/setTimestamp for both timestamp with time zone and
 
11
 * timestamp without time zone datatypes
14
12
 *
15
13
 */
16
14
public class TimestampTest extends TestCase
25
23
 
26
24
        protected void setUp() throws Exception
27
25
        {
28
 
                con = JDBC2Tests.openDB();
29
 
                Statement stmt = con.createStatement();
30
 
 
31
 
                JDBC2Tests.createTable(con, "testtimestamp", "ts timestamp");
 
26
                con = TestUtil.openDB();
 
27
                TestUtil.createTable(con, TSWTZ_TABLE, "ts timestamp with time zone");
 
28
                TestUtil.createTable(con, TSWOTZ_TABLE, "ts timestamp without time zone");
32
29
        }
33
30
 
34
31
        protected void tearDown() throws Exception
35
32
        {
36
 
                JDBC2Tests.dropTable(con, "testtimestamp");
37
 
                JDBC2Tests.closeDB(con);
38
 
        }
39
 
 
40
 
        /*
41
 
         * Tests the time methods in ResultSet
42
 
         */
43
 
        public void testGetTimestamp()
44
 
        {
45
 
                try
46
 
                {
47
 
                        Statement stmt = con.createStatement();
48
 
 
49
 
                        assertEquals(1, stmt.executeUpdate(JDBC2Tests.insertSQL("testtimestamp",
50
 
                                                                                           "'1950-02-07 15:00:00'")));
51
 
 
52
 
                        assertEquals(1, stmt.executeUpdate(JDBC2Tests.insertSQL("testtimestamp", "'" +
53
 
                                                                                           getTimestamp(1970, 6, 2, 8, 13, 0, 0).toString() +
54
 
                                                                                           "'")));
55
 
 
56
 
                        assertEquals(1, stmt.executeUpdate(JDBC2Tests.insertSQL("testtimestamp",
57
 
                                                                                           "'1970-06-02 08:13:00'")));
58
 
 
59
 
                        // Fall through helper
60
 
                        timestampTest();
61
 
 
62
 
                        assertEquals(3, stmt.executeUpdate("DELETE FROM testtimestamp"));
63
 
 
64
 
                        stmt.close();
65
 
                }
66
 
                catch (Exception ex)
67
 
                {
68
 
                        fail(ex.getMessage());
69
 
                }
70
 
        }
71
 
 
72
 
        /*
73
 
         * Tests the time methods in PreparedStatement
74
 
         */
75
 
        public void testSetTimestamp()
76
 
        {
77
 
                try
78
 
                {
79
 
                        Statement stmt = con.createStatement();
80
 
                        PreparedStatement pstmt = con.prepareStatement(JDBC2Tests.insertSQL("testtimestamp", "?"));
81
 
 
82
 
                        pstmt.setTimestamp(1, getTimestamp(1950, 2, 7, 15, 0, 0, 0));
83
 
                        assertEquals(1, pstmt.executeUpdate());
84
 
 
85
 
                        pstmt.setTimestamp(1, getTimestamp(1970, 6, 2, 8, 13, 0, 0));
86
 
                        assertEquals(1, pstmt.executeUpdate());
87
 
 
88
 
                        pstmt.setTimestamp(1, getTimestamp(1970, 6, 2, 8, 13, 0, 0));
89
 
                        assertEquals(1, pstmt.executeUpdate());
90
 
 
91
 
                        // Fall through helper
92
 
                        timestampTest();
93
 
 
94
 
                        assertEquals(3, stmt.executeUpdate("DELETE FROM testtimestamp"));
95
 
 
96
 
                        pstmt.close();
97
 
                        stmt.close();
98
 
                }
99
 
                catch (Exception ex)
100
 
                {
101
 
                        fail(ex.getMessage());
102
 
                }
103
 
        }
104
 
 
105
 
        /*
106
 
         * Helper for the TimeTests. It tests what should be in the db
107
 
         */
108
 
        private void timestampTest() throws SQLException
109
 
        {
110
 
                Statement stmt = con.createStatement();
111
 
                ResultSet rs;
112
 
                java.sql.Timestamp t;
113
 
 
114
 
                rs = stmt.executeQuery(JDBC2Tests.selectSQL("testtimestamp", "ts"));
115
 
                assertNotNull(rs);
116
 
 
117
 
                assertTrue(rs.next());
118
 
                t = rs.getTimestamp(1);
119
 
                assertNotNull(t);
120
 
                assertTrue(t.equals(getTimestamp(1950, 2, 7, 15, 0, 0, 0)));
121
 
 
122
 
                assertTrue(rs.next());
123
 
                t = rs.getTimestamp(1);
124
 
                assertNotNull(t);
125
 
                assertTrue(t.equals(getTimestamp(1970, 6, 2, 8, 13, 0, 0)));
126
 
 
127
 
                assertTrue(rs.next());
128
 
                t = rs.getTimestamp(1);
129
 
                assertNotNull(t);
130
 
                assertTrue(t.equals(getTimestamp(1970, 6, 2, 8, 13, 0, 0)));
131
 
 
132
 
                assertTrue(! rs.next()); // end of table. Fail if more entries exist.
133
 
 
134
 
                rs.close();
135
 
                stmt.close();
136
 
        }
137
 
 
138
 
        private java.sql.Timestamp getTimestamp(int y, int m, int d, int h, int mn, int se, int f)
139
 
        {
140
 
                return java.sql.Timestamp.valueOf(JDBC2Tests.fix(y, 4) + "-" +
141
 
                                                                                  JDBC2Tests.fix(m, 2) + "-" +
142
 
                                                                                  JDBC2Tests.fix(d, 2) + " " +
143
 
                                                                                  JDBC2Tests.fix(h, 2) + ":" +
144
 
                                                                                  JDBC2Tests.fix(mn, 2) + ":" +
145
 
                                                                                  JDBC2Tests.fix(se, 2) + "." +
146
 
                                                                                  JDBC2Tests.fix(f, 9));
147
 
        }
 
33
                TestUtil.dropTable(con, TSWTZ_TABLE);
 
34
                TestUtil.dropTable(con, TSWOTZ_TABLE);
 
35
                TestUtil.closeDB(con);
 
36
        }
 
37
 
 
38
        /*
 
39
         * Tests the timestamp methods in ResultSet on timestamp with time zone
 
40
                        * we insert a known string value (don't use setTimestamp) then see that 
 
41
                        * we get back the same value from getTimestamp
 
42
         */
 
43
        public void testGetTimestampWTZ()
 
44
        {
 
45
                try
 
46
                {
 
47
                        Statement stmt = con.createStatement();
 
48
 
 
49
                        //Insert the three timestamp values in raw pg format
 
50
                        assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + TS1WTZ_PGFORMAT + "'")));
 
51
                        assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + TS2WTZ_PGFORMAT + "'")));
 
52
                        assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + TS3WTZ_PGFORMAT + "'")));
 
53
                        assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + TS4WTZ_PGFORMAT + "'")));
 
54
                        assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + TS1WTZ_PGFORMAT + "'")));
 
55
                        assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + TS2WTZ_PGFORMAT + "'")));
 
56
                        assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + TS3WTZ_PGFORMAT + "'")));
 
57
                        assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + TS4WTZ_PGFORMAT + "'")));
 
58
                        assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + TS1WTZ_PGFORMAT + "'")));
 
59
                        assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + TS2WTZ_PGFORMAT + "'")));
 
60
                        assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + TS3WTZ_PGFORMAT + "'")));
 
61
                        assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + TS4WTZ_PGFORMAT + "'")));                                                                                              
 
62
                        assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + new java.sql.Timestamp(tmpDate1.getTime()) + "'")));
 
63
                        assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + new java.sql.Timestamp(tmpDate2.getTime()) + "'")));
 
64
                        assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + new java.sql.Timestamp(tmpDate3.getTime()) + "'")));
 
65
                        assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + new java.sql.Timestamp(tmpDate4.getTime()) + "'")));
 
66
                        assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + new java.sql.Timestamp(tmpTime1.getTime()) + "'")));
 
67
                        assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + new java.sql.Timestamp(tmpTime2.getTime()) + "'")));
 
68
                        assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + new java.sql.Timestamp(tmpTime3.getTime()) + "'")));
 
69
                        assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWTZ_TABLE, "'" + new java.sql.Timestamp(tmpTime4.getTime()) + "'")));
 
70
                        
 
71
 
 
72
                        // Fall through helper
 
73
                        timestampTestWTZ();
 
74
 
 
75
                        assertEquals(20, stmt.executeUpdate("DELETE FROM " + TSWTZ_TABLE));
 
76
 
 
77
                        stmt.close();
 
78
                }
 
79
                catch (Exception ex)
 
80
                {
 
81
                        fail(ex.getMessage());
 
82
                }
 
83
        }
 
84
 
 
85
        /*
 
86
         * Tests the timestamp methods in PreparedStatement on timestamp with time zone
 
87
                        * we insert a value using setTimestamp then see that
 
88
                        * we get back the same value from getTimestamp (which we know works as it was tested
 
89
                        * independently of setTimestamp
 
90
         */
 
91
        public void testSetTimestampWTZ()
 
92
        {
 
93
                try
 
94
                {
 
95
                        Statement stmt = con.createStatement();
 
96
                        PreparedStatement pstmt = con.prepareStatement(TestUtil.insertSQL(TSWTZ_TABLE, "?"));
 
97
 
 
98
                        pstmt.setTimestamp(1, TS1WTZ);
 
99
                        assertEquals(1, pstmt.executeUpdate());
 
100
 
 
101
                        pstmt.setTimestamp(1, TS2WTZ);
 
102
                        assertEquals(1, pstmt.executeUpdate());
 
103
 
 
104
                        pstmt.setTimestamp(1, TS3WTZ);
 
105
                        assertEquals(1, pstmt.executeUpdate());
 
106
 
 
107
                        pstmt.setTimestamp(1, TS4WTZ);
 
108
                        assertEquals(1, pstmt.executeUpdate());
 
109
                        
 
110
                        // With java.sql.Timestamp
 
111
                        pstmt.setObject(1,TS1WTZ, java.sql.Types.TIMESTAMP);
 
112
                        assertEquals(1, pstmt.executeUpdate());
 
113
                        pstmt.setObject(1,TS2WTZ, java.sql.Types.TIMESTAMP);
 
114
                        assertEquals(1, pstmt.executeUpdate());
 
115
                        pstmt.setObject(1,TS3WTZ, java.sql.Types.TIMESTAMP);
 
116
                        assertEquals(1, pstmt.executeUpdate());                 
 
117
                        pstmt.setObject(1,TS4WTZ, java.sql.Types.TIMESTAMP);
 
118
                        assertEquals(1, pstmt.executeUpdate());
 
119
                        
 
120
                        // With Strings
 
121
                        pstmt.setObject(1,TS1WTZ_PGFORMAT, java.sql.Types.TIMESTAMP);
 
122
                        assertEquals(1, pstmt.executeUpdate());
 
123
                        pstmt.setObject(1,TS2WTZ_PGFORMAT, java.sql.Types.TIMESTAMP);
 
124
                        assertEquals(1, pstmt.executeUpdate());
 
125
                        pstmt.setObject(1,TS3WTZ_PGFORMAT, java.sql.Types.TIMESTAMP);
 
126
                        assertEquals(1, pstmt.executeUpdate());                 
 
127
                        pstmt.setObject(1,TS4WTZ_PGFORMAT, java.sql.Types.TIMESTAMP);
 
128
                        assertEquals(1, pstmt.executeUpdate());
 
129
 
 
130
                        // With java.sql.Date
 
131
                        pstmt.setObject(1,tmpDate1, java.sql.Types.TIMESTAMP);
 
132
                        assertEquals(1, pstmt.executeUpdate());
 
133
                        pstmt.setObject(1,tmpDate2, java.sql.Types.TIMESTAMP);
 
134
                        assertEquals(1, pstmt.executeUpdate());
 
135
                        pstmt.setObject(1,tmpDate3, java.sql.Types.TIMESTAMP);
 
136
                        assertEquals(1, pstmt.executeUpdate());                 
 
137
                        pstmt.setObject(1,tmpDate4, java.sql.Types.TIMESTAMP);
 
138
                        assertEquals(1, pstmt.executeUpdate());
 
139
                
 
140
                        // With java.sql.Time   
 
141
                        pstmt.setObject(1,tmpTime1, java.sql.Types.TIMESTAMP);
 
142
                        assertEquals(1, pstmt.executeUpdate());
 
143
                        pstmt.setObject(1,tmpTime2, java.sql.Types.TIMESTAMP);
 
144
                        assertEquals(1, pstmt.executeUpdate());
 
145
                        pstmt.setObject(1,tmpTime3, java.sql.Types.TIMESTAMP);
 
146
                        assertEquals(1, pstmt.executeUpdate());                 
 
147
                        pstmt.setObject(1,tmpTime4, java.sql.Types.TIMESTAMP);
 
148
                        assertEquals(1, pstmt.executeUpdate());                                                                                                                 
 
149
                        
 
150
                        // Fall through helper
 
151
                        timestampTestWTZ();
 
152
 
 
153
                        assertEquals(20, stmt.executeUpdate("DELETE FROM " + TSWTZ_TABLE));
 
154
 
 
155
                        pstmt.close();
 
156
                        stmt.close();
 
157
                }
 
158
                catch (Exception ex)
 
159
                {
 
160
                        fail(ex.getMessage());
 
161
                }
 
162
        }
 
163
 
 
164
        /*
 
165
         * Tests the timestamp methods in ResultSet on timestamp without time zone
 
166
                        * we insert a known string value (don't use setTimestamp) then see that 
 
167
                        * we get back the same value from getTimestamp
 
168
         */
 
169
        public void testGetTimestampWOTZ()
 
170
        {
 
171
                try
 
172
                {
 
173
                        Statement stmt = con.createStatement();
 
174
 
 
175
                        //Insert the three timestamp values in raw pg format
 
176
                        assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + TS1WOTZ_PGFORMAT + "'")));
 
177
                        assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + TS2WOTZ_PGFORMAT + "'")));
 
178
                        assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + TS3WOTZ_PGFORMAT + "'")));
 
179
                        assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + TS4WOTZ_PGFORMAT + "'")));
 
180
                        assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + TS1WOTZ_PGFORMAT + "'")));
 
181
                        assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + TS2WOTZ_PGFORMAT + "'")));
 
182
                        assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + TS3WOTZ_PGFORMAT + "'")));
 
183
                        assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + TS4WOTZ_PGFORMAT + "'")));
 
184
                        assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + TS1WOTZ_PGFORMAT + "'")));
 
185
                        assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + TS2WOTZ_PGFORMAT + "'")));
 
186
                        assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + TS3WOTZ_PGFORMAT + "'")));
 
187
                        assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + TS4WOTZ_PGFORMAT + "'")));
 
188
                        assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + new java.sql.Timestamp(tmpDate1WOTZ.getTime()) + "'")));
 
189
                        assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + new java.sql.Timestamp(tmpDate2WOTZ.getTime()) + "'")));
 
190
                        assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + new java.sql.Timestamp(tmpDate3WOTZ.getTime()) + "'")));
 
191
                        assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + new java.sql.Timestamp(tmpDate4WOTZ.getTime()) + "'")));
 
192
                        assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + new java.sql.Timestamp(tmpTime1WOTZ.getTime()) + "'")));
 
193
                        assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + new java.sql.Timestamp(tmpTime2WOTZ.getTime()) + "'")));
 
194
                        assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + new java.sql.Timestamp(tmpTime3WOTZ.getTime()) + "'")));
 
195
                        assertEquals(1, stmt.executeUpdate(TestUtil.insertSQL(TSWOTZ_TABLE, "'" + new java.sql.Timestamp(tmpTime4WOTZ.getTime()) + "'")));                                                                                              
 
196
 
 
197
                        // Fall through helper
 
198
                        timestampTestWOTZ();
 
199
 
 
200
                        assertEquals(20, stmt.executeUpdate("DELETE FROM " + TSWOTZ_TABLE));
 
201
 
 
202
                        stmt.close();
 
203
                }
 
204
                catch (Exception ex)
 
205
                {
 
206
                        fail(ex.getMessage());
 
207
                }
 
208
        }
 
209
 
 
210
 
 
211
        /*
 
212
         * Tests the timestamp methods in PreparedStatement on timestamp without time zone
 
213
                        * we insert a value using setTimestamp then see that
 
214
                        * we get back the same value from getTimestamp (which we know works as it was tested
 
215
                        * independently of setTimestamp
 
216
         */
 
217
        public void testSetTimestampWOTZ()
 
218
        {
 
219
                try
 
220
                {
 
221
                        Statement stmt = con.createStatement();
 
222
                        PreparedStatement pstmt = con.prepareStatement(TestUtil.insertSQL(TSWOTZ_TABLE, "?"));
 
223
 
 
224
                        pstmt.setTimestamp(1, TS1WOTZ);
 
225
                        assertEquals(1, pstmt.executeUpdate());
 
226
 
 
227
                        pstmt.setTimestamp(1, TS2WOTZ);
 
228
                        assertEquals(1, pstmt.executeUpdate());
 
229
 
 
230
                        pstmt.setTimestamp(1, TS3WOTZ);
 
231
                        assertEquals(1, pstmt.executeUpdate());
 
232
 
 
233
                        pstmt.setTimestamp(1, TS4WOTZ);
 
234
                        assertEquals(1, pstmt.executeUpdate());
 
235
 
 
236
 
 
237
                        // With java.sql.Timestamp
 
238
                        pstmt.setObject(1,TS1WOTZ, java.sql.Types.TIMESTAMP);
 
239
                        assertEquals(1, pstmt.executeUpdate());
 
240
                        pstmt.setObject(1,TS2WOTZ, java.sql.Types.TIMESTAMP);
 
241
                        assertEquals(1, pstmt.executeUpdate());
 
242
                        pstmt.setObject(1,TS3WOTZ, java.sql.Types.TIMESTAMP);
 
243
                        assertEquals(1, pstmt.executeUpdate());                 
 
244
                        pstmt.setObject(1,TS4WOTZ, java.sql.Types.TIMESTAMP);
 
245
                        assertEquals(1, pstmt.executeUpdate());
 
246
                        
 
247
                        // With Strings
 
248
                        pstmt.setObject(1,TS1WOTZ_PGFORMAT, java.sql.Types.TIMESTAMP);
 
249
                        assertEquals(1, pstmt.executeUpdate());
 
250
                        pstmt.setObject(1,TS2WOTZ_PGFORMAT, java.sql.Types.TIMESTAMP);
 
251
                        assertEquals(1, pstmt.executeUpdate());
 
252
                        pstmt.setObject(1,TS3WOTZ_PGFORMAT, java.sql.Types.TIMESTAMP);
 
253
                        assertEquals(1, pstmt.executeUpdate());                 
 
254
                        pstmt.setObject(1,TS4WOTZ_PGFORMAT, java.sql.Types.TIMESTAMP);
 
255
                        assertEquals(1, pstmt.executeUpdate());
 
256
 
 
257
                        // With java.sql.Date
 
258
                        pstmt.setObject(1,tmpDate1WOTZ, java.sql.Types.TIMESTAMP);
 
259
                        assertEquals(1, pstmt.executeUpdate());
 
260
                        pstmt.setObject(1,tmpDate2WOTZ, java.sql.Types.TIMESTAMP);
 
261
                        assertEquals(1, pstmt.executeUpdate());
 
262
                        pstmt.setObject(1,tmpDate3WOTZ, java.sql.Types.TIMESTAMP);
 
263
                        assertEquals(1, pstmt.executeUpdate());                 
 
264
                        pstmt.setObject(1,tmpDate4WOTZ, java.sql.Types.TIMESTAMP);
 
265
                        assertEquals(1, pstmt.executeUpdate());
 
266
                
 
267
                        // With java.sql.Time   
 
268
                        pstmt.setObject(1,tmpTime1WOTZ, java.sql.Types.TIMESTAMP);
 
269
                        assertEquals(1, pstmt.executeUpdate());
 
270
                        pstmt.setObject(1,tmpTime2WOTZ, java.sql.Types.TIMESTAMP);
 
271
                        assertEquals(1, pstmt.executeUpdate());
 
272
                        pstmt.setObject(1,tmpTime3WOTZ, java.sql.Types.TIMESTAMP);
 
273
                        assertEquals(1, pstmt.executeUpdate());                 
 
274
                        pstmt.setObject(1,tmpTime4WOTZ, java.sql.Types.TIMESTAMP);
 
275
                        assertEquals(1, pstmt.executeUpdate());                                                                                                                 
 
276
 
 
277
                        // Fall through helper
 
278
                        timestampTestWOTZ();
 
279
 
 
280
                        assertEquals(20, stmt.executeUpdate("DELETE FROM " + TSWOTZ_TABLE));
 
281
 
 
282
                        pstmt.close();
 
283
                        stmt.close();
 
284
                }
 
285
                catch (Exception ex)
 
286
                {
 
287
                        fail(ex.getMessage());
 
288
                }
 
289
        }
 
290
 
 
291
        /*
 
292
         * Helper for the TimestampTests. It tests what should be in the db
 
293
         */
 
294
        private void timestampTestWTZ() throws SQLException
 
295
        {
 
296
                Statement stmt = con.createStatement();
 
297
                ResultSet rs;
 
298
                java.sql.Timestamp t;
 
299
 
 
300
                rs = stmt.executeQuery("select ts from " + TSWTZ_TABLE); //removed the order by ts
 
301
                assertNotNull(rs);
 
302
 
 
303
                for (int i=0; i<3; i++)
 
304
                {
 
305
                        assertTrue(rs.next());
 
306
                        t = rs.getTimestamp(1);
 
307
                        assertNotNull(t);
 
308
                        assertTrue(t.equals(TS1WTZ));
 
309
        
 
310
                        assertTrue(rs.next());
 
311
                        t = rs.getTimestamp(1);
 
312
                        assertNotNull(t);
 
313
                        assertTrue(t.equals(TS2WTZ));
 
314
        
 
315
                        assertTrue(rs.next());
 
316
                        t = rs.getTimestamp(1);
 
317
                        assertNotNull(t);
 
318
                        assertTrue(t.equals(TS3WTZ));
 
319
        
 
320
                        assertTrue(rs.next());
 
321
                        t = rs.getTimestamp(1);
 
322
                        assertNotNull(t);
 
323
                        assertTrue(t.equals(TS4WTZ));
 
324
                }
 
325
                
 
326
                // Testing for Date
 
327
                assertTrue(rs.next());
 
328
                t = rs.getTimestamp(1);
 
329
                assertNotNull(t);
 
330
                assertEquals(t.getTime(), tmpDate1.getTime());
 
331
 
 
332
                assertTrue(rs.next());
 
333
                t = rs.getTimestamp(1);
 
334
                assertNotNull(t);
 
335
                assertEquals(t.getTime(), tmpDate2.getTime());
 
336
 
 
337
                assertTrue(rs.next());
 
338
                t = rs.getTimestamp(1);
 
339
                assertNotNull(t);
 
340
                assertEquals(t.getTime(), tmpDate3.getTime());
 
341
 
 
342
                assertTrue(rs.next());
 
343
                t = rs.getTimestamp(1);
 
344
                assertNotNull(t);
 
345
                assertEquals(t.getTime(), tmpDate4.getTime());
 
346
                
 
347
                // Testing for Time
 
348
                assertTrue(rs.next());
 
349
                t = rs.getTimestamp(1);
 
350
                assertNotNull(t);
 
351
                assertEquals(t.getTime(), tmpTime1.getTime());
 
352
 
 
353
                assertTrue(rs.next());
 
354
                t = rs.getTimestamp(1);
 
355
                assertNotNull(t);
 
356
                assertEquals(t.getTime(), tmpTime2.getTime());
 
357
 
 
358
                assertTrue(rs.next());
 
359
                t = rs.getTimestamp(1);
 
360
                assertNotNull(t);
 
361
                assertEquals(t.getTime(), tmpTime3.getTime());
 
362
 
 
363
                assertTrue(rs.next());
 
364
                t = rs.getTimestamp(1);
 
365
                assertNotNull(t);
 
366
                assertEquals(t.getTime(), tmpTime4.getTime());          
 
367
 
 
368
                assertTrue(! rs.next()); // end of table. Fail if more entries exist.
 
369
 
 
370
                rs.close();
 
371
                stmt.close();
 
372
        }
 
373
 
 
374
        /*
 
375
         * Helper for the TimestampTests. It tests what should be in the db
 
376
         */
 
377
        private void timestampTestWOTZ() throws SQLException
 
378
        {
 
379
                Statement stmt = con.createStatement();
 
380
                ResultSet rs;
 
381
                java.sql.Timestamp t;
 
382
 
 
383
                rs = stmt.executeQuery("select ts from " + TSWOTZ_TABLE); //removed the order by ts
 
384
                assertNotNull(rs);
 
385
 
 
386
                for (int i=0; i<3; i++)
 
387
                {
 
388
                        assertTrue(rs.next());
 
389
                        t = rs.getTimestamp(1);
 
390
                        assertNotNull(t);
 
391
                        assertTrue(t.equals(TS1WOTZ));
 
392
        
 
393
                        assertTrue(rs.next());
 
394
                        t = rs.getTimestamp(1);
 
395
                        assertNotNull(t);
 
396
                        assertTrue(t.equals(TS2WOTZ));
 
397
        
 
398
                        assertTrue(rs.next());
 
399
                        t = rs.getTimestamp(1);
 
400
                        assertNotNull(t);
 
401
                        assertTrue(t.equals(TS3WOTZ));
 
402
        
 
403
                        assertTrue(rs.next());
 
404
                        t = rs.getTimestamp(1);
 
405
                        assertNotNull(t);
 
406
                        assertTrue(t.equals(TS4WOTZ));
 
407
                }
 
408
                
 
409
                // Testing for Date
 
410
                assertTrue(rs.next());
 
411
                t = rs.getTimestamp(1);
 
412
                assertNotNull(t);
 
413
                assertEquals(t.getTime(), tmpDate1WOTZ.getTime());
 
414
 
 
415
                assertTrue(rs.next());
 
416
                t = rs.getTimestamp(1);
 
417
                assertNotNull(t);
 
418
                assertEquals(t.getTime(), tmpDate2WOTZ.getTime());
 
419
 
 
420
                assertTrue(rs.next());
 
421
                t = rs.getTimestamp(1);
 
422
                assertNotNull(t);
 
423
                assertEquals(t.getTime(), tmpDate3WOTZ.getTime());
 
424
 
 
425
                assertTrue(rs.next());
 
426
                t = rs.getTimestamp(1);
 
427
                assertNotNull(t);
 
428
                assertEquals(t.getTime(), tmpDate4WOTZ.getTime());
 
429
                
 
430
                // Testing for Time
 
431
                assertTrue(rs.next());
 
432
                t = rs.getTimestamp(1);
 
433
                assertNotNull(t);
 
434
                assertEquals(t.getTime(), tmpTime1WOTZ.getTime());
 
435
 
 
436
                assertTrue(rs.next());
 
437
                t = rs.getTimestamp(1);
 
438
                assertNotNull(t);
 
439
                assertEquals(t.getTime(), tmpTime2WOTZ.getTime());
 
440
 
 
441
                assertTrue(rs.next());
 
442
                t = rs.getTimestamp(1);
 
443
                assertNotNull(t);
 
444
                assertEquals(t.getTime(), tmpTime3WOTZ.getTime());
 
445
 
 
446
                assertTrue(rs.next());
 
447
                t = rs.getTimestamp(1);
 
448
                assertNotNull(t);
 
449
                assertEquals(t.getTime(), tmpTime4WOTZ.getTime());              
 
450
                
 
451
                assertTrue(! rs.next()); // end of table. Fail if more entries exist.
 
452
 
 
453
                rs.close();
 
454
                stmt.close();
 
455
        }
 
456
 
 
457
        private static java.sql.Timestamp getTimestamp(int y, int m, int d, int h, int mn, int se, int f, String tz)
 
458
        {
 
459
                java.sql.Timestamp l_return = null;
 
460
                java.text.DateFormat l_df;
 
461
                try
 
462
                {
 
463
                        String l_ts;
 
464
                        l_ts = TestUtil.fix(y, 4) + "-" +
 
465
                                   TestUtil.fix(m, 2) + "-" +
 
466
                                   TestUtil.fix(d, 2) + " " +
 
467
                                   TestUtil.fix(h, 2) + ":" +
 
468
                                   TestUtil.fix(mn, 2) + ":" +
 
469
                                   TestUtil.fix(se, 2) + " ";
 
470
 
 
471
                        if (tz == null)
 
472
                        {
 
473
                                l_df = new java.text.SimpleDateFormat("y-M-d H:m:s");
 
474
                        }
 
475
                        else
 
476
                        {
 
477
                                l_ts = l_ts + tz;
 
478
                                l_df = new java.text.SimpleDateFormat("y-M-d H:m:s z");
 
479
                        }
 
480
                        java.util.Date l_date = l_df.parse(l_ts);
 
481
                        l_return = new java.sql.Timestamp(l_date.getTime());
 
482
                        l_return.setNanos(f);
 
483
                }
 
484
                catch (Exception ex)
 
485
                {
 
486
                        fail(ex.getMessage());
 
487
                }
 
488
                return l_return;
 
489
        }
 
490
 
 
491
        private static final java.sql.Timestamp TS1WTZ = getTimestamp(1950, 2, 7, 15, 0, 0, 100000000, "PST");
 
492
        private static final String TS1WTZ_PGFORMAT = "1950-02-07 15:00:00.1-08";
 
493
 
 
494
        private static final java.sql.Timestamp TS2WTZ = getTimestamp(2000, 2, 7, 15, 0, 0, 120000000, "GMT");
 
495
        private static final String TS2WTZ_PGFORMAT = "2000-02-07 15:00:00.12+00";
 
496
 
 
497
        private static final java.sql.Timestamp TS3WTZ = getTimestamp(2000, 7, 7, 15, 0, 0, 123000000, "GMT");
 
498
        private static final String TS3WTZ_PGFORMAT = "2000-07-07 15:00:00.123+00";
 
499
 
 
500
        private static final java.sql.Timestamp TS4WTZ = getTimestamp(2000, 7, 7, 15, 0, 0, 123456000, "GMT");
 
501
        private static final String TS4WTZ_PGFORMAT = "2000-07-07 15:00:00.123456+00";
 
502
 
 
503
 
 
504
        private static final java.sql.Timestamp TS1WOTZ = getTimestamp(1950, 2, 7, 15, 0, 0, 100000000, null);
 
505
        private static final String TS1WOTZ_PGFORMAT = "1950-02-07 15:00:00.1";
 
506
 
 
507
        private static final java.sql.Timestamp TS2WOTZ = getTimestamp(2000, 2, 7, 15, 0, 0, 120000000, null);
 
508
        private static final String TS2WOTZ_PGFORMAT = "2000-02-07 15:00:00.12";
 
509
 
 
510
        private static final java.sql.Timestamp TS3WOTZ = getTimestamp(2000, 7, 7, 15, 0, 0, 123000000, null);
 
511
        private static final String TS3WOTZ_PGFORMAT = "2000-07-07 15:00:00.123";
 
512
 
 
513
        private static final java.sql.Timestamp TS4WOTZ = getTimestamp(2000, 7, 7, 15, 0, 0, 123456000, null);
 
514
        private static final String TS4WOTZ_PGFORMAT = "2000-07-07 15:00:00.123456";
 
515
 
 
516
        private static final String TSWTZ_TABLE = "testtimestampwtz";
 
517
        private static final String TSWOTZ_TABLE = "testtimestampwotz";
 
518
        
 
519
        private static final java.sql.Date tmpDate1 = new java.sql.Date(TS1WTZ.getTime());
 
520
        private static final java.sql.Time tmpTime1 = new java.sql.Time(TS1WTZ.getTime());
 
521
        private static final java.sql.Date tmpDate2 = new java.sql.Date(TS2WTZ.getTime());
 
522
        private static final java.sql.Time tmpTime2 = new java.sql.Time(TS2WTZ.getTime());
 
523
        private static final java.sql.Date tmpDate3 = new java.sql.Date(TS3WTZ.getTime());
 
524
        private static final java.sql.Time tmpTime3 = new java.sql.Time(TS3WTZ.getTime());
 
525
        private static final java.sql.Date tmpDate4 = new java.sql.Date(TS4WTZ.getTime());
 
526
        private static final java.sql.Time tmpTime4 = new java.sql.Time(TS4WTZ.getTime());      
 
527
        
 
528
        private static final java.sql.Date tmpDate1WOTZ = new java.sql.Date(TS1WOTZ.getTime());
 
529
        private static final java.sql.Time tmpTime1WOTZ = new java.sql.Time(TS1WOTZ.getTime());
 
530
        private static final java.sql.Date tmpDate2WOTZ = new java.sql.Date(TS2WOTZ.getTime());
 
531
        private static final java.sql.Time tmpTime2WOTZ = new java.sql.Time(TS2WOTZ.getTime());
 
532
        private static final java.sql.Date tmpDate3WOTZ = new java.sql.Date(TS3WOTZ.getTime());
 
533
        private static final java.sql.Time tmpTime3WOTZ = new java.sql.Time(TS3WOTZ.getTime());
 
534
        private static final java.sql.Date tmpDate4WOTZ = new java.sql.Date(TS4WOTZ.getTime());
 
535
        private static final java.sql.Time tmpTime4WOTZ = new java.sql.Time(TS4WOTZ.getTime()); 
 
536
 
 
537
 
148
538
}