Clover Coverage Report - Commons BeanUtils 1.8.3-kuali-SNAPSHOT
Coverage timestamp: Thu Jun 9 2011 11:19:33 MST
Overview   Package   File
    FRAMES   NO FRAMES     
../../../../img/srcFileCovDistChart3.png 76% of files have more coverage
199   950   172   1.37
54   578   0.86   145
145     1.19  
1    
 
  TestResultSet       Line # 53 199 0% 172 291 26.9% 0.26884422
 
  (6)
 
1    /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements. See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License. You may obtain a copy of the License at
8    *
9    * http://www.apache.org/licenses/LICENSE-2.0
10    *
11    * Unless required by applicable law or agreed to in writing, software
12    * distributed under the License is distributed on an "AS IS" BASIS,
13    * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14    * See the License for the specific language governing permissions and
15    * limitations under the License.
16    */
17   
18   
19    package org.apache.commons.beanutils;
20   
21   
22    import java.io.InputStream;
23    import java.io.Reader;
24    import java.lang.reflect.InvocationHandler;
25    import java.lang.reflect.Method;
26    import java.lang.reflect.Proxy;
27    import java.math.BigDecimal;
28    import java.net.URL;
29    import java.sql.Array;
30    import java.sql.Blob;
31    import java.sql.Clob;
32    import java.sql.Date;
33    import java.sql.Ref;
34    import java.sql.ResultSet;
35    import java.sql.ResultSetMetaData;
36    import java.sql.SQLException;
37    import java.sql.SQLWarning;
38    import java.sql.Statement;
39    import java.sql.Time;
40    import java.sql.Timestamp;
41    import java.util.Calendar;
42    import java.util.Map;
43   
44   
45    /**
46    * <p>Mock object that implements enough of <code>java.sql.ResultSet</code>
47    * to exercise the {@link ResultSetDynaClass} functionality.</p>
48    *
49    * @author Craig R. McClanahan
50    * @version $Revision: 745080 $ $Date: 2009-02-17 09:05:02 -0500 (Tue, 17 Feb 2009) $
51    */
52   
 
53    public class TestResultSet implements InvocationHandler {
54   
55   
56    // ----------------------------------------------------- Instance Variables
57   
58   
59    /**
60    * Current row number (0 means "before the first one").
61    */
62    protected int row = 0;
63   
64   
65    /**
66    * The constant (per run) value used to initialize date/time/timestamp.
67    */
68    protected long timestamp = System.currentTimeMillis();
69   
70    /**
71    * Meta data for the result set.
72    */
73    protected ResultSetMetaData resultSetMetaData;
74   
75    /**
76    * Factory method for creating {@link ResultSet} proxies.
77    *
78    * @return A result set proxy
79    */
 
80  19 toggle public static ResultSet createProxy() {
81  19 return TestResultSet.createProxy(new TestResultSet());
82    }
83   
84    /**
85    * Factory method for creating {@link ResultSet} proxies.
86    *
87    * @param invocationHandler Invocation Handler
88    * @return A result set proxy
89    */
 
90  20 toggle public static ResultSet createProxy(InvocationHandler invocationHandler) {
91  20 ClassLoader classLoader = ResultSet.class.getClassLoader();
92  20 Class[] interfaces = new Class[] { ResultSet.class };
93  20 return (ResultSet)Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);
94    }
95   
96    /**
97    * Create a proxy ResultSet.
98    */
 
99  19 toggle public TestResultSet() {
100  19 this(TestResultSetMetaData.createProxy());
101    }
102   
103    /**
104    * Create a proxy ResultSet with the specified meta data.
105    *
106    * @param resultSetMetaData The result set meta data
107    */
 
108  20 toggle public TestResultSet(ResultSetMetaData resultSetMetaData) {
109  20 this.resultSetMetaData = resultSetMetaData;
110    }
111   
112    /**
113    * Handles method invocation on the ResultSet proxy.
114    *
115    * @param proxy The proxy ResultSet object
116    * @param method the method being invoked
117    * @param args The method arguments
118    * @return The result of invoking the method.
119    * @throws Throwable if an error occurs.
120    */
 
