// Unit tests for Async-SQLite Wrapper (Group 3: Prepared Statement Lifecycle)

#include "async_sqlite3.h"

#include "DelegateMQ.h"

#include <iostream>

#include <cstdio>

#include <vector>

#include <string>

using namespace async;

static const char* TEST_DB_FILE_STMT = "test_stmt.sqlite";

// -----------------------------------------------------------------------------

// Helper Infrastructure

// -----------------------------------------------------------------------------

static void CleanupDB() {

std::remove(TEST_DB_FILE_STMT);

}

static sqlite3* SetupDB() {

sqlite3* db = nullptr;

sqlite3_init_async();

int rc = async::sqlite3_open(TEST_DB_FILE_STMT, &db);

DMQ_ASSERT_TRUE(rc == SQLITE_OK);

return db;

}

static void TearDownDB(sqlite3* db) {

if (db) {

async::sqlite3_close(db);

}

CleanupDB();

}

// -----------------------------------------------------------------------------

// Test 1: Basic Prepare, Step, Finalize (DDL)

// -----------------------------------------------------------------------------

static void Test_Stmt_Lifecycle_Basic()

{

sqlite3* db = SetupDB();

sqlite3_stmt* stmt = nullptr;

int rc = 0;

// 1. Prepare: Create Table

const char* sql = "CREATE TABLE test_lifecycle (id INT, data TEXT);";

rc = async::sqlite3_prepare_v2(db, sql, -1, &stmt, nullptr);

DMQ_ASSERT_TRUE(rc == SQLITE_OK);

DMQ_ASSERT_TRUE(stmt != nullptr);

// 2. Step: Execute the statement

// DDL statements return SQLITE_DONE on the first step

rc = async::sqlite3_step(stmt);

DMQ_ASSERT_TRUE(rc == SQLITE_DONE);

// 3. Finalize: Clean up memory on the worker thread

rc = async::sqlite3_finalize(stmt);

DMQ_ASSERT_TRUE(rc == SQLITE_OK);

TearDownDB(db);

}

// -----------------------------------------------------------------------------

// Test 2: Reading Rows (Select Loop with Columns)

// -----------------------------------------------------------------------------

static void Test_Stmt_SelectLoop()

{

sqlite3* db = SetupDB();

// Seed data using simple exec

const char* seed = "CREATE TABLE users (id INT, name TEXT);"

"INSERT INTO users VALUES (10, 'Alice');"

"INSERT INTO users VALUES (20, 'Bob');";

async::sqlite3_exec(db, seed, nullptr, nullptr, nullptr);

sqlite3_stmt* stmt = nullptr;

const char* query = "SELECT id, name FROM users ORDER BY id ASC;";

// 1. Prepare

int rc = async::sqlite3_prepare_v2(db, query, -1, &stmt, nullptr);

DMQ_ASSERT_TRUE(rc == SQLITE_OK);

// 2. Step Row 1

rc = async::sqlite3_step(stmt);

DMQ_ASSERT_TRUE(rc == SQLITE_ROW);

// 3. Verify Columns (Row 1)

int id = async::sqlite3_column_int(stmt, 0);

DMQ_ASSERT_TRUE(id == 10);

const unsigned char* text = async::sqlite3_column_text(stmt, 1);

DMQ_ASSERT_TRUE(text != nullptr);

std::string name1(reinterpret_cast<const char*>(text));

DMQ_ASSERT_TRUE(name1 == "Alice");

// 4. Step Row 2

rc = async::sqlite3_step(stmt);

DMQ_ASSERT_TRUE(rc == SQLITE_ROW);

// 5. Verify Columns (Row 2)

id = async::sqlite3_column_int(stmt, 0);

DMQ_ASSERT_TRUE(id == 20);

text = async::sqlite3_column_text(stmt, 1);

std::string name2(reinterpret_cast<const char*>(text));

DMQ_ASSERT_TRUE(name2 == "Bob");

// 6. Step End

rc = async::sqlite3_step(stmt);

DMQ_ASSERT_TRUE(rc == SQLITE_DONE);

// 7. Finalize

async::sqlite3_finalize(stmt);

TearDownDB(db);

}

// -----------------------------------------------------------------------------

