/*
 *
 * Derby - Class UpdateXXXTest
 *
 * 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.jdbcapi;

import java.math.BigDecimal;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import junit.framework.Test;
import org.apache.derbyTesting.junit.BaseJDBCTestCase;
import org.apache.derbyTesting.junit.BaseTestSuite;
import org.apache.derbyTesting.junit.JDBC;
import org.apache.derbyTesting.junit.TestConfiguration;


/**
 * Tests updateXXX() methods on updatable resultsets.
 * This is done by creating a table which has n columns with
 * different SQL types. Then there is one testcase for each
 * updateXXX method, which calls updateXXX on all columns.
 */
final public class UpdateXXXTest extends BaseJDBCTestCase
{
    /**
     * Constructor
     * @param name name of testcase. Should be the name of test method.
     */
    public UpdateXXXTest(final String name) {
        super(name);
    }
    
    /**
     * Run in both embedded and client.
     */
    public static Test suite() {
        
        BaseTestSuite suite = baseSuite("UpdateXXXTest");
        
        suite.addTest(
                TestConfiguration.clientServerDecorator(
                        baseSuite("UpdateXXXTest:client")));
                      
        return suite;
    }
    
    /**
     * Base suite of tests that will run in both embedded and client.
     * @param name Name for the suite.
     */
    private static BaseTestSuite baseSuite(String name) {
        BaseTestSuite suite = new BaseTestSuite(name);
          
        suite.addTestSuite(UpdateXXXTest.class);
        
        // requires java.math.BigDecimal
        if (JDBC.vmSupportsJDBC3())
            suite.addTest(new UpdateXXXTest("jdbc2testUpdateBigDecimal"));
                      
        return suite;
    }

    /**
     * The setup creates a Connection to the database, and also
     * creates a table with one row. Then it creates an updatable
     * ResultSet which is positioned on the row.
     * @exception Exception any exception will cause test to fail with error.
     */
    public void setUp()
        throws Exception
    {
        Connection con = getConnection();
        try {
            
            con.setAutoCommit(false);
            
            Statement stmt = con.createStatement();
            String createTableString = "CREATE TABLE " + TABLE_NAME + " (" +
                "F01 SMALLINT," + 
                "F02 INTEGER," +
                "F03 BIGINT," + 
                "F04 REAL," +
                "F05 FLOAT," +
                "F06 DOUBLE," +
                "F07 DECIMAL," +
                "F08 NUMERIC," +
                "F09 CHAR(100)," +
                "F10 VARCHAR(256) )";
            println(createTableString);
            stmt.executeUpdate(createTableString);
            PreparedStatement ps = con.prepareStatement
                ("insert into " + TABLE_NAME + " values(?,?,?,?,?,?,?,?,?,?)");
            
            ps.setShort(1, (short) 1);
            ps.setInt(2, 1);
            ps.setLong(3, 1L);
            ps.setFloat(4, 1.0f);
            ps.setDouble(5, 1.0);
            ps.setDouble(6, 1.0);
            
            // Use setString instead of setBigDecimal to
            // allow most of the test cases to run under J2ME
            ps.setString(7, "1");
            ps.setString(8, "1");
            
            ps.setString(9, "1");
            ps.setString(10, "1");
            ps.executeUpdate();
            
            ps.close();
            stmt.close();
        } catch (SQLException e) {
            con.rollback();
            throw e;
        }
    }
        
    /**
     * Tests calling updateString on all columns of the row.
     * @exception SQLException database access error. Causes test to 
     *                         fail with an error.
     */
    public void testUpdateString() 
        throws SQLException
    {
        Statement s = createStatement(ResultSet.TYPE_FORWARD_ONLY, 
                ResultSet.CONCUR_UPDATABLE);
        ResultSet rs = s.executeQuery(SELECT_STMT);
        rs.next();

        for (int i = 1; i <= COLUMNS; i++) {
            rs.updateString(i, "2");
            assertEquals("Expected rs.getDouble(" + i + 
                         ") to match updated value", 2, (int) rs.getDouble(i));
        }
        rs.updateRow();
        rs.close();
        checkColumnsAreUpdated();
        
        s.close();
    }