121  866 toggle public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
122  866 String methodName = method.getName();
123  866 if ("close".equals(methodName)) {
124  0 return null;
125  866 } if ("getMetaData".equals(methodName)) {
126  20 return getMetaData();
127  846 } if ("getObject".equals(methodName)) {
128  590 return getObject(columnName(args[0]));
129  256 } if ("getDate".equals(methodName)) {
130  58 return getDate(columnName(args[0]));
131  198 } if ("getTime".equals(methodName)) {
132  58 return getTime(columnName(args[0]));
133  140 } if ("getTimestamp".equals(methodName)) {
134  58 return getTimestamp(columnName(args[0]));
135  82 } if ("next".equals(methodName)) {
136  82 return (next() ? Boolean.TRUE : Boolean.FALSE);
137  0 } if ("updateObject".equals(methodName)) {
138  0 updateObject((String)args[0], args[1]);
139  0 return null;
140    }
141   
142  0 throw new UnsupportedOperationException(methodName + " not implemented");
143    }
144   
 
145  764 toggle private String columnName(Object arg) throws SQLException {
146  764 if (arg instanceof Integer) {
147  0 return resultSetMetaData.getColumnName(((Integer)arg).intValue());
148    } else {
149  764 return (String)arg;
150    }
151    }
152   
153    // ---------------------------------------------------- Implemented Methods
154   
155   
 
156  0 toggle public void close() throws SQLException {
157    // No action required
158    }
159   
160   
 
161  20 toggle public ResultSetMetaData getMetaData() throws SQLException {
162  20 return resultSetMetaData;
163    }
164   
165   
 
166  589 toggle public Object getObject(String columnName) throws SQLException {
167  589 if (row > 5) {
168  0 throw new SQLException("No current row");
169    }
170  589 if ("bigDecimalProperty".equals(columnName)) {
171  60 return (new BigDecimal(123.45));
172  529 } else if ("booleanProperty".equals(columnName)) {
173  58 if ((row % 2) == 0) {
174  23 return (Boolean.TRUE);
175    } else {
176  35 return (Boolean.FALSE);
177    }
178  471 } else if ("byteProperty".equals(columnName)) {
179  58 return (new Byte((byte) row));
180  413 } else if ("dateProperty".equals(columnName)) {
181  1 return (new Date(timestamp));
182  412 } else if ("doubleProperty".equals(columnName)) {
183  58 return (new Double(321.0));
184  354 } else if ("floatProperty".equals(columnName)) {
185  58 return (new Float((float) 123.0));
186  296 } else if ("intProperty".equals(columnName)) {
187  60 return (new Integer(100 + row));
188  236 } else if ("longProperty".equals(columnName)) {
189  58 return (new Long(200 + row));
190  178 } else if ("nullProperty".equals(columnName)) {
191  60 return (null);
192  118 } else if ("shortProperty".equals(columnName)) {
193  58 return (new Short((short) (300 + row)));
194  60 } else if ("stringProperty".equals(columnName)) {
195  60 return ("This is a string");
196  0 } else if ("timeProperty".equals(columnName)) {
197  0 return (new Time(timestamp));
198  0 } else if ("timestampProperty".equals(columnName)) {
199  0 return (new Timestamp(timestamp));
200    } else {
201  0 throw new SQLException("Unknown column name " + columnName);
202    }
203    }
204   
 
205  58 toggle public Date getDate(String columnName) throws SQLException {
206  58 return (new Date(timestamp));
207    }
208   
 
209  58 toggle public Time getTime(String columnName) throws SQLException {
210  58 return (new Time(timestamp));
211    }
212   
 
213  58 toggle public Timestamp getTimestamp(String columnName) throws SQLException {
214  58 return (new Timestamp(timestamp));
215    }
216   
 
217  82 toggle public boolean next() throws SQLException {
218  82 if (row++ < 5) {
219  70 return (true);
220    } else {
221  12 return (false);
222    }
223    }
224   
225   
 
226  0 toggle public void updateObject(String columnName, Object x)
227    throws SQLException {
228  0 if (row > 5) {
229  0 throw new SQLException("No current row");
230    }
231    // FIXME - updateObject()
232    }
233   
234   
235    // -------------------------------------------------- Unimplemented Methods
236   
237   
 