// Test 3: Reset and Re-execution

// -----------------------------------------------------------------------------

static void Test_Stmt_Reset()

{

sqlite3* db = SetupDB();

async::sqlite3_exec(db, "CREATE TABLE counter (val INT);", nullptr, nullptr, nullptr);

sqlite3_stmt* stmt = nullptr;

// Note: In real usage we would bind inputs, but here we just reuse the SQL

const char* insertSql = "INSERT INTO counter VALUES (100);";

// 1. Prepare ONCE

async::sqlite3_prepare_v2(db, insertSql, -1, &stmt, nullptr);

// 2. Run First Time

int rc = async::sqlite3_step(stmt);

DMQ_ASSERT_TRUE(rc == SQLITE_DONE);

// 3. Reset (Reset puts the statement back to the beginning)

// IMPORTANT: It does not clear bindings (tested in Group 4)

rc = async::sqlite3_reset(stmt);

DMQ_ASSERT_TRUE(rc == SQLITE_OK);

// 4. Run Second Time

rc = async::sqlite3_step(stmt);

DMQ_ASSERT_TRUE(rc == SQLITE_DONE);

async::sqlite3_finalize(stmt);

// Verify we have 2 rows now

int rowCount = 0;

auto countCb = [](void* ptr, int, char**, char**) -> int {

(*static_cast<int*>(ptr))++;

return 0;

};

async::sqlite3_exec(db, "SELECT * FROM counter;", countCb, &rowCount, nullptr);

DMQ_ASSERT_TRUE(rowCount == 2);

TearDownDB(db);

}

// -----------------------------------------------------------------------------

// Test 4: Prepare Failure (Invalid SQL)

// -----------------------------------------------------------------------------

static void Test_Stmt_PrepareFail()

{

sqlite3* db = SetupDB();

sqlite3_stmt* stmt = nullptr;

// Syntax error (missing FROM table)

const char* badSql = "SELECT * missing_table";

int rc = async::sqlite3_prepare_v2(db, badSql, -1, &stmt, nullptr);

// Should fail

DMQ_ASSERT_TRUE(rc != SQLITE_OK);

// stmt should be NULL on failure (usually, depends on specific SQLite version behavior,

// but wrapper should propagate it)

DMQ_ASSERT_TRUE(stmt == nullptr);

// Verify we can get the error message from the DB handle

const char* errMsg = async::sqlite3_errmsg(db);

DMQ_ASSERT_TRUE(errMsg != nullptr);

// Just ensure the string isn't empty

DMQ_ASSERT_TRUE(std::string(errMsg).length() > 0);

TearDownDB(db);

}

// -----------------------------------------------------------------------------

// Test 5: Column Metadata

// -----------------------------------------------------------------------------

static void Test_Stmt_ColumnMetadata()

{

sqlite3* db = SetupDB();

sqlite3_stmt* stmt = nullptr;

const char* sql = "SELECT 1 AS my_num, 'text' AS my_str";

async::sqlite3_prepare_v2(db, sql, -1, &stmt, nullptr);

// Must step at least once (or just prepare, depending on SQLite version)

// to get column count, but Step is usually not required for Col Count.

// However, Step IS required for Column Data.

int colCount = async::sqlite3_column_count(stmt);

DMQ_ASSERT_TRUE(colCount == 2);

const char* name0 = async::sqlite3_column_name(stmt, 0);

DMQ_ASSERT_TRUE(std::string(name0) == "my_num");

const char* name1 = async::sqlite3_column_name(stmt, 1);

DMQ_ASSERT_TRUE(std::string(name1) == "my_str");

async::sqlite3_finalize(stmt);

TearDownDB(db);

}

// -----------------------------------------------------------------------------

// Main Entry Point

// -----------------------------------------------------------------------------

void Prepared_UT()

{

std::cout << "Running SQLite Prepared Statement Tests..." << std::endl;

CleanupDB();

Test_Stmt_Lifecycle_Basic();

Test_Stmt_SelectLoop();

Test_Stmt_Reset();

Test_Stmt_PrepareFail();

Test_Stmt_ColumnMetadata();

std::cout << "SQLite Prepared Statement Tests Passed!" << std::endl;

}