    /**
     * Tests calling updateInt on all columns of the row.
     * @exception SQLException database access error. Causes test to 
     *                         fail with an error.
     */
    public void testUpdateInt() 
        throws SQLException
    {
        Statement s = createStatement(ResultSet.TYPE_FORWARD_ONLY, 
                ResultSet.CONCUR_UPDATABLE);
        ResultSet rs = s.executeQuery(SELECT_STMT);
        rs.next();

        for (int i = 1; i <= COLUMNS; i++) {
            rs.updateInt(i, 2);
            assertEquals("Expected rs.getInt(" + i + 
                         ") to match updated value", 2, rs.getInt(i));
        }
        rs.updateRow();
        rs.close();
        checkColumnsAreUpdated();
        
        s.close();
    }

    /**
     * Tests calling updateLong on all columns of the row.
     * @exception SQLException database access error. Causes test to 
     *                         fail with an error.
     */
    public void testUpdateLong() 
        throws SQLException
    {
        Statement s = createStatement(ResultSet.TYPE_FORWARD_ONLY, 
                ResultSet.CONCUR_UPDATABLE);
        ResultSet rs = s.executeQuery(SELECT_STMT);
        rs.next();

        for (int i = 1; i <= COLUMNS; i++) {
            rs.updateLong(i, 2L);
            assertEquals("Expected rs.getLong(" + i + 
                         ") to match updated value", 2L, rs.getLong(i));
        }
        rs.updateRow();
        rs.close();
        checkColumnsAreUpdated();
        
        s.close();
    }

    /**
     * Tests calling updateShort on all columns of the row.
     * @exception SQLException database access error. Causes test to 
     *                         fail with an error.
     */
    public void testUpdateShort() 
        throws SQLException
    {
        Statement s = createStatement(ResultSet.TYPE_FORWARD_ONLY, 
                ResultSet.CONCUR_UPDATABLE);
        ResultSet rs = s.executeQuery(SELECT_STMT);
        rs.next();

        for (int i = 1; i <= COLUMNS; i++) {
            rs.updateShort(i, (short) 2);
            assertEquals("Expected rs.getShort(" + i + 
                         ") to match updated value", 2, (int) rs.getShort(i));
        }
        rs.updateRow();
        rs.close();
        checkColumnsAreUpdated();
        
        s.close();
    }
    
    /**
     * Tests calling updateFloat on all columns of the row.
     * @exception SQLException database access error. Causes test to 
     *                         fail with an error.
     */
    public void testUpdateFloat() 
        throws SQLException
    {
        Statement s = createStatement(ResultSet.TYPE_FORWARD_ONLY, 
                ResultSet.CONCUR_UPDATABLE);
        ResultSet rs = s.executeQuery(SELECT_STMT);
        rs.next();

        for (int i = 1; i <= COLUMNS; i++) {
            rs.updateFloat(i, 2.0f);
            assertEquals("Expected rs.getFloat(" + i + 
                         ") to match updated value", 2, (int) rs.getFloat(i));
        }
        rs.updateRow();
        rs.close();
        checkColumnsAreUpdated();
        
        s.close();
    }
    
    /**
     * Tests calling updateDouble on all columns of the row.
     * @exception SQLException database access error. Causes test to 
     *                         fail with an error.
     */
    public void testUpdateDouble() 
        throws SQLException
    {
        Statement s = createStatement(ResultSet.TYPE_FORWARD_ONLY, 
                ResultSet.CONCUR_UPDATABLE);
        ResultSet rs = s.executeQuery(SELECT_STMT);
        
        rs.next();
    	
        for (int i = 1; i <= COLUMNS; i++) {
            rs.updateDouble(i, 2.0);
            assertEquals("Expected rs.getDouble(" + i + 
                         ") to match updated value", 2, (int) rs.getDouble(i));
        }
        rs.updateRow();
        rs.close();
        checkColumnsAreUpdated();
        
        s.close();
    }

    /**
     * Tests calling update on all columns of the row.
     * @exception SQLException database access error. Causes test to 
     *                         fail with an error.
     */
    public void jdbc2testUpdateBigDecimal() 
        throws SQLException
    {
        Statement s = createStatement(ResultSet.TYPE_FORWARD_ONLY, 
                ResultSet.CONCUR_UPDATABLE);
        ResultSet rs = s.executeQuery(SELECT_STMT);
        rs.next();

        for (int i = 1; i <= COLUMNS; i++) {
            rs.updateBigDecimal(i, BigDecimal.valueOf(2L));
            assertEquals("Expected rs.getBigDecimal(" + i + 
                         ") to match updated value", 2, 
                         rs.getBigDecimal(i).intValue());
        }
        rs.updateRow();
        rs.close();
        checkColumnsAreUpdated();
        
        s.close();
    }
    