238  0 toggle public boolean absolute(int row) throws SQLException {
239  0 throw new UnsupportedOperationException();
240    }
241   
242   
 
243  0 toggle public void afterLast() throws SQLException {
244  0 throw new UnsupportedOperationException();
245    }
246   
247   
 
248  0 toggle public void beforeFirst() throws SQLException {
249  0 throw new UnsupportedOperationException();
250    }
251   
252   
 
253  0 toggle public void cancelRowUpdates() throws SQLException {
254  0 throw new UnsupportedOperationException();
255    }
256   
257   
 
258  0 toggle public void clearWarnings() throws SQLException {
259  0 throw new UnsupportedOperationException();
260    }
261   
262   
 
263  0 toggle public void deleteRow() throws SQLException {
264  0 throw new UnsupportedOperationException();
265    }
266   
267   
 
268  0 toggle public int findColumn(String columnName) throws SQLException {
269  0 throw new UnsupportedOperationException();
270    }
271   
272   
 
273  0 toggle public boolean first() throws SQLException {
274  0 throw new UnsupportedOperationException();
275    }
276   
277   
 
278  0 toggle public Array getArray(int columnIndex) throws SQLException {
279  0 throw new UnsupportedOperationException();
280    }
281   
282   
 
283  0 toggle public Array getArray(String columnName) throws SQLException {
284  0 throw new UnsupportedOperationException();
285    }
286   
287   
 
288  0 toggle public InputStream getAsciiStream(int columnIndex) throws SQLException {
289  0 throw new UnsupportedOperationException();
290    }
291   
292   
 
293  0 toggle public InputStream getAsciiStream(String columnName) throws SQLException {
294  0 throw new UnsupportedOperationException();
295    }
296   
297   
 
298  0 toggle public BigDecimal getBigDecimal(int columnIndex) throws SQLException {
299  0 throw new UnsupportedOperationException();
300    }
301   
302    /** @deprecated */
 
303  0 toggle public BigDecimal getBigDecimal(int columnIndex, int scale)
304    throws SQLException {
305  0 throw new UnsupportedOperationException();
306    }
307   
308   
 
309  0 toggle public BigDecimal getBigDecimal(String columnName) throws SQLException {
310  0 throw new UnsupportedOperationException();
311    }
312   
313   
314    /** @deprecated */
 
315  0 toggle public BigDecimal getBigDecimal(String columnName, int scale)
316    throws SQLException {
317  0 throw new UnsupportedOperationException();
318    }
319   
320   
 
321  0 toggle public InputStream getBinaryStream(int columnIndex) throws SQLException {
322  0 throw new UnsupportedOperationException();
323    }
324   
325   
 
326  0 toggle public InputStream getBinaryStream(String columnName) throws SQLException {
327  0 throw new UnsupportedOperationException();
328    }
329   
330   
 
331  0 toggle public Blob getBlob(int columnIndex) throws SQLException {
332  0 throw new UnsupportedOperationException();
333    }
334   
335   
 
336  0 toggle public Blob getBlob(String columnName) throws SQLException {
337  0 throw new UnsupportedOperationException();
338    }
339   
340   
 
341  0 toggle public boolean getBoolean(int columnIndex) throws SQLException {
342  0 throw new UnsupportedOperationException();
343    }
344   
345   
 
346  0 toggle public boolean getBoolean(String columnName) throws SQLException {
347  0 throw new UnsupportedOperationException();
348    }
349   
350   
 
351  0 toggle public byte getByte(int columnIndex) throws SQLException {
352  0 throw new UnsupportedOperationException();
353    }
354   
355   
 
356  0 toggle public byte getByte(String columnName) throws SQLException {
357  0 throw new UnsupportedOperationException();
358    }
359   
360   
 
361  0 toggle public byte[] getBytes(int columnIndex) throws SQLException {
362  0 throw new UnsupportedOperationException();
363    }
364   
365   
 
366  0 toggle public byte[] getBytes(String columnName) throws SQLException {
367  0 throw new UnsupportedOperationException();
368    }
369   
370   
 
371  0 toggle public Reader getCharacterStream(int columnIndex)
372    throws SQLException {
373  0 throw new UnsupportedOperationException();
374    }
375   
376   
 
