path: root/sql/src/test/java/tests/SQLite/FunctionContextTest.java

/*
 * Copyright (C) 2008 The Android Open Source Project
 *
 * Licensed 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 tests.SQLite;

import SQLite.Database;
import SQLite.Exception;
import SQLite.Function;
import SQLite.FunctionContext;
import SQLite.Stmt;
import SQLite.TableResult;
import dalvik.annotation.AndroidOnly;
import dalvik.annotation.KnownFailure;
import dalvik.annotation.TestTargets;
import dalvik.annotation.TestLevel;
import dalvik.annotation.TestTargetNew;
import dalvik.annotation.TestTargetClass;

import junit.framework.TestCase;

import java.io.UnsupportedEncodingException;
import java.sql.SQLException;
import java.sql.Statement;

import tests.support.DatabaseCreator;

@TestTargetClass(FunctionContext.class)
public class FunctionContextTest extends SQLiteTest {
    
    private Database db = null;

    public void setUp() throws java.lang.Exception {
        Statement st = null;
        super.setUp();
        db = new Database();
        db.open(dbFile.getPath(), 0);
        st = conn.createStatement();
        st.execute(DatabaseCreator.CREATE_TABLE2);
        st.execute(DatabaseCreator.CREATE_TABLE_SIMPLE1);
        st.close();
    }

    /* (non-Javadoc)
     * @see junit.framework.TestCase#tearDown()
     */
    public void tearDown() {
        super.tearDown();
    }

    /**
     * Test method for {@link SQLite.FunctionContext#set_result(java.lang.String)}.
     * @throws Exception 
     */
    @TestTargetNew(
        level = TestLevel.SUFFICIENT,
        notes = "indirectly tested invoking function",
        method = "set_result",
        args = {java.lang.String.class}
    )
    public void testSet_resultString() throws Exception {
        TestFCString testString = new TestFCString();
        db.exec("insert into " + DatabaseCreator.TEST_TABLE2
                + " (ftext) values ('TestInput')", null);
        db.create_function("test", 1, testString);
        TableResult res = db.get_table("select test(ftext) from "
                + DatabaseCreator.TEST_TABLE2);
        String row[] = (String[]) res.rows.elementAt(0);
        String val = row[0];

        assertEquals("TestInput", val);
    }

    /**
     * Test method for {@link SQLite.FunctionContext#set_result(int)}.
     * @throws Exception 
     */
    @TestTargetNew(
        level = TestLevel.SUFFICIENT,
        notes = "method test",
        method = "set_result",
        args = {int.class}
    )
    public void testSet_resultInt() throws Exception {
        TestFCInt testInt = new TestFCInt();
        db.exec("insert into " + DatabaseCreator.SIMPLE_TABLE1
                + "  values (1,'" + testInt.intVal + "',3)", null);
        db.create_function("testInt", 1, testInt);
        TableResult res = db.get_table("select testInt(speed) from "
                + DatabaseCreator.SIMPLE_TABLE1);
        String row[] = (String[]) res.rows.elementAt(0);
        String val = row[0];

        assertEquals(testInt.intVal, Integer.parseInt(val));
    }

    /**
     * Test method for {@link SQLite.FunctionContext#set_result(double)}.
     * @throws Exception 
     */
    @TestTargetNew(
        level = TestLevel.SUFFICIENT,
        notes = "indirectly tested",
        method = "set_result",
        args = {double.class}
    )
    public void testSet_resultDouble() throws Exception {
        SinFunc testD = new SinFunc();
        db.exec("insert into " + DatabaseCreator.TEST_TABLE2
                + " (fdouble)  values (" + testD.testDouble + ")", null);
        db.create_function("testDouble", 1, testD);
        TableResult res = db.get_table("select testDouble(fdouble) from "
                + DatabaseCreator.TEST_TABLE2);
        String row[] = (String[]) res.rows.elementAt(0);
        String val = row[0];

        assertEquals(testD.testDouble, Double.parseDouble(val));
        
        assertTrue(testD.functionCalled);
    }

    /**
     * Test method for {@link SQLite.FunctionContext#set_error(java.lang.String)}.
     * @throws Exception 
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "method test",
        method = "set_error",
        args = {java.lang.String.class}
    )
    public void testSet_error() throws Exception {
        TestFCError testError = new TestFCError();
        SinFunc testD = new SinFunc();
        db.exec("insert into " + DatabaseCreator.TEST_TABLE2
                + " (fdouble)  values (" + testD.testDouble + ")", null);
        db.create_function("testError", 1, testError);
        
        try {
        TableResult res = db.get_table("select testError(fdouble) from "
                + DatabaseCreator.TEST_TABLE2);
        fail("Should get Exception");
        } catch (Exception e) {
            assertEquals("error in step", e.getMessage());
        }
        
        assertFalse(testD.functionCalled);
    }

    /**
     * Test method for {@link SQLite.FunctionContext#set_result(byte[])}.
     * @throws Exception 
     * @throws UnsupportedEncodingException 
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "method test",
        method = "set_result",
        args = {byte[].class}
    )
    public void testSet_resultByteArray() throws Exception, UnsupportedEncodingException {     
        Stmt st = null;
        TestFCByteArray testBinArrayFnc = new TestFCByteArray();
        String expected = "";
        expected = "X'" + getHexString(testBinArrayFnc.byteVal) + "'";
        
        // setup
        db.exec("create table testBinaryData (binVal BINARY) ;", null);
        
        try {
        st = db.prepare("insert into testBinaryData values (?)");
        st.bind(1, testBinArrayFnc.byteVal);
        st.step();


        db.create_function("testBinArray", 1, testBinArrayFnc);
        TableResult res = db
                .get_table("select testBinArray(binVal) from testBinaryData");

        String row[] = (String[]) res.rows.elementAt(0);
        String val = row[0];
       
        assertTrue(expected.equalsIgnoreCase(val));
        
        assertTrue(testBinArrayFnc.functionCalled);
        
        } finally {
            //teardown
            db.exec("drop table testBinaryData;", null);
        }
    }

    /**
     * Test method for {@link SQLite.FunctionContext#set_result_zeroblob(int)}.
     * @throws Exception 
     * @throws UnsupportedEncodingException 
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "method test",
        method = "set_result_zeroblob",
        args = {int.class}
    )
    @AndroidOnly("ZeroBlob not supported")
    public void testSet_result_zeroblob() throws Exception,
            UnsupportedEncodingException {
        Stmt st = null;
        TestFCZeroBlob testZeroBlobFnc = new TestFCZeroBlob();
        byte[] byteVal = {(byte) 1, (byte) 2, (byte) 3};
        
        
        // setup
        db.exec("create table testBinaryData (binVal BINARY) ;", null);
        
        try {
        st = db.prepare("insert into testBinaryData values (?)");
        st.bind(1, byteVal);
        st.step();


        db.create_function("testZeroBlob", 0, testZeroBlobFnc);
        TableResult res = db
                .get_table("select testZeroBlob() from testBinaryData");
        TableResult res2 = db.get_table("select zeroblob("
                + testZeroBlobFnc.numBytes + ") from testBinaryData");

        String row[] = (String[]) res.rows.elementAt(0);
        String val = row[0];

        assertNotNull(val);

        assertEquals(((String[]) res2.rows.elementAt(0))[0], val);
        assertTrue(testZeroBlobFnc.functionCalled);
        
        } finally  {
         // teardown
            db.exec("drop table if exists testBinaryData;", null);
        }
    }

    /**
     * Test method for {@link SQLite.FunctionContext#count()}.
     * @throws SQLException 
     * @throws Exception 
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "method test",
        method = "count",
        args = {}
    )
    @AndroidOnly("Test Method results in a segmentation fault.")
    public void testCount() throws SQLException, Exception {
        TestFCCount countTest = new TestFCCount();
        int inputCount = 10;
        
        assertFalse(countTest.functionCalled);
        
        DatabaseCreator.fillTestTable2(conn, inputCount);
        db.create_function("testCount", 0, countTest);
        // the invokation of testCount leads to a Segmentation fault
        /*
        TableResult res = db
                .get_table("select testCount() from "+DatabaseCreator.TEST_TABLE2);
       
        String row[] = (String[]) res.rows.elementAt(0);
        String val = row[0];
        
        assertTrue(countTest.functionCalled);
        assertEquals(inputCount,Integer.parseInt(val));
        */
        
    }
    
    class TestFCError implements Function {
        public boolean functionCalled = false;
        public String errorMsg = "FunctionError";
        
        public void function(FunctionContext fc, String args[]) {
            functionCalled = true;
            fc.set_error(errorMsg);
        }

        public void last_step(FunctionContext fc) {
            // TODO Auto-generated method stub

        }

        public void step(FunctionContext fc, String[] args) {
            // TODO Auto-generated method stub

        }
    }
    
    class TestFCCount implements Function {
        public boolean functionCalled = false;
        public int noOfRows = 0;
        
        public void function(FunctionContext fc, String args[]) {
            functionCalled = true;
            noOfRows = fc.count();
            fc.set_result(noOfRows);
        }

        public void last_step(FunctionContext fc) {
            // TODO Auto-generated method stub

        }

        public void step(FunctionContext fc, String[] args) {
            // TODO Auto-generated method stub

        }
    }
    
    class TestFCZeroBlob implements Function {
        public int numBytes = 16;
        public boolean functionCalled = false;
        
        public void function(FunctionContext fc, String args[]) {
            functionCalled = true;
            fc.set_result_zeroblob(numBytes);
        }

        public void last_step(FunctionContext fc) {
            // TODO Auto-generated method stub

        }

        public void step(FunctionContext fc, String[] args) {
            // TODO Auto-generated method stub

        }
    }
    
    class TestFCString implements Function {
        public String testString = "TestString";
        public boolean functionCalled;
        
        public void function(FunctionContext fc, String args[]) {
            assertNotNull(args);
            functionCalled = true;
            fc.set_result(args[0]);
        }

        public void last_step(FunctionContext fc) {
            // TODO Auto-generated method stub

        }

        public void step(FunctionContext fc, String[] args) {
            // TODO Auto-generated method stub

        }
    }
    
    class TestFCInt implements Function {
        public int intVal = Integer.MAX_VALUE;
        public boolean functionCalled;
        
        public void function(FunctionContext fc, String args[]) {
            assertNotNull(args);
            functionCalled = true;
            fc.set_result(Integer.parseInt(args[0]));
        }

        public void last_step(FunctionContext fc) {
            // TODO Auto-generated method stub

        }

        public void step(FunctionContext fc, String[] args) {
            // TODO Auto-generated method stub

        }
    }
    
    class TestFCByteArray implements Function {
        public byte[] byteVal = {(byte)  1, (byte) 2, (byte) 3};
        public boolean functionCalled;
        
        public void function(FunctionContext fc, String args[]) {
            assertNotNull(args);
            functionCalled = true;
            fc.set_result(args[0].getBytes());
        }

        public void last_step(FunctionContext fc) {
            // TODO Auto-generated method stub

        }

        public void step(FunctionContext fc, String[] args) {
            // TODO Auto-generated method stub

        }
    }
    
        class SinFunc implements Function {
            
        public Double testDouble = 3.0;
        public boolean functionCalled = false;
        
        public void function(FunctionContext fc, String args[]) {
            Double d = new Double(args[0]);
            functionCalled = true;
            fc.set_result(d.doubleValue());
        }

        public void last_step(FunctionContext fc) {
            // TODO Auto-generated method stub

        }

        public void step(FunctionContext fc, String[] args) {
            // TODO Auto-generated method stub

        }
    }
    
    static final byte[] HEX_CHAR_TABLE = {
            (byte)'0', (byte)'1', (byte)'2', (byte)'3',
            (byte)'4', (byte)'5', (byte)'6', (byte)'7',
            (byte)'8', (byte)'9', (byte)'a', (byte)'b',
            (byte)'c', (byte)'d', (byte)'e', (byte)'f'
          };    

     public static String getHexString(byte[] raw)
            throws UnsupportedEncodingException {
        byte[] hex = new byte[2 * raw.length];
        int index = 0;

        for (byte b : raw) {
            int v = b & 0xFF;
            hex[index++] = HEX_CHAR_TABLE[v >>> 4];
            hex[index++] = HEX_CHAR_TABLE[v & 0xF];
        }
        return new String(hex, "ASCII");
    }

}