    /**
     * Tests calling updateObject with a null value on all columns.
     * @exception SQLException database access error. Causes test to 
     *                         fail with an error.
     */
    public void testUpdateObjectWithNull() 
        throws SQLException
    {
        Statement s = createStatement(ResultSet.TYPE_FORWARD_ONLY, 
                ResultSet.CONCUR_UPDATABLE);
        ResultSet rs = s.executeQuery(SELECT_STMT);
        rs.next();

        Object value = null;
        
        for (int i = 1; i <= COLUMNS; i++) {
            rs.updateObject(i, value);
            assertNull("Expected rs.getObject(" + i + ") to be null", 
                       rs.getObject(i));
            assertTrue("Expected rs.wasNull() to return true",
                       rs.wasNull());
        }
        rs.updateRow();
        rs.close();
        checkColumnsAreNull();
        
        s.close();
    }

    /**
     * Tests calling setNull on all columns
     * @exception SQLException database access error. Causes test to 
     *                         fail with an error.
     */
    public void testUpdateNull() 
        throws SQLException
    {
        Statement s = createStatement(ResultSet.TYPE_FORWARD_ONLY, 
                ResultSet.CONCUR_UPDATABLE);
        ResultSet rs = s.executeQuery(SELECT_STMT);
        rs.next();

        for (int i = 1; i <= COLUMNS; i++) {
            rs.updateNull(i);
            assertNull("Expected rs.getObject(" + i + ") to be null", 
                       rs.getObject(i));
            assertTrue("Expected rs.wasNull() to return true",
                       rs.wasNull());
        }
        rs.updateRow();
        rs.close();
        checkColumnsAreNull();
        
        s.close();
    }

    /**
     * Checks that the columns in the row are all SQL null.
     * @exception SQLException database access error. Causes test to 
     *                         fail with an error.
     */
    private void checkColumnsAreNull() 
        throws SQLException
    {

        
        Statement s = createStatement(ResultSet.TYPE_FORWARD_ONLY, 
                                 ResultSet.CONCUR_READ_ONLY);
        
        ResultSet rs = s.executeQuery(SELECT_STMT);
        
        rs.next();
        
        for (int i = 1; i <= COLUMNS; i++) {
            assertNull("Expected column " + i + " to be null", 
                       rs.getObject(i));
            assertTrue("Expected wasNull() after reading column " + i +
                       " to be true when data is SQL Null on column", 
                       rs.wasNull());
        }
        s.close();
    }

    /**
     * Checks that the columns in the row are updated in the database.
     * Using a new ResultSet to do this check.
     * @exception SQLException database access error. Causes test to 
     *                         fail with an error.
     */
    private void checkColumnsAreUpdated() 
        throws SQLException
    {
         Statement s = createStatement(ResultSet.TYPE_FORWARD_ONLY, 
                                 ResultSet.CONCUR_READ_ONLY);
        
        ResultSet rs = s.executeQuery(SELECT_STMT);
        
        rs.next();
        for (int i = 1; i <= COLUMNS; i++) {
            int expectedVal = 2;
            
            // Since rs.getInt(i) on CHAR/VARCHAR columns with value 2.0 gives:
            // "ERROR 22018: Invalid character string format for type int"
            // we use getDouble(i). We cast it to int, because there is not
            // assertEquals(..) methods which takes double.
            int actualVal = (int) rs.getDouble(i); 
            assertEquals("Unexpected value from rs.getDouble( + " + i + ")",
                         expectedVal, actualVal);
        }
        s.close();
    }
    
    /* Table name */
    private static final String TABLE_NAME = "MultiTypeTable";

    /* SQL String for the SELECT statement */
    private static final  String SELECT_STMT = 
        "SELECT * FROM " + TABLE_NAME;
                             
    /* Number of columns in table */
    private static final int COLUMNS = 10;
}