377  0 toggle public Reader getCharacterStream(String columnName) throws SQLException {
378  0 throw new UnsupportedOperationException();
379    }
380   
381   
 
382  0 toggle public Clob getClob(int columnIndex) throws SQLException {
383  0 throw new UnsupportedOperationException();
384    }
385   
386   
 
387  0 toggle public Clob getClob(String columnName) throws SQLException {
388  0 throw new UnsupportedOperationException();
389    }
390   
391   
 
392  0 toggle public int getConcurrency() throws SQLException {
393  0 throw new UnsupportedOperationException();
394    }
395   
396   
 
397  0 toggle public String getCursorName() throws SQLException {
398  0 throw new UnsupportedOperationException();
399    }
400   
401   
 
402  0 toggle public Date getDate(int columnIndex) throws SQLException {
403  0 throw new UnsupportedOperationException();
404    }
405   
406   
 
407  0 toggle public Date getDate(int columnIndex, Calendar cal) throws SQLException {
408  0 throw new UnsupportedOperationException();
409    }
410   
411   
412   
413   
 
414  0 toggle public Date getDate(String columnName, Calendar cal) throws SQLException {
415  0 throw new UnsupportedOperationException();
416    }
417   
418   
 
419  0 toggle public double getDouble(int columnIndex) throws SQLException {
420  0 throw new UnsupportedOperationException();
421    }
422   
423   
 
424  0 toggle public double getDouble(String columnName) throws SQLException {
425  0 throw new UnsupportedOperationException();
426    }
427   
428   
 
429  0 toggle public int getFetchDirection() throws SQLException {
430  0 throw new UnsupportedOperationException();
431    }
432   
433   
 
434  0 toggle public int getFetchSize() throws SQLException {
435  0 throw new UnsupportedOperationException();
436    }
437   
438   
 
439  0 toggle public float getFloat(int columnIndex) throws SQLException {
440  0 throw new UnsupportedOperationException();
441    }
442   
443   
 
444  0 toggle public float getFloat(String columnName) throws SQLException {
445  0 throw new UnsupportedOperationException();
446    }
447   
448   
 
449  0 toggle public int getInt(int columnIndex) throws SQLException {
450  0 throw new UnsupportedOperationException();
451    }
452   
453   
 
454  0 toggle public int getInt(String columnName) throws SQLException {
455  0 throw new UnsupportedOperationException();
456    }
457   
458   
 
459  0 toggle public long getLong(int columnIndex) throws SQLException {
460  0 throw new UnsupportedOperationException();
461    }
462   
463   
 
464  0 toggle public long getLong(String columnName) throws SQLException {
465  0 throw new UnsupportedOperationException();
466    }
467   
468   
 
469  0 toggle public Object getObject(int columnIndex) throws SQLException {
470  0 throw new UnsupportedOperationException();
471    }
472   
473   
 
474  0 toggle public Object getObject(int columnIndex, Map map) throws SQLException {
475  0 throw new UnsupportedOperationException();
476    }
477   
478   
 
479  0 toggle public Object getObject(String columnName, Map map) throws SQLException {
480  0 throw new UnsupportedOperationException();
481    }
482   
483   
 
484  0 toggle public Ref getRef(int columnIndex) throws SQLException {
485  0 throw new UnsupportedOperationException();
486    }
487   
488   
 
489  0 toggle public Ref getRef(String columnName) throws SQLException {
490  0 throw new UnsupportedOperationException();
491    }
492   
493   
 
494  0 toggle public int getRow() throws SQLException {
495  0 throw new UnsupportedOperationException();
496    }
497   
498   
 
499  0 toggle public short getShort(int columnIndex) throws SQLException {
500  0 throw new UnsupportedOperationException();
501    }
502   
503   
 
504  0 toggle public short getShort(String columnName) throws SQLException {
505  0 throw new UnsupportedOperationException();
506    }
507   
508   
 
509  0 toggle public Statement getStatement() throws SQLException {
510  0 throw new UnsupportedOperationException();
511    }
512   
513   
 
514  0 toggle public String getString(int columnIndex) throws SQLException {
515  0 throw new UnsupportedOperationException();
516    }
517   
518   
 
