diff options
Diffstat (limited to 'sql/src/test/java/tests/SQLite/FunctionContextTest.java')
| -rw-r--r-- | sql/src/test/java/tests/SQLite/FunctionContextTest.java | 452 |
1 files changed, 452 insertions, 0 deletions
diff --git a/sql/src/test/java/tests/SQLite/FunctionContextTest.java b/sql/src/test/java/tests/SQLite/FunctionContextTest.java new file mode 100644 index 0000000..1bb5cf5 --- /dev/null +++ b/sql/src/test/java/tests/SQLite/FunctionContextTest.java @@ -0,0 +1,452 @@ +/* + * 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} + ) + 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"); + } + +} |