519  0 toggle public String getString(String columnName) throws SQLException {
520  0 throw new UnsupportedOperationException();
521    }
522   
523   
 
524  0 toggle public Time getTime(int columnIndex) throws SQLException {
525  0 throw new UnsupportedOperationException();
526    }
527   
528   
 
529  0 toggle public Time getTime(int columnIndex, Calendar cal) throws SQLException {
530  0 throw new UnsupportedOperationException();
531    }
532   
533   
534   
 
535  0 toggle public Time getTime(String columnName, Calendar cal) throws SQLException {
536  0 throw new UnsupportedOperationException();
537    }
538   
539   
 
540  0 toggle public Timestamp getTimestamp(int columnIndex) throws SQLException {
541  0 throw new UnsupportedOperationException();
542    }
543   
544   
 
545  0 toggle public Timestamp getTimestamp(int columnIndex, Calendar cal)
546    throws SQLException {
547  0 throw new UnsupportedOperationException();
548    }
549   
550   
551   
 
552  0 toggle public Timestamp getTimestamp(String columnName, Calendar cal)
553    throws SQLException {
554  0 throw new UnsupportedOperationException();
555    }
556   
557   
 
558  0 toggle public int getType() throws SQLException {
559  0 throw new UnsupportedOperationException();
560    }
561   
562   
563    /** @deprecated */
 
564  0 toggle public InputStream getUnicodeStream(int columnIndex) throws SQLException {
565  0 throw new UnsupportedOperationException();
566    }
567   
568   
569    /** @deprecated */
 
570  0 toggle public InputStream getUnicodeStream(String columnName) throws SQLException {
571  0 throw new UnsupportedOperationException();
572    }
573   
574   
 
575  0 toggle public URL getURL(int columnIndex) throws SQLException {
576  0 throw new UnsupportedOperationException();
577    }
578   
579   
 
580  0 toggle public URL getURL(String columnName) throws SQLException {
581  0 throw new UnsupportedOperationException();
582    }
583   
584   
 
585  0 toggle public SQLWarning getWarnings() throws SQLException {
586  0 throw new UnsupportedOperationException();
587    }
588   
589   
 
590  0 toggle public void insertRow() throws SQLException {
591  0 throw new UnsupportedOperationException();
592    }
593   
594   
 
595  0 toggle public boolean isAfterLast() throws SQLException {
596  0 throw new UnsupportedOperationException();
597    }
598   
599   
 
600  0 toggle public boolean isBeforeFirst() throws SQLException {
601  0 throw new UnsupportedOperationException();
602    }
603   
604   
 
605  0 toggle public boolean isFirst() throws SQLException {
606  0 throw new UnsupportedOperationException();
607    }
608   
609   
 
610  0 toggle public boolean isLast() throws SQLException {
611  0 throw new UnsupportedOperationException();
612    }
613   
614   
 
615  0 toggle public boolean last() throws SQLException {
616  0 throw new UnsupportedOperationException();
617    }
618   
619   
 
620  0 toggle public void moveToCurrentRow() throws SQLException {
621  0 throw new UnsupportedOperationException();
622    }
623   
624   
 
625  0 toggle public void moveToInsertRow() throws SQLException {
626  0 throw new UnsupportedOperationException();
627    }
628   
629   
 
630  0 toggle public boolean previous() throws SQLException {
631  0 throw new UnsupportedOperationException();
632    }
633   
634   
 
635  0 toggle public void refreshRow() throws SQLException {
636  0 throw new UnsupportedOperationException();
637    }
638   
639   
 
640  0 toggle public boolean relative(int rows) throws SQLException {
641  0 throw new UnsupportedOperationException();
642    }
643   
644   
 
645  0 toggle public boolean rowDeleted() throws SQLException {
646  0 throw new UnsupportedOperationException();
647    }
648   
649   
 
650  0 toggle public boolean rowInserted() throws SQLException {
651  0 throw new UnsupportedOperationException();
652    }
653   
654   
 
655  0 toggle public boolean rowUpdated() throws SQLException {
656  0 throw new UnsupportedOperationException();
657    }
658   
659   
 
660  0 toggle public void setFetchDirection(int direction) throws SQLException {
661  0 throw new UnsupportedOperationException();
662    }
663   
664   
 
665  0 toggle public void setFetchSize(int size) throws SQLException {
666  0 throw new UnsupportedOperationException();
667    }
668   
669   
 
670  0 toggle public void updateArray(int columnPosition, Array x)
671    throws SQLException {
672  0 throw new UnsupportedOperationException();
673    }
674   
675   
 
676  0 toggle public void updateArray(String columnName, Array x)
677    throws SQLException {
678  0 throw new UnsupportedOperationException();
679    }
680   
681   
 
682  0 toggle public void updateAsciiStream(int columnPosition, InputStream x, int len)
683    throws SQLException {
684  0 throw new UnsupportedOperationException();
685    }
686   
687   
 
688  0 toggle public void updateAsciiStream(String columnName, InputStream x, int len)
689    throws SQLException {
690  0 throw new UnsupportedOperationException();
691    }
692   
693   
 
694  0 toggle public void updateBigDecimal(int columnPosition, BigDecimal x)
695    throws SQLException {
696  0 throw new UnsupportedOperationException();
697    }
698   
699   
 
700  0 toggle public void updateBigDecimal(String columnName, BigDecimal x)
701    throws SQLException {
702  0 throw new UnsupportedOperationException();
703    }
704   
705   
 
706  0 toggle public void updateBinaryStream(int columnPosition, InputStream x, int len)
707    throws SQLException {
708  0 throw new UnsupportedOperationException();
709    }
710   
711   
 
712  0 toggle public void updateBinaryStream(String columnName, InputStream x, int len)
713    throws SQLException {
714  0 throw new UnsupportedOperationException();
715    }
716   
717   
 
718  0 toggle public void updateBlob(int columnPosition, Blob x)
719    throws SQLException {
720  0 throw new UnsupportedOperationException();
721    }
722   
723   
 
724  0 toggle public void updateBlob(String columnName, Blob x)
725    throws SQLException {
726  0 throw new UnsupportedOperationException();
727    }
728   
729   
 
730  0 toggle public void updateBoolean(int columnPosition, boolean x)
731    throws SQLException {
732  0 throw new UnsupportedOperationException();
733    }
734   
735   
 
736  0 toggle public void updateBoolean(String columnName, boolean x)
737    throws SQLException {
738  0 throw new UnsupportedOperationException();
739    }
740   
741   
 
742  0 toggle public void updateByte(int columnPosition, byte x)
743    throws SQLException {
744  0 throw new UnsupportedOperationException();
745    }
746   
747   
 
748  0 toggle public void updateByte(String columnName, byte x)
749    throws SQLException {
750  0 throw new UnsupportedOperationException();
751    }
752   
753   
 
754  0 toggle public void updateBytes(int columnPosition, byte x[])
755    throws SQLException {
756  0 throw new UnsupportedOperationException();
757    }
758   
759   
 
760  0 toggle public void updateBytes(String columnName, byte x[])
761    throws SQLException {
762  0 throw new UnsupportedOperationException();
763    }
764   
765   
 
766  0 toggle public void updateCharacterStream(int columnPosition, Reader x, int len)
767    throws SQLException {
768  0 throw new UnsupportedOperationException();
769    }
770   
771   
 
772  0 toggle public void updateCharacterStream(String columnName, Reader x, int len)
773    throws SQLException {
774  0 throw new UnsupportedOperationException();
775    }
776   
777   
 
778  0 toggle public void updateClob(int columnPosition, Clob x)
779    throws SQLException {
780  0 throw new UnsupportedOperationException();
781    }
782   
783   
 
784  0 toggle public void updateClob(String columnName, Clob x)
785    throws SQLException {
786  0 throw new UnsupportedOperationException();
787    }
788   
789   
 
790  0 toggle public void updateDate(int columnPosition, Date x)
791    throws SQLException {
792  0 throw new UnsupportedOperationException();
793    }
794   
795   
 
796  0 toggle public void updateDate(String columnName, Date x)
797    throws SQLException {
798  0 throw new UnsupportedOperationException();
799    }
800   
801   
 
802  0 toggle public void updateDouble(int columnPosition, double x)
803    throws SQLException {
804  0 throw new UnsupportedOperationException();
805    }
806   
807   
 
808  0 toggle public void updateDouble(String columnName, double x)
809    throws SQLException {
810  0 throw new UnsupportedOperationException();
811    }
812   
813   
 
814  0 toggle public void updateFloat(int columnPosition, float x)
815    throws SQLException {
816  0 throw new UnsupportedOperationException();
817    }
818   
819   
 
820  0 toggle public void updateFloat(String columnName, float x)
821    throws SQLException {
822  0 throw new UnsupportedOperationException();
823    }
824   
825   
 
826  0 toggle public void updateInt(int columnPosition, int x)
827    throws SQLException {
828  0 throw new UnsupportedOperationException();
829    }
830   
831   
 
832  0 toggle public void updateInt(String columnName, int x)
833    throws SQLException {
834  0 throw new UnsupportedOperationException();
835    }
836   
837   
 
838  0 toggle public void updateLong(int columnPosition, long x)
839    throws SQLException {
840  0 throw new UnsupportedOperationException();
841    }
842   
843   
 
844  0 toggle public void updateLong(String columnName, long x)
845    throws SQLException {
846  0 throw new UnsupportedOperationException();
847    }
848   
849   
 
850  0 toggle public void updateNull(int columnPosition)
851    throws SQLException {
852  0 throw new UnsupportedOperationException();
853    }
854   
855   
 
856  0 toggle public void updateNull(String columnName)
857    throws SQLException {
858  0 throw new UnsupportedOperationException();
859    }
860   
861   
 
862  0 toggle public void updateObject(int columnPosition, Object x)
863    throws SQLException {
864  0 throw new UnsupportedOperationException();
865    }
866   
867   
 
868  0 toggle public void updateObject(int columnPosition, Object x, int scale)
869    throws SQLException {
870  0 throw new UnsupportedOperationException();
871    }
872   
873   
 
874  0 toggle public void updateObject(String columnName, Object x, int scale)
875    throws SQLException {
876  0 throw new UnsupportedOperationException();
877    }
878   
879   
 
880  0 toggle public void updateRef(int columnPosition, Ref x)
881    throws SQLException {
882  0 throw new UnsupportedOperationException();
883    }
884   
885   
 
886  0 toggle public void updateRef(String columnName, Ref x)
887    throws SQLException {
888  0 throw new UnsupportedOperationException();
889    }
890   
891   
 
892  0 toggle public void updateRow() throws SQLException {
893  0 throw new UnsupportedOperationException();
894    }
895   
896   
 
897  0 toggle public void updateShort(int columnPosition, short x)
898    throws SQLException {
899  0 throw new UnsupportedOperationException();
900    }
901   
902   
 
903  0 toggle public void updateShort(String columnName, short x)
904    throws SQLException {
905  0 throw new UnsupportedOperationException();
906    }
907   
908   
 
909  0 toggle public void updateString(int columnPosition, String x)
910    throws SQLException {
911  0 throw new UnsupportedOperationException();
912    }
913   
914   
 
915  0 toggle public void updateString(String columnName, String x)
916    throws SQLException {
917  0 throw new UnsupportedOperationException();
918    }
919   
920   
 
921  0 toggle public void updateTime(int columnPosition, Time x)
922    throws SQLException {
923  0 throw new UnsupportedOperationException();
924    }
925   
926   
 
927  0 toggle public void updateTime(String columnName, Time x)
928    throws SQLException {
929  0 throw new UnsupportedOperationException();
930    }
931   
932   
 
933  0 toggle public void updateTimestamp(int columnPosition, Timestamp x)
934    throws SQLException {
935  0 throw new UnsupportedOperationException();
936    }
937   
938   
 
939  0 toggle public void updateTimestamp(String columnName, Timestamp x)
940    throws SQLException {
941  0 throw new UnsupportedOperationException();
942    }
943   
944   
 
945  0 toggle public boolean wasNull() throws SQLException {
946  0 throw new UnsupportedOperationException();
947    }
948   
949   
950    }
 
CloverReport generated by Clover Code Coverage v3.0.2
Thu Jun 9 2011 11:23:06 MST.		   Clover: Open Source License registered to University of Arizona.