connection_test.cc

// Copyright 2023 Google LLC
//
// 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
//
//      https://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.

#include "google/cloud/odbc/testing/odbc_utils/connection.h"
#include "google/cloud/odbc/internal/version.h"
#include <gmock/gmock.h>
#include <nlohmann/json.hpp>
#include <fstream>

namespace google::cloud::odbc_tests {
using google::cloud::odbc_tests::SetAttributes;
using ::testing::HasSubstr;

void CheckDiagnosticRecord(SQLHDBC hdbc, std::string const& expected_sqlstate,
                           int expected_error_code,
                           std::string const& expected_message_regex);

std::string GetDriverName() {
#ifndef BQ_DRIVER_INTEGRATION_TESTS
#ifdef _WIN32
  return kExistingDriverWindows;
#else
  return kExistingDriverNonWindows;
#endif /* _WIN32 */
#else
  return "ODBC Driver for BigQuery";
#endif /* BQ_DRIVER_INTEGRATION_TESTS */
}

TEST(SQLGetInfo, CheckPositionalUpdate) {
  auto conn = std::make_shared<ODBCHandles>();
  EXPECT_EQ(Connect(kDefaultConnectionString, conn), SQL_SUCCESS);

  // Check SQL_DYNAMIC_CURSOR_ATTRIBUTES1
  SQLUINTEGER sql_bitmask_buf = 0;
  SQLRETURN status;
  status = SQLGetInfo(conn->hdbc, SQL_DYNAMIC_CURSOR_ATTRIBUTES1,
                      &sql_bitmask_buf, 0, nullptr);
  CheckError(status, "SQLGetInfo(SQL_DYNAMIC_CURSOR_ATTRIBUTES1)", conn);

  EXPECT_NE(SQL_CA1_POSITIONED_UPDATE,
            (sql_bitmask_buf & SQL_CA1_POSITIONED_UPDATE));
  EXPECT_NE(SQL_CA1_POSITIONED_DELETE,
            (sql_bitmask_buf & SQL_CA1_POSITIONED_DELETE));

  // Check SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES1
  sql_bitmask_buf = 0;
  status = SQLGetInfo(conn->hdbc, SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES1,
                      &sql_bitmask_buf, 0, nullptr);
  CheckError(status, "SQLGetInfo(SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES1)", conn);

  EXPECT_NE(SQL_CA1_POSITIONED_UPDATE,
            (sql_bitmask_buf & SQL_CA1_POSITIONED_UPDATE));
  EXPECT_NE(SQL_CA1_POSITIONED_DELETE,
            (sql_bitmask_buf & SQL_CA1_POSITIONED_DELETE));

  // Check SQL_KEYSET_CURSOR_ATTRIBUTES1
  sql_bitmask_buf = 0;
  status = SQLGetInfo(conn->hdbc, SQL_KEYSET_CURSOR_ATTRIBUTES1,
                      &sql_bitmask_buf, 0, nullptr);
  CheckError(status, "SQLGetInfo(SQL_KEYSET_CURSOR_ATTRIBUTES1)", conn);

  EXPECT_NE(SQL_CA1_POSITIONED_UPDATE,
            (sql_bitmask_buf & SQL_CA1_POSITIONED_UPDATE));
  EXPECT_NE(SQL_CA1_POSITIONED_DELETE,
            (sql_bitmask_buf & SQL_CA1_POSITIONED_DELETE));

  // Check SQL_STATIC_CURSOR_ATTRIBUTES1
  sql_bitmask_buf = 0;
  status = SQLGetInfo(conn->hdbc, SQL_STATIC_CURSOR_ATTRIBUTES1,
                      &sql_bitmask_buf, 0, nullptr);
  CheckError(status, "SQLGetInfo(SQL_KEYSET_CURSOR_ATTRIBUTES1)", conn);

  EXPECT_NE(SQL_CA1_POSITIONED_UPDATE,
            (sql_bitmask_buf & SQL_CA1_POSITIONED_UPDATE));
  EXPECT_NE(SQL_CA1_POSITIONED_DELETE,
            (sql_bitmask_buf & SQL_CA1_POSITIONED_DELETE));

  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}

TEST(SQLGetInfo, CheckSqlConformance) {
  auto conn = std::make_shared<ODBCHandles>();
  EXPECT_EQ(Connect(kDefaultConnectionString, conn), SQL_SUCCESS);

  SQLUINTEGER conformance_val = 0;
  auto status = SQLGetInfo(conn->hdbc, SQL_SQL_CONFORMANCE, &conformance_val,
                           sizeof(conformance_val), nullptr);
  ASSERT_TRUE(SQL_SUCCEEDED(status));
  EXPECT_EQ(conformance_val, SQL_SC_SQL92_ENTRY);
  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}

TEST(SQLGetInfoW, CheckDriverName_Wide) {
  auto conn = std::make_shared<ODBCHandles>();
  EXPECT_EQ(Connect(kDefaultConnectionString, conn), SQL_SUCCESS);

  SQLWCHAR sqlWCharBuf[kBufferLength];
  std::string expected_info_val = "ODBC Driver For BigQuery";
  SQLSMALLINT out_len;
  SQLRETURN status = SQLGetInfoW(conn->hdbc, SQL_DRIVER_NAME,
                                 reinterpret_cast<SQLPOINTER>(sqlWCharBuf),
                                 kBufferLength, &out_len);
  ASSERT_TRUE(SQL_SUCCEEDED(status));
  std::string str_out =
      ConvertSQLWCHARToString(sqlWCharBuf, out_len / sizeof(SQLWCHAR));
#ifdef BQ_DRIVER_INTEGRATION_TESTS
  EXPECT_STREQ(str_out.data(), "ODBC Driver For BigQuery");
#else
  EXPECT_STREQ(str_out.data(), kExistingDriverWindows.c_str());
#endif

  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}

#ifdef BQ_DRIVER_INTEGRATION_TESTS
namespace {
// Constants for GetBQDriverInfo
static std::map<SQLUSMALLINT, std::string> const kUnsupportedEmptyCharMap = {
    {SQL_KEYWORDS, ""},
    {SQL_PROCEDURE_TERM, ""},
    {SQL_SPECIAL_CHARACTERS, ""},
    {SQL_USER_NAME, ""}};

static std::map<SQLUSMALLINT, std::string> const kUnsupportedNCharMap = {
    {SQL_ACCESSIBLE_PROCEDURES, "N"},
    {SQL_DATA_SOURCE_READ_ONLY, "N"},
    {SQL_INTEGRITY, "N"},
    {SQL_LIKE_ESCAPE_CLAUSE, "N"},
    {SQL_MAX_ROW_SIZE_INCLUDES_LONG, "N"},
    {SQL_MULT_RESULT_SETS, "N"},
    {SQL_NEED_LONG_DATA_LEN, "N"},
    {SQL_ORDER_BY_COLUMNS_IN_SELECT, "N"},
    {SQL_ROW_UPDATES, "N"}};

static std::map<SQLUSMALLINT, std::string> const kSupportedCharMap = {
    {SQL_ACCESSIBLE_TABLES, "Y"},
    {SQL_CATALOG_NAME, "Y"},
    {SQL_CATALOG_NAME_SEPARATOR, "."},
    {SQL_CATALOG_TERM, "Project"},
    {SQL_COLLATION_SEQ, "UTF-16LE_BINARY"},
    {SQL_COLUMN_ALIAS, "Y"},
    {SQL_DBMS_NAME, "BigQuery"},
    {SQL_DBMS_VER, "2"},
    {SQL_DESCRIBE_PARAMETER, "Y"},
    {SQL_DRIVER_NAME, "ODBC Driver For BigQuery"},
    {SQL_DRIVER_ODBC_VER, "03.80"},
    {SQL_DRIVER_VER, DRIVER_VERSION},
    {SQL_EXPRESSIONS_IN_ORDERBY, "Y"},
    {SQL_IDENTIFIER_QUOTE_CHAR, "`"},
    {SQL_MULTIPLE_ACTIVE_TXN, "Y"},
    {SQL_PROCEDURES, "Y"},
    {SQL_SCHEMA_TERM, "Dataset"},
    {SQL_SEARCH_PATTERN_ESCAPE, "\\"},
    {SQL_SERVER_NAME, "Google"},
    {SQL_TABLE_TERM, "Table"}};

static std::map<SQLUSMALLINT, SQLUSMALLINT> const kUnsupportedUSmallIntMap = {
    {SQL_ACTIVE_ENVIRONMENTS, 0},
    {SQL_CONCAT_NULL_BEHAVIOR, 0},
    {SQL_FILE_USAGE, 0},
    {SQL_MAX_COLUMNS_IN_GROUP_BY, 0},
    {SQL_MAX_COLUMNS_IN_INDEX, 0},
    {SQL_MAX_COLUMNS_IN_ORDER_BY, 0},
    {SQL_MAX_COLUMNS_IN_SELECT, 0},
    {SQL_MAX_CONCURRENT_ACTIVITIES, 0},
    {SQL_MAX_CURSOR_NAME_LEN, 0},
    {SQL_MAX_DRIVER_CONNECTIONS, 0},
    {SQL_MAX_PROCEDURE_NAME_LEN, 0},
    {SQL_MAX_USER_NAME_LEN, 0},
    {SQL_NON_NULLABLE_COLUMNS, 0}};

static std::map<SQLUSMALLINT, SQLUSMALLINT> const kSupportedUSmallIntMap = {
    {SQL_CATALOG_LOCATION, 1},
    {SQL_CORRELATION_NAME, 2},
    {SQL_CURSOR_COMMIT_BEHAVIOR, 1},
    {SQL_CURSOR_ROLLBACK_BEHAVIOR, 1},
    {SQL_GROUP_BY, 2},
    {SQL_IDENTIFIER_CASE, 3},
    {SQL_MAX_CATALOG_NAME_LEN, 128},
    {SQL_MAX_COLUMNS_IN_TABLE, 10000},
    {SQL_MAX_COLUMN_NAME_LEN, 128},
    {SQL_MAX_IDENTIFIER_LEN, 255},
    {SQL_MAX_SCHEMA_NAME_LEN, 1024},
    {SQL_MAX_TABLES_IN_SELECT, 1000},
    {SQL_MAX_TABLE_NAME_LEN, 1024},
    {SQL_NULL_COLLATION, 1},
    {SQL_QUOTED_IDENTIFIER_CASE, 3},
    {SQL_TXN_CAPABLE, 1}};

static std::map<SQLUSMALLINT, SQLUINTEGER> const kSupportedUIntMap = {
    {SQL_ASYNC_MODE, 2},
    {SQL_DEFAULT_TXN_ISOLATION, 8},
    {SQL_ODBC_INTERFACE_CONFORMANCE, 1},
    {SQL_SQL_CONFORMANCE, 1}};

static std::map<SQLUSMALLINT, SQLUINTEGER> const kUnsupportedUIntMap = {
    {SQL_BATCH_ROW_COUNT, 0},
    {SQL_BATCH_SUPPORT, 0},
    {SQL_BOOKMARK_PERSISTENCE, 0},
    {SQL_CURSOR_SENSITIVITY, 0},
    {SQL_DDL_INDEX, 0},
    {SQL_MAX_ASYNC_CONCURRENT_STATEMENTS, 0},
    {SQL_MAX_BINARY_LITERAL_LEN, 0},
    {SQL_MAX_CHAR_LITERAL_LEN, 0},
    {SQL_MAX_INDEX_SIZE, 0},
    {SQL_MAX_ROW_SIZE, 0},
    {SQL_MAX_STATEMENT_LEN, 0},
    {SQL_PARAM_ARRAY_ROW_COUNTS, 0},
    {SQL_PARAM_ARRAY_SELECTS, 0}};

static std::map<SQLUSMALLINT, SQLUINTEGER> const kUnsupportedBitmaskMap = {
    {SQL_ALTER_DOMAIN, 0L},
    {SQL_ALTER_TABLE, 0L},
    {SQL_CONVERT_BINARY, 0L},
    {SQL_CONVERT_CHAR, 0L},
    {SQL_CONVERT_DECIMAL, 0L},
    {SQL_CONVERT_FLOAT, 0L},
    {SQL_CONVERT_INTEGER, 0L},
    {SQL_CONVERT_INTERVAL_DAY_TIME, 0L},
    {SQL_CONVERT_INTERVAL_YEAR_MONTH, 0L},
    {SQL_CONVERT_LONGVARBINARY, 0L},
    {SQL_CONVERT_LONGVARCHAR, 0L},
    {SQL_CONVERT_NUMERIC, 0L},
    {SQL_CONVERT_REAL, 0L},
    {SQL_CONVERT_SMALLINT, 0L},
    {SQL_CONVERT_TINYINT, 0L},
    {SQL_CREATE_ASSERTION, 0L},
    {SQL_CREATE_CHARACTER_SET, 0L},
    {SQL_CREATE_COLLATION, 0L},
    {SQL_CREATE_DOMAIN, 0L},
    {SQL_CREATE_SCHEMA, 0L},
    {SQL_CREATE_SCHEMA, 0L},
    {SQL_CREATE_TABLE, 0L},
    {SQL_CREATE_TRANSLATION, 0L},
    {SQL_CREATE_VIEW, 0L},
    {SQL_DROP_ASSERTION, 0L},
    {SQL_DROP_CHARACTER_SET, 0L},
    {SQL_DROP_COLLATION, 0L},
    {SQL_DROP_DOMAIN, 0L},
    {SQL_DROP_SCHEMA, 0L},
    {SQL_DROP_TABLE, 0L},
    {SQL_DROP_TRANSLATION, 0L},
    {SQL_DROP_VIEW, 0L},
    {SQL_DYNAMIC_CURSOR_ATTRIBUTES1, 0L},
    {SQL_DYNAMIC_CURSOR_ATTRIBUTES2, 0L},
    {SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES1, 0L},
    {SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES1, 0L},
    {SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES2, 0L},
    {SQL_INDEX_KEYWORDS, 0L},
    {SQL_INFO_SCHEMA_VIEWS, 0L},
    {SQL_INSERT_STATEMENT, 0L},
    {SQL_KEYSET_CURSOR_ATTRIBUTES1, 0L},
    {SQL_KEYSET_CURSOR_ATTRIBUTES2, 0L},
    {SQL_POS_OPERATIONS, 0L},
    {SQL_SQL92_FOREIGN_KEY_DELETE_RULE, 0L},
    {SQL_SQL92_FOREIGN_KEY_UPDATE_RULE, 0L},
    {SQL_SQL92_GRANT, 0L},
    {SQL_SQL92_NUMERIC_VALUE_FUNCTIONS, 0L},
    {SQL_SQL92_REVOKE, 0L},
    {SQL_STATIC_CURSOR_ATTRIBUTES1, 0L},
    {SQL_STATIC_CURSOR_ATTRIBUTES2, 0L},
    {SQL_UNION, 0L}};

static std::map<SQLUSMALLINT, SQLUINTEGER> const kSupportedBitmaskMap = {
    {SQL_AGGREGATE_FUNCTIONS, 127},
    {SQL_CATALOG_USAGE, 1},
    {SQL_CONVERT_BIT, 20736},
    {SQL_CONVERT_DATE, 164096},
    {SQL_CONVERT_DOUBLE, 16768},
    {SQL_CONVERT_FUNCTIONS, 3},
    {SQL_CONVERT_TIME, 65792},
    {SQL_CONVERT_VARBINARY, 2304},
    {SQL_CONVERT_VARCHAR, 252288},
    {SQL_DATETIME_LITERALS, 4},
    {SQL_GETDATA_EXTENSIONS, 15},
    {SQL_NUMERIC_FUNCTIONS, 14221311},
    {SQL_CONVERT_TIMESTAMP, 196864},
    {SQL_OJ_CAPABILITIES, 127},
    {SQL_SCROLL_OPTIONS, 1},
    {SQL_SCHEMA_USAGE, 31},
    {SQL_SUBQUERIES, 31},
    {SQL_TXN_ISOLATION_OPTION, 8},
    {SQL_TIMEDATE_FUNCTIONS, 2097151},
    {SQL_SYSTEM_FUNCTIONS, 4},
    {SQL_TIMEDATE_ADD_INTERVALS, 510},
    {SQL_TIMEDATE_DIFF_INTERVALS, 478},
    {SQL_SQL92_PREDICATES, 16135},
    {SQL_SQL92_RELATIONAL_JOIN_OPERATORS, 346},
    {SQL_SQL92_ROW_VALUE_CONSTRUCTOR, 15},
    {SQL_SQL92_DATETIME_FUNCTIONS, 7},
    {SQL_SQL92_STRING_FUNCTIONS, 254},
    {SQL_SQL92_VALUE_EXPRESSIONS, 2},
    {SQL_STANDARD_CLI_CONFORMANCE, 2},
    {SQL_STRING_FUNCTIONS, 15822265},
    {SQL_CONVERT_BIGINT, 20864}};

void AssertBQDriverSQLGetInfo(std::shared_ptr<ODBCHandles> conn) {
  SQLCHAR sqlCharBuf[kBufferLength];
  SQLUSMALLINT sqlUSmallIntBuf;
  SQLUINTEGER sqlUIntegerBuf;
  SQLUINTEGER sqlBitmaskBuf;
  SQLSMALLINT out_len;
  SQLRETURN status;

  for (auto elem : kSupportedCharMap) {
    auto info_type = elem.first;
    auto expected_info_val = elem.second;
    status = SQLGetInfo(conn->hdbc, info_type,
                        reinterpret_cast<SQLPOINTER>(sqlCharBuf), kBufferLength,
                        &out_len);
    ASSERT_TRUE(SQL_SUCCEEDED(status));
    std::string actual_val = reinterpret_cast<char*>(sqlCharBuf);
    EXPECT_EQ(expected_info_val, actual_val);
  }
  for (auto elem : kUnsupportedEmptyCharMap) {
    auto info_type = elem.first;
    status = SQLGetInfo(conn->hdbc, info_type,
                        reinterpret_cast<SQLPOINTER>(sqlCharBuf), kBufferLength,
                        &out_len);
    ASSERT_TRUE(SQL_SUCCEEDED(status));
    std::string actual_val = (char*)sqlCharBuf;
    EXPECT_EQ("", actual_val);
  }
  for (auto elem : kUnsupportedNCharMap) {
    auto info_type = elem.first;
    status = SQLGetInfo(conn->hdbc, info_type,
                        reinterpret_cast<SQLPOINTER>(sqlCharBuf), kBufferLength,
                        &out_len);
    ASSERT_TRUE(SQL_SUCCEEDED(status));
    std::string actual_val = (char*)sqlCharBuf;
    EXPECT_EQ("N", actual_val);
  }
  for (auto elem : kSupportedUSmallIntMap) {
    auto info_type = elem.first;
    auto expected_info_val = elem.second;
    status = SQLGetInfo(conn->hdbc, info_type,
                        reinterpret_cast<SQLPOINTER>(&sqlUSmallIntBuf),
                        sizeof(sqlUSmallIntBuf), &out_len);
    ASSERT_TRUE(SQL_SUCCEEDED(status));
    SQLUSMALLINT actual_val = sqlUSmallIntBuf;
    EXPECT_EQ(expected_info_val, actual_val);
  }
  for (auto elem : kUnsupportedUSmallIntMap) {
    auto info_type = elem.first;
    status = SQLGetInfo(conn->hdbc, info_type,
                        reinterpret_cast<SQLPOINTER>(&sqlUSmallIntBuf),
                        sizeof(sqlUSmallIntBuf), &out_len);
    ASSERT_TRUE(SQL_SUCCEEDED(status));
    SQLUSMALLINT actual_val = sqlUSmallIntBuf;
    EXPECT_EQ(0, actual_val);
  }
  for (auto elem : kSupportedUIntMap) {
    auto info_type = elem.first;
    auto expected_info_val = elem.second;
    status = SQLGetInfo(conn->hdbc, info_type,
                        reinterpret_cast<SQLPOINTER>(&sqlUIntegerBuf),
                        sizeof(sqlUIntegerBuf), &out_len);
    ASSERT_TRUE(SQL_SUCCEEDED(status));
    SQLUINTEGER actual_val = sqlUIntegerBuf;
    EXPECT_EQ(expected_info_val, actual_val);
  }
  for (auto elem : kUnsupportedUIntMap) {
    auto info_type = elem.first;
    status = SQLGetInfo(conn->hdbc, info_type,
                        reinterpret_cast<SQLPOINTER>(&sqlUIntegerBuf),
                        sizeof(sqlUIntegerBuf), &out_len);
    ASSERT_TRUE(SQL_SUCCEEDED(status));
    SQLUINTEGER actual_val = sqlUIntegerBuf;
    EXPECT_EQ(0, actual_val);
  }
  for (auto elem : kSupportedBitmaskMap) {
    auto info_type = elem.first;
    auto expected_info_val = elem.second;
    status = SQLGetInfo(conn->hdbc, info_type,
                        reinterpret_cast<SQLPOINTER>(&sqlBitmaskBuf),
                        sizeof(sqlBitmaskBuf), &out_len);
    ASSERT_TRUE(SQL_SUCCEEDED(status));
    SQLUINTEGER actual_val = sqlBitmaskBuf;
    EXPECT_EQ(expected_info_val, actual_val);
  }
  for (auto elem : kUnsupportedBitmaskMap) {
    auto info_type = elem.first;
    status = SQLGetInfo(conn->hdbc, info_type,
                        reinterpret_cast<SQLPOINTER>(&sqlBitmaskBuf),
                        sizeof(sqlBitmaskBuf), &out_len);
    ASSERT_TRUE(SQL_SUCCEEDED(status));
    SQLUINTEGER actual_val = sqlBitmaskBuf;
    EXPECT_EQ(0L, actual_val);
  }
}

void AssertSupportedFnsODBC3(SQLUSMALLINT* odbc3_fns) {
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLALLOCHANDLE));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLGETDESCFIELD));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLSETCONNECTATTR));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLDRIVERS));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLBINDCOL));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLGETDESCREC));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLCANCEL));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLGETDIAGFIELD));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLCLOSECURSOR));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLGETDIAGREC));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLCOLATTRIBUTE));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLGETENVATTR));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLCONNECT));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLGETFUNCTIONS));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLCOPYDESC));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLGETINFO));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLDATASOURCES));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLGETSTMTATTR));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLDESCRIBECOL));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLGETTYPEINFO));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLDISCONNECT));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLNUMRESULTCOLS));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLPARAMDATA));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLENDTRAN));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLPREPARE));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLEXECDIRECT));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLPUTDATA));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLEXECUTE));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLROWCOUNT));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLFETCH));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLFETCHSCROLL));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLSETCURSORNAME));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLFREEHANDLE));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLSETDESCFIELD));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLSETDESCREC));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLGETCONNECTATTR));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLSETENVATTR));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLGETCURSORNAME));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLSETSTMTATTR));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLGETDATA));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLCOLUMNS));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLSTATISTICS));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLSPECIALCOLUMNS));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLTABLES));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLBINDPARAM));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLNATIVESQL));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLBROWSECONNECT));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLNUMPARAMS));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLPRIMARYKEYS));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLCOLUMNPRIVILEGES));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLPROCEDURECOLUMNS));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLDESCRIBEPARAM));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLPROCEDURES));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLDRIVERCONNECT));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLFOREIGNKEYS));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLTABLEPRIVILEGES));
  EXPECT_EQ(SQL_TRUE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLMORERESULTS));
}
}  // namespace

#endif  // BQ_DRIVER_INTEGRATION_TESTS

std::vector<int> GetMajorMinorVer(std::string version_str) {
  std::vector<int> versions;
  int start, end = -1;

  do {
    start = end + 1;
    end = version_str.find(".", start);
    versions.emplace_back(stoi(version_str.substr(start, end - start)));
  } while (end != -1);

  return versions;
}

void VerifyDriverInfo(std::shared_ptr<ODBCHandles> conn) {
  EXPECT_EQ(conn->metadata.dsn_name, GetDefaultDSN());
  std::vector<int> db_odbc_versions =
      GetMajorMinorVer(conn->metadata.db_odbc_ver);
  EXPECT_EQ(db_odbc_versions[0], 3);
  std::vector<int> driver_odbc_versions =
      GetMajorMinorVer(conn->metadata.driver_odbc_ver);
  EXPECT_EQ(driver_odbc_versions[0], 3);
#ifdef BQ_DRIVER_INTEGRATION_TESTS
  EXPECT_EQ(conn->metadata.driver_name, "ODBC Driver For BigQuery");
#else
  EXPECT_EQ(conn->metadata.driver_name, kExistingDriverWindows);
#endif  // BQ_DRIVER_INTEGRATION_TESTS
}

void SetAttr(std::shared_ptr<ODBCHandles> conn, bool use_ansi = false) {
  SQLCHAR buf[256] = "test";
  EXPECT_EQ(Connect(kDefaultConnectionString, conn, use_ansi), SQL_SUCCESS);

  SQLRETURN status;
  if (use_ansi) {
    status = SQLSetConnectAttrA(conn->hdbc, SQL_ATTR_CURRENT_CATALOG,
                                (SQLPOINTER)buf, SQL_NTS);
  } else {
    status = SQLSetConnectAttr(conn->hdbc, SQL_ATTR_CURRENT_CATALOG,
                               (SQLPOINTER)buf, SQL_NTS);
  }
  CheckError(status, "SQLSetConnectAttr", conn, use_ansi);

  SQLCHAR output[256];
  SQLINTEGER length;
  if (use_ansi) {
    status = SQLGetConnectAttrA(conn->hdbc, SQL_ATTR_CURRENT_CATALOG,
                                (SQLPOINTER)output, 256, &length);
  } else {
    status = SQLGetConnectAttr(conn->hdbc, SQL_ATTR_CURRENT_CATALOG,
                               (SQLPOINTER)output, 256, &length);
  }
  CheckError(status, "SQLGetConnectAttr", conn, use_ansi);

  std::string actual = reinterpret_cast<char*>(output);
  EXPECT_EQ("test", actual);
  EXPECT_EQ(4, length);
}

// Sets the window handle for SQLDriverConnect (Windows: desktop handle, others:
// nullptr).
void GetWindowHandle(SQLHWND& window_handle) {
#ifdef _WIN32
  window_handle = GetDesktopWindow();
#else
  window_handle = nullptr;
#endif  // _WIN32
}

TEST(ConnectionTest, SQLDriverConnect) {
  auto conn = std::make_shared<ODBCHandles>();
  EXPECT_EQ(Connect(kDefaultConnectionString, conn), SQL_SUCCESS);
  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}

TEST(ConnectionTest, SQLDriverConnectW) {
  auto conn = std::make_shared<ODBCHandles>();
  std::wstring defaultConnectionWstring = Utf8ToUtf16(kDefaultConnectionString);
  EXPECT_EQ(Connect(defaultConnectionWstring, conn, 30, true), SQL_SUCCESS);
  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}

TEST(ConnectionTest, SQLDriverConnect_NULLOutput) {
  auto conn = std::make_shared<ODBCHandles>();
  std::wstring defaultConnectionWstring = Utf8ToUtf16(kDefaultConnectionString);
  EXPECT_EQ(ConnectWithNullOutputParams(kDefaultConnectionString,
                                        defaultConnectionWstring, conn),
            SQL_SUCCESS);
  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}

TEST(ConnectionTest, SQLDriverConnectW_NULLOutput) {
  auto conn = std::make_shared<ODBCHandles>();
  std::wstring defaultConnectionWstring = Utf8ToUtf16(kDefaultConnectionString);
  EXPECT_EQ(ConnectWithNullOutputParams(kDefaultConnectionString,
                                        defaultConnectionWstring, conn, true),
            SQL_SUCCESS);
  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}

void CreateDriverConnection() {
  auto conn = std::make_shared<ODBCHandles>();
  EXPECT_EQ(Connect(kDefaultConnectionString, conn), SQL_SUCCESS);
  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}
TEST(MultipleConnectionTest, SQLDriverConnect) {
  int const number_of_threads = 50;
  std::thread threads[number_of_threads];

  for (int i = 0; i < number_of_threads; i++) {
    threads[i] = std::thread(CreateDriverConnection);
  }

  for (int i = 0; i < number_of_threads; i++) {
    threads[i].join();
  }
}

TEST(ConnectionTest, VerifySQLANSIAttributes) {
  auto conn = std::make_shared<ODBCHandles>();
  SQLRETURN status;
  SQLCHAR data_source[kBufferLength];
  SQLSMALLINT buflen = 0;
  SetAttributes(conn, 30, true);
  StrToChar(reinterpret_cast<char*>(data_source), kDefaultConnectionString);

  status =
      SQLDriverConnectA(conn->hdbc, nullptr, data_source, SQL_NTS,
                        reinterpret_cast<SQLCHAR*>(conn->outdsn),
                        sizeof(conn->outdsn), &buflen, SQL_DRIVER_COMPLETE);
  CheckError(status, "SQLDriverConnectA", conn, true);

  // SQL_ATTR_ANSI_APP is expected to be successful after connection.
  status = SQLSetConnectAttr(conn->hdbc, SQL_ATTR_ANSI_APP,
                             ToSqlPointer(SQL_AA_FALSE), 0);
  EXPECT_EQ(status, SQL_SUCCESS);
}

TEST(ConnectionTest, SQLDriverConnectA) {
  auto conn = std::make_shared<ODBCHandles>();
  EXPECT_EQ(Connect(kDefaultConnectionString, conn, true), SQL_SUCCESS);
  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}

TEST(ConnectionTest, SQLDriverConnect_SQL_DRIVER_COMPLETE) {
  auto conn = std::make_shared<ODBCHandles>();
  SQLHWND window_handle;
  GetWindowHandle(window_handle);

  EXPECT_EQ(ConnectWithPromptWindows(kDefaultConnectionString, conn,
                                     window_handle, SQL_DRIVER_COMPLETE, true),
            SQL_SUCCESS);
  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}

TEST(ConnectionTest, SQLDriverConnect_SQL_DRIVER_COMPLETE_REQUIRED) {
  auto conn = std::make_shared<ODBCHandles>();
  SQLHWND window_handle;
  GetWindowHandle(window_handle);

  EXPECT_EQ(
      ConnectWithPromptWindows(kDefaultConnectionString, conn, window_handle,
                               SQL_DRIVER_COMPLETE_REQUIRED, true),
      SQL_SUCCESS);
  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}

TEST(ConnectionTest, SQLDriverConnect_SQL_DRIVER_NOPROMPT) {
  auto conn = std::make_shared<ODBCHandles>();
  SQLHWND window_handle;
  GetWindowHandle(window_handle);

  EXPECT_EQ(ConnectWithPromptWindows(kDefaultConnectionString, conn,
                                     window_handle, SQL_DRIVER_NOPROMPT, true),
            SQL_SUCCESS);
  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}

TEST(ConnectionTest, SQLDriverConnect_StringDataRightTruncated) {
  auto conn = std::make_shared<ODBCHandles>();

  std::string conn_str = kDefaultConnectionString;
  SQLCHAR in_conn_str[kBufferLength];
  SQLCHAR out_conn_str[10] = {0};
  SQLSMALLINT out_conn_str_len;

  StrToChar((char*)in_conn_str, conn_str);
  google::cloud::odbc_tests::SetAttributes(conn, 30, true);

  auto status =
      SQLDriverConnect(conn->hdbc, nullptr, (SQLCHAR*)in_conn_str, SQL_NTS,
                       (SQLCHAR*)out_conn_str, sizeof(out_conn_str),
                       &out_conn_str_len, SQL_DRIVER_COMPLETE);

  PrintDriverVerName(conn);
  EXPECT_EQ(status, SQL_SUCCESS_WITH_INFO);
  EXPECT_NE(out_conn_str_len, sizeof(out_conn_str));
  CleanupODBCHandles(*conn);
}

TEST(ConnectionTest, SQL_DriverConnect_CaseInsensitive) {
  auto conn = std::make_shared<ODBCHandles>();
  std::vector<std::string> const conn_string = {"dsn=" + GetDefaultDSN(),
                                                "DSN=" + GetDefaultDSN(),
                                                "DsN=" + GetDefaultDSN()};
  for (auto const& conn_str : conn_string) {
    EXPECT_EQ(Connect(conn_str, conn, true), SQL_SUCCESS);
    EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
  }
}

TEST(ConnectionTest, SQLSetConnectAttr_StringWithNullTermInMiddle) {
  SQLCHAR buf[256] = "te\0t";
  SQLINTEGER len = strlen(reinterpret_cast<char*>(buf));
  auto conn = std::make_shared<ODBCHandles>();
  EXPECT_EQ(Connect(kDefaultConnectionString, conn), SQL_SUCCESS);

  auto status = SQLSetConnectAttr(conn->hdbc, SQL_ATTR_CURRENT_CATALOG,
                                  (SQLPOINTER)buf, len);
  CheckError(status, "SQLSetConnectAttr", conn);

  SQLCHAR output[256];
  SQLINTEGER length;
  status = SQLGetConnectAttr(conn->hdbc, SQL_ATTR_CURRENT_CATALOG,
                             (SQLPOINTER)output, 256, &length);
  CheckError(status, "SQLGetConnectAttr", conn);

  std::string actual = reinterpret_cast<char*>(output);
  EXPECT_EQ("te\0t", actual);

  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}

TEST(ConnectionTest, SQLSetConnectAttrA_StringWithNullTermInMiddle) {
  SQLCHAR buf[256] = "te\0t";
  SQLINTEGER len = strlen(reinterpret_cast<char*>(buf));
  auto conn = std::make_shared<ODBCHandles>();
  EXPECT_EQ(Connect(kDefaultConnectionString, conn, true), SQL_SUCCESS);

  auto status = SQLSetConnectAttrA(conn->hdbc, SQL_ATTR_CURRENT_CATALOG,
                                   (SQLPOINTER)buf, len);
  CheckError(status, "SQLSetConnectAttr", conn, true);

  SQLCHAR output[256];
  SQLINTEGER length;
  status = SQLGetConnectAttrA(conn->hdbc, SQL_ATTR_CURRENT_CATALOG,
                              (SQLPOINTER)output, 256, &length);
  CheckError(status, "SQLGetConnectAttr", conn, true);

  std::string actual = reinterpret_cast<char*>(output);
  EXPECT_EQ("te\0t", actual);

  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}

TEST(ConnectionTest, SQLSetConnectAttr_UpdateString) {
  SQLCHAR buf[256] = "test";
  auto conn = std::make_shared<ODBCHandles>();
  EXPECT_EQ(Connect(kDefaultConnectionString, conn), SQL_SUCCESS);

  // As per the spec if valuePtr is a character string data, string length
  // should either the length of the string or SQL_NTS
  // existing is not following the spec and accepts incorrect lengths,
  // Google driver will follow the spec and accept correct lengths.
  auto status = SQLSetConnectAttr(conn->hdbc, SQL_ATTR_CURRENT_CATALOG,
                                  (SQLPOINTER)buf, 4);
  CheckError(status, "SQLSetConnectAttr", conn);

  std::string expected = "test";

  buf[0] = '0';
  std::string buffer = reinterpret_cast<char*>(buf);
  EXPECT_EQ("0est", buffer);

  SQLCHAR output[256];
  SQLINTEGER length;
  status = SQLGetConnectAttr(conn->hdbc, SQL_ATTR_CURRENT_CATALOG,
                             (SQLPOINTER)output, 256, &length);
  CheckError(status, "SQLGetConnectAttr", conn);

  std::string actual = reinterpret_cast<char*>(output);
  // Parity with existing Driver - Original value is retained even though
  // input buf has been modified by the caller.
  EXPECT_EQ(expected, actual);
  EXPECT_EQ(expected.size(), length);

  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}

TEST(ConnectionTest, SQLSetConnectAttrA_UpdateString) {
  SQLCHAR buf[256] = "test";
  auto conn = std::make_shared<ODBCHandles>();
  EXPECT_EQ(Connect(kDefaultConnectionString, conn, true), SQL_SUCCESS);

  // As per the spec if valuePtr is a character string data, string length
  // should either the length of the string or SQL_NTS
  // Existing Driver is not following the spec and accepts incorrect lengths,
  // Google driver will follow the spec and accept correct lengths.
  auto status = SQLSetConnectAttrA(conn->hdbc, SQL_ATTR_CURRENT_CATALOG,
                                   (SQLPOINTER)buf, 4);
  CheckError(status, "SQLSetConnectAttr", conn, true);

  std::string expected = "test";

  buf[0] = '0';
  std::string buffer = reinterpret_cast<char*>(buf);
  EXPECT_EQ("0est", buffer);

  SQLCHAR output[256];
  SQLINTEGER length;
  status = SQLGetConnectAttrA(conn->hdbc, SQL_ATTR_CURRENT_CATALOG,
                              (SQLPOINTER)output, 256, &length);
  CheckError(status, "SQLGetConnectAttr", conn, true);

  std::string actual = reinterpret_cast<char*>(output);
  // Parity with existing Driver - Original value is retained even though
  // input buf has been modified by the caller.
  EXPECT_EQ(expected, actual);
  EXPECT_EQ(expected.size(), length);

  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}

TEST(ConnectionTest, SQLSetConnectAttrW_UpdateString) {
  std::wstring wstr = L"test";
  std::vector<SQLWCHAR> buf(wstr.begin(), wstr.end());
  buf.emplace_back(L'\0');
  auto conn = std::make_shared<ODBCHandles>();
  EXPECT_EQ(Connect(kDefaultConnectionString, conn), SQL_SUCCESS);

  auto status = SQLSetConnectAttrW(conn->hdbc, SQL_ATTR_CURRENT_CATALOG,
                                   (SQLPOINTER)buf.data(), SQL_NTS);
  CheckError(status, "SQLSetConnectAttrW", conn);

  std::string expected = "test";

  buf[0] = '0';
  std::string buffer =
      ConvertSQLWCHARToString(reinterpret_cast<SQLWCHAR*>(buf.data()), SQL_NTS);
  EXPECT_STREQ("0est", buffer.data());

  SQLWCHAR output[256];
  SQLINTEGER length = 0;
  status = SQLGetConnectAttrW(conn->hdbc, SQL_ATTR_CURRENT_CATALOG,
                              (SQLPOINTER)output, 256, &length);
  CheckError(status, "SQLGetConnectAttrW", conn);
  std::string str_out = ConvertSQLWCHARToString(output, SQL_NTS);
  EXPECT_EQ(expected, str_out);

  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}

TEST(ConnectionTest, SQLSetConnectAttr_DeleteString) {
  auto conn = std::make_shared<ODBCHandles>();

  SetAttr(conn);

  SQLCHAR output[256];
  SQLINTEGER length;
  auto status = SQLGetConnectAttr(conn->hdbc, SQL_ATTR_CURRENT_CATALOG,
                                  (SQLPOINTER)output, 256, &length);
  CheckError(status, "SQLGetConnectAttr", conn);

  std::string actual = reinterpret_cast<char*>(output);
  EXPECT_EQ("test", actual);
  EXPECT_EQ(4, length);

  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}

TEST(ConnectionTest, SQLSetConnectAttrA_DeleteString) {
  auto conn = std::make_shared<ODBCHandles>();

  SetAttr(conn, true);

  SQLCHAR output[256];
  SQLINTEGER length;
  auto status = SQLGetConnectAttrA(conn->hdbc, SQL_ATTR_CURRENT_CATALOG,
                                   (SQLPOINTER)output, 256, &length);
  CheckError(status, "SQLGetConnectAttr", conn, true);

  std::string actual = reinterpret_cast<char*>(output);
  EXPECT_EQ("test", actual);
  EXPECT_EQ(4, length);

  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}

TEST(ConnectionTest, SQLSetConnectAttr_Integer) {
  SQLULEN buf = SQL_ASYNC_ENABLE_ON;
  auto conn = std::make_shared<ODBCHandles>();

  EXPECT_EQ(Connect(kDefaultConnectionString, conn), SQL_SUCCESS);

  auto status =
      SQLSetConnectAttr(conn->hdbc, SQL_ATTR_ASYNC_ENABLE, (SQLPOINTER)buf, 4);
  CheckError(status, "SQLSetConnectAttr", conn);

  auto* buf_ptr = &buf;
  *buf_ptr = 222;
  EXPECT_EQ(222, buf);

  SQLULEN output = 0;
  SQLINTEGER len;
  // Spec doesn't say anything about len being null so its upto the driver to
  // implement. Google Driver does not accept nullptr for len.
  status =
      SQLGetConnectAttr(conn->hdbc, SQL_ATTR_ASYNC_ENABLE, &output, 256, &len);
  CheckError(status, "SQLGetConnectAttr", conn);

  // Parity with existing driver - Original value is retained even
  // though input buf has been modified by the caller.
  EXPECT_EQ(SQL_ASYNC_ENABLE_ON, output);

  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}

TEST(ConnectionTest, SQLSetConnectAttrA_Integer) {
  SQLULEN buf = SQL_ASYNC_ENABLE_ON;
  auto conn = std::make_shared<ODBCHandles>();

  EXPECT_EQ(Connect(kDefaultConnectionString, conn, true), SQL_SUCCESS);

  auto status =
      SQLSetConnectAttrA(conn->hdbc, SQL_ATTR_ASYNC_ENABLE, (SQLPOINTER)buf, 4);
  CheckError(status, "SQLSetConnectAttr", conn, true);

  auto* buf_ptr = &buf;
  *buf_ptr = 222;
  EXPECT_EQ(222, buf);

  SQLULEN output = 0;
  SQLINTEGER len;
  // Spec doesn't say anything about len being null so its upto the driver to
  // implement. Google Driver does not accept nullptr for len.
  status =
      SQLGetConnectAttrA(conn->hdbc, SQL_ATTR_ASYNC_ENABLE, &output, 256, &len);
  CheckError(status, "SQLGetConnectAttr", conn, true);

  // Parity with existing driver - Original value is retained even
  // though input buf has been modified by the caller.
  EXPECT_EQ(SQL_ASYNC_ENABLE_ON, output);

  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}

TEST(ConnectionTest, SQLGetConnectAttr_DefaultCatalog) {
  auto conn = std::make_shared<ODBCHandles>();
  EXPECT_EQ(Connect(kDefaultConnectionString, conn), SQL_SUCCESS);

  SQLCHAR output[256];
  SQLINTEGER length;
  auto status = SQLGetConnectAttr(conn->hdbc, SQL_ATTR_CURRENT_CATALOG,
                                  (SQLPOINTER)output, 256, &length);
  CheckError(status, "SQLGetConnectAttr", conn);

  std::string actual = reinterpret_cast<char*>(output);
  EXPECT_EQ(kCatalogName, actual);
  EXPECT_EQ(kCatalogName.size(), length);

  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}

TEST(ConnectionTest, GetDefaultValueForAutocommit) {
  auto conn = std::make_shared<ODBCHandles>();
  EXPECT_EQ(Connect(kDefaultConnectionString, conn), SQL_SUCCESS);

  SQLUINTEGER commit_mode = 0;
  auto status =
      SQLGetConnectAttr(conn->hdbc, SQL_ATTR_AUTOCOMMIT, &commit_mode, 0, NULL);
  CheckError(status, "SQLGetConnectAttr", conn);

  EXPECT_EQ(SQL_AUTOCOMMIT_ON, commit_mode);

  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}
// TODO(b/435322167): External Authentication crash with service account key
TEST(ConnectionTest, DISABLED_FailsForExternalAuthWithServiceAccountJson) {
  std::shared_ptr<ODBCHandles> conn = std::make_shared<ODBCHandles>();
  ASSERT_TRUE(conn != nullptr);

  auto service_account_path =
      GetEnv("CPP_BIGQUERY_ODBC_TEST_SERVICE_ACCOUNT_AUTH_KEY").value_or("");
  ASSERT_FALSE(service_account_path.empty())
      << "CPP_BIGQUERY_ODBC_TEST_SERVICE_ACCOUNT_AUTH_KEY is not set";

  std::string driver_name = GetDriverName();
  std::string conn_str = "DRIVER={" + driver_name +
                         "};"
                         "OAuthMechanism=4;"
                         "KeyFilePath=" +
                         service_account_path + ";";

  EXPECT_EQ(Connect(conn_str, conn, false), SQL_ERROR);
}

#ifdef BQ_DRIVER_INTEGRATION_TESTS
TEST(ConnectionTest, SuccessForExternalAuthWithExternalAccountJson) {
  std::shared_ptr<ODBCHandles> conn = std::make_shared<ODBCHandles>();
  ASSERT_TRUE(conn != nullptr);

  auto external_account_path =
      GetEnv("CPP_BIGQUERY_ODBC_TEST_EXTERNAL_ACCOUNT_AUTH_KEY").value_or("");
  ASSERT_FALSE(external_account_path.empty())
      << "CPP_BIGQUERY_ODBC_TEST_EXTERNAL_ACCOUNT_AUTH_KEY is not set";

  std::string driver_name = GetDriverName();
  std::string conn_str = "DRIVER={" + driver_name +
                         "};"
                         "OAuthMechanism=4;"
                         "KeyFilePath=" +
                         external_account_path + ";";

  EXPECT_EQ(Connect(conn_str, conn, 30, false), SQL_SUCCESS);
  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}

TEST(ConnectionTest, SuccessForExternalAuthWithBYOIDProperties) {
  std::shared_ptr<ODBCHandles> conn = std::make_shared<ODBCHandles>();
  ASSERT_TRUE(conn != nullptr);

  auto external_account_path =
      GetEnv("CPP_BIGQUERY_ODBC_TEST_EXTERNAL_ACCOUNT_AUTH_KEY").value_or("");
  ASSERT_FALSE(external_account_path.empty())
      << "CPP_BIGQUERY_ODBC_TEST_EXTERNAL_ACCOUNT_AUTH_KEY is not set";

  std::ifstream f(external_account_path);
  nlohmann::json credentials = nlohmann::json::parse(f);

  std::string audience = credentials["audience"];
  std::string credential_source = credentials["credential_source"].dump();
  std::string subject_token_type = credentials["subject_token_type"];
  std::string token_url = credentials["token_url"];

  std::string driver_name = GetDriverName();
  std::string conn_str = "DRIVER={" + driver_name + "};" + "OAuthMechanism=4;" +
                         "BYOID_AUDIENCEURL=" + audience + ";" +
                         "BYOID_CREDENTIALSOURCE={" + credential_source + "};" +
                         "BYOID_SUBJECTTOKENTYPE=" + subject_token_type + ";" +
                         "BYOID_TOKENURL=" + token_url + ";";

  EXPECT_EQ(Connect(conn_str, conn, 30, false), SQL_SUCCESS);
  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}

TEST(ConnectionTest, VerifyServiceAccountImpersonationEmail) {
  auto conn = std::make_shared<ODBCHandles>();
  std::string conn_str =
      kDefaultConnectionString +
      ";ServiceAccountImpersonationEmail=" + kImpersonatedAccountEmail;

  SQLRETURN status = Connect(conn_str, conn);
  CheckError(status, "Connect", conn);

  status =
      SQLExecDirect(conn->hstmt, (SQLCHAR*)"SELECT SESSION_USER()", SQL_NTS);
  CheckError(status, "SQLExecDirect", conn);

  status = SQLFetch(conn->hstmt);
  CheckError(status, "SQLFetch", conn);

  char user_email[256] = {};
  SQLLEN indicator = 0;
  status = SQLGetData(conn->hstmt, 1, SQL_C_CHAR, user_email,
                      sizeof(user_email), &indicator);
  CheckError(status, "SQLGetData", conn);
  EXPECT_STREQ(user_email, kImpersonatedAccountEmail.c_str());

  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}

TEST(ConnectionTest, VerifyServiceAccountImpersonationEmailInvalidFails) {
  auto conn = std::make_shared<ODBCHandles>();
  std::string const invalid_email =
      "invalid-sa@invalid-project.iam.gserviceaccount.com";
  std::string conn_str = kDefaultConnectionString +
                         ";ServiceAccountImpersonationEmail=" + invalid_email;

  SetAttributes(conn, 30, false);
  SQLCHAR out_conn_str[kBufferLength] = {0};
  SQLSMALLINT out_conn_str_len = 0;
  SQLRETURN status = SQLDriverConnect(
      conn->hdbc, nullptr,
      reinterpret_cast<SQLCHAR*>(const_cast<char*>(conn_str.c_str())), SQL_NTS,
      out_conn_str, sizeof(out_conn_str), &out_conn_str_len,
      SQL_DRIVER_COMPLETE);

  EXPECT_EQ(status, SQL_ERROR);
  CheckDiagnosticRecord(conn->hdbc, "HY000", 404, invalid_email);
  CleanupODBCHandles(*conn);
}

TEST(ConnectionTest, VerifyQuotaProjectId) {
  auto conn = std::make_shared<ODBCHandles>();
  std::string connectionstring =
      kDefaultConnectionString + ";QuotaProjectId=bigquery-devtools-drivers;";

  EXPECT_EQ(Connect(connectionstring, conn), SQL_SUCCESS);

  SQLRETURN status = SQLExecDirect(conn->hstmt, (SQLCHAR*)"SELECT 1", SQL_NTS);
  CheckError(status, "SQLExecDirect", conn);

  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}

TEST(ConnectionTest, VerifyQuotaProjectIdInvalidFails) {
  auto conn = std::make_shared<ODBCHandles>();
  std::string connectionstring =
      kDefaultConnectionString + ";QuotaProjectId=invalid-quota-project-12345;";

  EXPECT_EQ(Connect(connectionstring, conn), SQL_SUCCESS);

  SQLRETURN status = SQLExecDirect(conn->hstmt, (SQLCHAR*)"SELECT 1", SQL_NTS);
  EXPECT_EQ(status, SQL_ERROR);

  SQLCHAR sqlstate[6];
  SQLINTEGER native_error;
  SQLCHAR message_text[256];
  SQLSMALLINT text_length;
  SQLRETURN diag_status =
      SQLGetDiagRec(SQL_HANDLE_STMT, conn->hstmt, 1, sqlstate, &native_error,
                    message_text, sizeof(message_text), &text_length);
  if (diag_status == SQL_SUCCESS || diag_status == SQL_SUCCESS_WITH_INFO) {
    EXPECT_THAT(
        reinterpret_cast<char*>(message_text),
        HasSubstr("Project 'projects/invalid-quota-project-12345' not found"));
  }

  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}
#endif  // BQ_DRIVER_INTEGRATION_TESTS

TEST(ConnectionTest, SQLConnect_WithDSN) {
  auto conn = std::make_shared<ODBCHandles>();
  EXPECT_EQ(ConnectDsn(kDefaultDataSource, conn), SQL_SUCCESS);
  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}

TEST(ConnectionTest, SQLConnectW_WithDSN) {
  auto conn = std::make_shared<ODBCHandles>();
  std::wstring defaultConnectionWstring = Utf8ToUtf16(kDefaultDataSource);
  EXPECT_EQ(Connect(defaultConnectionWstring, conn), SQL_SUCCESS);
  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}

TEST(ConnectionTest, SQLConnectA_WithDSN) {
  auto conn = std::make_shared<ODBCHandles>();
  EXPECT_EQ(ConnectDsn(kDefaultDataSource, conn, true), SQL_SUCCESS);
  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}

void CheckDiagnosticRecord(SQLHDBC hdbc, std::string const& expected_sqlstate,
                           int expected_error_code,
                           std::string const& expected_message_regex) {
  SQLCHAR sqlstate[6];
  SQLCHAR buf[kBufferLength];
  SQLINTEGER native_error;
  SQLSMALLINT string_length_ptr;

  SQLRETURN diag_status =
      SQLGetDiagRec(SQL_HANDLE_DBC, hdbc, 1, sqlstate, &native_error, buf,
                    kBufferLength, &string_length_ptr);

  ASSERT_EQ(diag_status, SQL_SUCCESS);
  EXPECT_STREQ(reinterpret_cast<char*>(sqlstate), expected_sqlstate.c_str());
  EXPECT_EQ(native_error, expected_error_code);

  std::string actual_message(reinterpret_cast<char*>(buf));
  EXPECT_EQ(actual_message.size(), string_length_ptr);

  if (kIsBqDriver) {
    EXPECT_THAT(actual_message, ::testing::HasSubstr(expected_message_regex));
  } else {
    EXPECT_THAT(actual_message,
                ::testing::ContainsRegex(expected_message_regex));
  }
}

TEST(ConnectionTest, SQLBrowseConnect_WithDsn) {
  auto conn = std::make_shared<ODBCHandles>();

  SQLCHAR in_conn_str[kBufferLength];
  SQLSMALLINT out_conn_str_len;
  SQLCHAR out_conn_str[kBufferLength] = {0};

  StrToChar((char*)in_conn_str, kDefaultConnectionString);
  SetAttributes(conn, 30);

  auto status = SQLBrowseConnect(conn->hdbc, (SQLCHAR*)in_conn_str,
                                 sizeof(in_conn_str), (SQLCHAR*)out_conn_str,
                                 sizeof(out_conn_str), &out_conn_str_len);

  PrintDriverVerName(conn);
  EXPECT_EQ(status, SQL_SUCCESS);

  std::string const expected_conn_out_str = kDefaultConnectionString + ";";
  std::string res_out_conn_str(reinterpret_cast<char const*>(out_conn_str));

  if (kIsBqDriver) {
    EXPECT_THAT(res_out_conn_str, HasSubstr(expected_conn_out_str));
    EXPECT_GT(out_conn_str_len, expected_conn_out_str.size());
  } else {
    EXPECT_EQ(res_out_conn_str, expected_conn_out_str);
    EXPECT_EQ(out_conn_str_len, expected_conn_out_str.size());
  }
  CleanupODBCHandles(*conn);
}

TEST(ConnectionTest, SQLBrowseConnect_OverrideDSNWithConnStrValues) {
  auto conn = std::make_shared<ODBCHandles>();
  std::string key_path =
      GetEnv("CPP_BIGQUERY_ODBC_TEST_SERVICE_ACCOUNT_AUTH_KEY").value_or("");
  std::string const conn_str =
      kDefaultConnectionString + ";KeyFilePath=" + key_path + ";";

  SQLCHAR in_conn_str[kBufferLength];
  SQLSMALLINT out_conn_str_len;
  SQLCHAR out_conn_str[kBufferLength] = {0};

  StrToChar((char*)in_conn_str, conn_str);
  SetAttributes(conn, 30);

  auto status = SQLBrowseConnect(conn->hdbc, (SQLCHAR*)in_conn_str,
                                 sizeof(in_conn_str), (SQLCHAR*)out_conn_str,
                                 sizeof(out_conn_str), &out_conn_str_len);
  PrintDriverVerName(conn);
  EXPECT_EQ(status, SQL_SUCCESS);

  std::string const expected_conn_out_str =
      kDefaultConnectionString + ";KeyFilePath=" + key_path + ";";
  std::string res_out_conn_str(reinterpret_cast<char const*>(out_conn_str));

  if (kIsBqDriver) {
    EXPECT_THAT(res_out_conn_str, HasSubstr(kDefaultConnectionString));
    EXPECT_GT(out_conn_str_len, kDefaultConnectionString.size());
  } else {
    EXPECT_EQ(res_out_conn_str, expected_conn_out_str);
    EXPECT_EQ(out_conn_str_len, expected_conn_out_str.size());
  }
  CleanupODBCHandles(*conn);
}

TEST(ConnectionTest, SQLBrowseConnect_WithDriver) {
  auto conn = std::make_shared<ODBCHandles>();
  std::string key_path =
      GetEnv("CPP_BIGQUERY_ODBC_TEST_SERVICE_ACCOUNT_AUTH_KEY").value_or("");
  std::string driver_name = GetDriverName();
  std::string conn_str =
      "DRIVER={" + driver_name +
      "};Catalog=bigquery-devtools-drivers;KeyFilePath=" + key_path +
      ";OAuthMechanism=0;";

  SQLCHAR in_conn_str[kBufferLength];
  SQLSMALLINT out_conn_str_len;
  SQLCHAR out_conn_str[kBufferLength] = {0};

  StrToChar((char*)in_conn_str, conn_str);
  SetAttributes(conn, 30);

  auto status = SQLBrowseConnect(conn->hdbc, (SQLCHAR*)in_conn_str,
                                 sizeof(in_conn_str), (SQLCHAR*)out_conn_str,
                                 sizeof(out_conn_str), &out_conn_str_len);

  PrintDriverVerName(conn);
  EXPECT_EQ(status, SQL_SUCCESS);

  std::string const expected_out_conn_str =
      "DRIVER={" + driver_name +
      "};Catalog=bigquery-devtools-drivers;KeyFilePath=" + key_path +
      ";OAuthMechanism=0;";
  std::string res_out_conn_str(reinterpret_cast<char const*>(out_conn_str));

  EXPECT_EQ(res_out_conn_str, expected_out_conn_str);
  EXPECT_EQ(sizeof(res_out_conn_str), sizeof(expected_out_conn_str));
  EXPECT_EQ(out_conn_str_len, expected_out_conn_str.size());
  CleanupODBCHandles(*conn);
}

TEST(ConnectionTest, SQLBrowseConnect_SQL_NEED_DATA) {
  auto conn = std::make_shared<ODBCHandles>();
  std::string const driver_name = GetDriverName();
  std::string conn_str = "DRIVER={" + driver_name + "}";

  SQLCHAR in_conn_str[kBufferLength];
  SQLSMALLINT out_conn_str_len;
  SQLCHAR out_conn_str[1024] = {0};

  StrToChar((char*)in_conn_str, conn_str);
  SetAttributes(conn, 30);

  auto status = SQLBrowseConnect(conn->hdbc, (SQLCHAR*)in_conn_str,
                                 sizeof(in_conn_str), (SQLCHAR*)out_conn_str,
                                 sizeof(out_conn_str), &out_conn_str_len);
  EXPECT_EQ(status, SQL_NEED_DATA);

  std::string res_out_conn_str(reinterpret_cast<char const*>(out_conn_str));

  // TODO(b/383449326): Add other connection attributes for the connection
  // TODO(b/402379435): Remove if (kIsBqDriver) after driver manager enabled.
  if (kIsBqDriver) {
    EXPECT_GE(out_conn_str_len, res_out_conn_str.size());
  } else {
    EXPECT_GT(out_conn_str_len, res_out_conn_str.size());
  }
// TODO(b/382204927): SQLBrowseConnect API out_conn_str come as empty(Linux)
#ifdef _WIN32
  EXPECT_THAT(res_out_conn_str,
              HasSubstr("Catalog:Catalog=?;OAuthMechanism:OAuthMechanism=?"));
#endif  // _WIN32
  CleanupODBCHandles(*conn);
}

TEST(ConnectionTest, SQLBrowseConnect_StringDataRightTruncated) {
  auto conn = std::make_shared<ODBCHandles>();

  SQLCHAR in_conn_str[kBufferLength];
  SQLSMALLINT out_conn_str_len;
  SQLCHAR out_conn_str[10] = {0};

  StrToChar((char*)in_conn_str, kDefaultConnectionString);
  SetAttributes(conn, 30);

  auto status = SQLBrowseConnect(conn->hdbc, (SQLCHAR*)in_conn_str,
                                 sizeof(in_conn_str), (SQLCHAR*)out_conn_str,
                                 sizeof(out_conn_str), &out_conn_str_len);
  EXPECT_EQ(status, SQL_NEED_DATA);
#ifndef BQ_DRIVER_INTEGRATION_TESTS
  std::string const expected_conn_out_str = "DSN=Sampl";
#else
  std::string const expected_conn_out_str = "DSN=BigQu";
#endif
  EXPECT_NE(out_conn_str_len, expected_conn_out_str.size());

// TODO(b/382204927): SQLBrowseConnect API out_conn_str come as empty(Linux)
#ifdef _WIN32
  std::string res_out_conn_str(reinterpret_cast<char const*>(out_conn_str));

  EXPECT_EQ(res_out_conn_str, expected_conn_out_str);
  EXPECT_NE(out_conn_str_len, expected_conn_out_str.size());
  EXPECT_EQ(res_out_conn_str.size(), expected_conn_out_str.size());
#endif  // _WIN32
  CleanupODBCHandles(*conn);
}

TEST(ConnectionTest, SQLBrowseConnect_InvalidConnectionAttribute) {
  auto conn = std::make_shared<ODBCHandles>();
  std::string const driver_name = GetDriverName();
  std::string conn_str =
      "DRIVER={" + driver_name + "};" + "InvalidKey=InvalidValue;";

  SQLCHAR in_conn_str[kBufferLength];
  SQLSMALLINT out_conn_str_len;
  SQLCHAR out_conn_str[kBufferLength] = {0};

  StrToChar((char*)in_conn_str, conn_str);
  SetAttributes(conn, 30);

  auto status = SQLBrowseConnect(conn->hdbc, (SQLCHAR*)in_conn_str,
                                 sizeof(in_conn_str), (SQLCHAR*)out_conn_str,
                                 sizeof(out_conn_str), &out_conn_str_len);
  std::string res_out_conn_str(reinterpret_cast<char const*>(out_conn_str));

  // TODO(b/383449326): Add other connection attributes for the connection
  if (kIsBqDriver) {
    EXPECT_EQ(status, SQL_ERROR);
  } else {
    EXPECT_EQ(status, SQL_NEED_DATA);
    EXPECT_GT(out_conn_str_len, res_out_conn_str.size());

// TODO(b/382204927): SQLBrowseConnect API out_conn_str come as empty(Linux)
#ifdef _WIN32
    EXPECT_THAT(res_out_conn_str,
                HasSubstr("Catalog:Catalog=?;OAuthMechanism:OAuthMechanism=?"));
#endif  // _WIN32
  }
  // Pass `false` to indicate that the Driver Manager (DM) will automatically
  // free the environment handle when the last connection handle is released.
  CleanupODBCHandles(*conn, false);
}

TEST(ConnectionTest, SQLBrowseConnect_InvalidConnectionString) {
  auto conn = std::make_shared<ODBCHandles>();
  std::string const driver_name = GetDriverName();
  std::string conn_str = "DRIVER={" + driver_name + "}";

  SQLCHAR in_conn_str[kBufferLength];
  SQLCHAR out_conn_str[kBufferLength] = {0};
  SQLSMALLINT out_conn_str_len;

  StrToChar((char*)in_conn_str, conn_str);
  SetAttributes(conn, 30);

  auto status = SQLBrowseConnect(conn->hdbc, (SQLCHAR*)in_conn_str,
                                 sizeof(in_conn_str), (SQLCHAR*)out_conn_str,
                                 sizeof(out_conn_str), &out_conn_str_len);

  EXPECT_EQ(status, SQL_NEED_DATA);
  std::string res_out_conn_str(reinterpret_cast<char const*>(out_conn_str));

// TODO(b/382204927): SQLBrowseConnect API out_conn_str come as empty(Linux)
#ifdef _WIN32
  EXPECT_THAT(res_out_conn_str,
              HasSubstr("Catalog:Catalog=?;OAuthMechanism:OAuthMechanism=?"));
#endif  // _WIN32

  conn_str = "InvalidString";
  StrToChar((char*)in_conn_str, conn_str);

  status = SQLBrowseConnect(conn->hdbc, (SQLCHAR*)in_conn_str,
                            sizeof(in_conn_str), (SQLCHAR*)out_conn_str,
                            sizeof(out_conn_str), &out_conn_str_len);
  EXPECT_EQ(status, SQL_ERROR);
  // TODO(b/382204927): SQLBrowseConnect API out_conn_str come as empty(Linux)
#ifdef _WIN32
  EXPECT_THAT(res_out_conn_str,
              HasSubstr("Catalog:Catalog=?;OAuthMechanism:OAuthMechanism=?"));
#endif  // _WIN32

  // TODO(b/383449326): Add other connection attributes for the connection
  // TODO(b/402379435): Remove if (kIsBqDriver) after driver manager enabled.
  if (kIsBqDriver) {
    EXPECT_GE(out_conn_str_len, res_out_conn_str.size());
    CheckDiagnosticRecord(
        conn->hdbc, "HY000", 0,
        "[Google][ODBC BigQuery Driver] Invalid Connection String");
  } else {
    EXPECT_GT(out_conn_str_len, res_out_conn_str.size());
    CheckDiagnosticRecord(conn->hdbc, "HY000", 50404,
                          "Invalid connection string");
  }
  CleanupODBCHandles(*conn);
}

TEST(ConnectionTest, SQLBrowseConnect_NonRequestedConnAttribute) {
  auto conn = std::make_shared<ODBCHandles>();
  std::string const driver_name = GetDriverName();
  std::string key_path =
      GetEnv("CPP_BIGQUERY_ODBC_TEST_SERVICE_ACCOUNT_AUTH_KEY").value_or("");

  std::string conn_str = "DRIVER={" + driver_name + "}";

  SQLCHAR in_conn_str[kBufferLength];
  SQLCHAR out_conn_str[kBufferLength] = {0};
  SQLSMALLINT out_conn_str_len;

  StrToChar((char*)in_conn_str, conn_str);
  SetAttributes(conn, 30);

  auto status = SQLBrowseConnect(conn->hdbc, (SQLCHAR*)in_conn_str,
                                 sizeof(in_conn_str), (SQLCHAR*)out_conn_str,
                                 sizeof(out_conn_str), &out_conn_str_len);

  EXPECT_EQ(status, SQL_NEED_DATA);
  std::string res_out_conn_str(reinterpret_cast<char const*>(out_conn_str));

// TODO(b/382204927): SQLBrowseConnect API out_conn_str come as empty(Linux)
#ifdef _WIN32
  EXPECT_THAT(res_out_conn_str,
              HasSubstr("Catalog:Catalog=?;OAuthMechanism:OAuthMechanism=?"));
#endif  // _WIN32

  conn_str =
      ";Catalog=bigquery-devtools-drivers;OAuthMechanism=0;"
      "InvalidKey=InvalidValue;";
  StrToChar((char*)in_conn_str, conn_str);

  status = SQLBrowseConnect(conn->hdbc, (SQLCHAR*)in_conn_str,
                            sizeof(in_conn_str), (SQLCHAR*)out_conn_str,
                            sizeof(out_conn_str), &out_conn_str_len);
  EXPECT_EQ(status, SQL_ERROR);

// TODO(b/382204927): SQLBrowseConnect API out_conn_str come as empty(Linux)
#ifdef _WIN32
  EXPECT_THAT(res_out_conn_str, HasSubstr("Catalog:Catalog=?"));
#endif  // _WIN32

  // TODO(b/383449326): Add other connection attributes for the connection
  // TODO(b/402379435): Remove if (kIsBqDriver) after driver manager enabled.
  if (kIsBqDriver) {
    EXPECT_GE(out_conn_str_len, res_out_conn_str.size());
    CheckDiagnosticRecord(conn->hdbc, "HY000", 0,
                          "[Google][ODBC BigQuery Driver] Connection Error: "
                          "Non Requested connection attribute");
  } else {
    EXPECT_GT(out_conn_str_len, res_out_conn_str.size());
    CheckDiagnosticRecord(
        conn->hdbc, "HY000", 11600,
        "Connection Error: Non Requested connection attribute");
  }
  CleanupODBCHandles(*conn);
}

TEST(ConnectionTest, SQLBrowseConnect_ConnectionAttributeExists) {
  auto conn = std::make_shared<ODBCHandles>();
  std::string const driver_name = GetDriverName();
  std::string conn_str = "DRIVER={" + driver_name +
                         "};"
                         "Catalog=bigquery-devtools-drivers";

  SQLCHAR in_conn_str[kBufferLength];
  SQLCHAR out_conn_str[kBufferLength] = {0};
  SQLSMALLINT out_conn_str_len;

  StrToChar((char*)in_conn_str, conn_str);
  google::cloud::odbc_tests::SetAttributes(conn, 30);

  auto status = SQLBrowseConnect(conn->hdbc, (SQLCHAR*)in_conn_str,
                                 sizeof(in_conn_str), (SQLCHAR*)out_conn_str,
                                 sizeof(out_conn_str), &out_conn_str_len);

  EXPECT_EQ(status, SQL_NEED_DATA);

  // TODO(b/382204927): SQLBrowseConnect API out_conn_str come as empty(Linux)
#ifdef _WIN32
  std::string res_out_conn_str(reinterpret_cast<char const*>(out_conn_str));
  EXPECT_THAT(res_out_conn_str, HasSubstr("OAuthMechanism:OAuthMechanism=?;"));
#endif  // _WIN32

  conn_str = "Catalog=bigquery-devtools-drivers;OAuthMechanism=0;";

  StrToChar((char*)in_conn_str, conn_str);
  status = SQLBrowseConnect(conn->hdbc, (SQLCHAR*)in_conn_str,
                            sizeof(in_conn_str), (SQLCHAR*)out_conn_str,
                            sizeof(out_conn_str), &out_conn_str_len);
  EXPECT_EQ(status, SQL_ERROR);

  if (kIsBqDriver) {
    CheckDiagnosticRecord(conn->hdbc, "HY000", 0,
                          "[Google][ODBC BigQuery Driver] Connection Error: "
                          "Connection Attribute 'CATALOG' already found!");
  } else {
    CheckDiagnosticRecord(
        conn->hdbc, "HY000", 11590,
        "Connection Error: Connection Attribute Catalog already found!");
  }
  CleanupODBCHandles(*conn);
}

TEST(DriverInfoTest, SQLGetInfo) {
  auto conn = std::make_shared<ODBCHandles>();
  EXPECT_EQ(Connect(kDefaultConnectionString, conn), SQL_SUCCESS);
  EXPECT_EQ(GetDriverInfo(conn), SQL_SUCCESS);
  VerifyDriverInfo(conn);
  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}

TEST(DriverInfoTest, SQLGetInfoA) {
  auto conn = std::make_shared<ODBCHandles>();
  EXPECT_EQ(Connect(kDefaultConnectionString, conn, true), SQL_SUCCESS);
  EXPECT_EQ(GetDriverInfo(conn, true), SQL_SUCCESS);
  VerifyDriverInfo(conn);
  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}

// This test is temporarily disabled till this issue is fixed for the driver
TEST(ConnectionTest, DISABLED_SQLGetConnectAttr) {
  srand(time(NULL));
  int timeout = (rand() % 30) + 1;
  SQLUINTEGER timeout_ret;
  auto conn = std::make_shared<ODBCHandles>();
  EXPECT_EQ(ConnectDsn(kDefaultDataSource, conn, timeout), SQL_SUCCESS);

  auto status = SQLGetConnectAttr(conn->hdbc, SQL_ATTR_CONNECTION_TIMEOUT,
                                  (SQLPOINTER)&timeout_ret,
                                  (SQLINTEGER)sizeof(timeout_ret), NULL);
  CheckError(status, "SQLGetConnectAttr", conn);
  EXPECT_EQ(timeout, timeout_ret);

  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}

TEST(ConnectionTest, validate_columnSize_with_DefaultStringColumnLength) {
  SQLRETURN status;

  // Setup connection handle
  auto conn = std::make_shared<ODBCHandles>();
  std::string connectionstring =
      kDefaultConnectionString + "; DefaultStringColumnLength=4;";

  // Connect
  EXPECT_EQ(Connect(connectionstring, conn), SQL_SUCCESS);

  // Execute SELECT with a literal
  status = SQLExecDirect(conn->hstmt,
                         (SQLCHAR*)"SELECT 'Hello, BigQuery!' AS my_string, ['Hello', 'BigQuery', '!'] AS my_array, 123 AS my_int",
                         SQL_NTS);
  CheckError(status, "SQLExecDirect(ASSERT)", conn);

  // Describe the column
  SQLCHAR column_name[256];
  SQLSMALLINT name_length = 0;
  SQLSMALLINT data_type = 0;
  SQLULEN column_size = 0;
  SQLSMALLINT decimal_digits = 0;
  SQLSMALLINT nullable = 0;

  status = SQLDescribeCol(conn->hstmt,
                          1,  // Column index 1
                          column_name, sizeof(column_name), &name_length,
                          &data_type, &column_size, &decimal_digits, &nullable);
  CheckError(status, "SQLDescribeCol(ASSERT)", conn);

  EXPECT_STREQ((char const*)column_name, "my_string");
  EXPECT_TRUE(data_type == SQL_VARCHAR || data_type == SQL_CHAR);
  EXPECT_EQ(column_size, 4);

  status = SQLDescribeCol(conn->hstmt,
                          2,  // Column index 2
                          column_name, sizeof(column_name), &name_length,
                          &data_type, &column_size, &decimal_digits, &nullable);
  CheckError(status, "SQLDescribeCol(ASSERT)", conn);

  EXPECT_STREQ((char const*)column_name, "my_array");
  EXPECT_TRUE(data_type == SQL_VARCHAR || data_type == SQL_CHAR);
  EXPECT_EQ(column_size, 4);

  status = SQLDescribeCol(conn->hstmt,
                          3,  // Column index 1
                          column_name, sizeof(column_name), &name_length,
                          &data_type, &column_size, &decimal_digits, &nullable);
  CheckError(status, "SQLDescribeCol(ASSERT)", conn);

  EXPECT_STREQ((char const*)column_name, "my_int");
  EXPECT_FALSE(data_type == SQL_VARCHAR || data_type == SQL_CHAR);
  EXPECT_EQ(column_size, 19);

  // Clean up
  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}

#ifndef _WIN32
TEST(SQLDisconnect, CheckAllHandlesAreFreed) {
  auto conn = std::make_shared<ODBCHandles>();
  EXPECT_EQ(Connect(kDefaultConnectionString, conn, true), SQL_SUCCESS);
  auto status = SQLAllocHandle(SQL_HANDLE_DESC, conn->hdbc, &conn->ard);
  CheckError(status, "SQLAllocHandle(SQL_HANDLE_DESC)", conn);

  status = SQLDisconnect(conn->hdbc);
  CheckError(status, "SQLDisconnect", conn);

  // Check that statement handle is freed
  SQLULEN metadata_id_stmt;
  status = SQLGetStmtAttr(conn->hstmt, SQL_ATTR_METADATA_ID, &metadata_id_stmt,
                          0, NULL);
  EXPECT_EQ(SQL_INVALID_HANDLE, status);
  // Check connection handle is disconnected
  status = SQLAllocHandle(SQL_HANDLE_STMT, conn->hdbc, &conn->hstmt);
  EXPECT_EQ(SQL_ERROR, status);

  status = SQLFreeHandle(SQL_HANDLE_DBC, conn->hdbc);
  CheckError(status, "SQLFreeHandle(SQL_HANDLE_DBC)", conn);
  status = SQLFreeHandle(SQL_HANDLE_ENV, conn->henv);
  CheckError(status, "SQLFreeHandle(SQL_HANDLE_ENV)", conn);
}

#endif  //_WIN32

// This test should not be run for existing Driver since different values are
// returned between google and existing for some information types. For more
// details please look at design doc: http://goto.google.com/sql-get-info-design

#ifdef BQ_DRIVER_INTEGRATION_TESTS

TEST(BQDriverTest, SQLGetInfo) {
  auto conn = std::make_shared<ODBCHandles>();
  EXPECT_EQ(Connect(kDefaultConnectionString, conn), SQL_SUCCESS);
  AssertBQDriverSQLGetInfo(conn);
  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}

TEST(BQDriverTest, SQLGetInfoA) {
  auto conn = std::make_shared<ODBCHandles>();
  EXPECT_EQ(Connect(kDefaultConnectionString, conn, true), SQL_SUCCESS);
  AssertBQDriverSQLGetInfo(conn);
  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}

TEST(BQDriverTest, SQLGetFunctions_ODBC3_AllSupported) {
  auto conn = std::make_shared<ODBCHandles>();
  SQLUSMALLINT odbc3_fns[SQL_API_ODBC3_ALL_FUNCTIONS_SIZE];

  EXPECT_EQ(Connect(kDefaultConnectionString, conn), SQL_SUCCESS);
  EXPECT_EQ(
      SQL_SUCCESS,
      SQLGetFunctions(conn->hdbc, SQL_API_ODBC3_ALL_FUNCTIONS, odbc3_fns));
  AssertSupportedFnsODBC3(odbc3_fns);
  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}

TEST(BQDriverTest, SQLGetFunctions_ODBC3_AllUnSupported) {
  auto conn = std::make_shared<ODBCHandles>();
  SQLUSMALLINT odbc3_fns[SQL_API_ODBC3_ALL_FUNCTIONS_SIZE];

  EXPECT_EQ(Connect(kDefaultConnectionString, conn), SQL_SUCCESS);
  EXPECT_EQ(
      SQL_SUCCESS,
      SQLGetFunctions(conn->hdbc, SQL_API_ODBC3_ALL_FUNCTIONS, odbc3_fns));
  EXPECT_EQ(SQL_FALSE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLBULKOPERATIONS));
  EXPECT_EQ(SQL_FALSE, SQL_FUNC_EXISTS(odbc3_fns, SQL_API_SQLSETPOS));
  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}

TEST(BQDriverTest, SQLGetFunctions_ODBC3_FunctionIdSupported) {
  auto conn = std::make_shared<ODBCHandles>();
  SQLUSMALLINT supported;

  EXPECT_EQ(Connect(kDefaultConnectionString, conn), SQL_SUCCESS);
  EXPECT_EQ(SQL_SUCCESS,
            SQLGetFunctions(conn->hdbc, SQL_API_SQLMORERESULTS, &supported));

  EXPECT_EQ(SQL_TRUE, supported);
  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}

TEST(BQDriverTest, SQLGetFunctions_ODBC3_FunctionIdNotSupported) {
  auto conn = std::make_shared<ODBCHandles>();
  SQLUSMALLINT supported;

  EXPECT_EQ(Connect(kDefaultConnectionString, conn), SQL_SUCCESS);
  EXPECT_EQ(SQL_SUCCESS,
            SQLGetFunctions(conn->hdbc, SQL_API_SQLSETPOS, &supported));

  EXPECT_EQ(SQL_FALSE, supported);
  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}

// Negative test cases for SQLGetFunctions

TEST(SQLGetFunctionsInternal, SQLGetFunctions_ODBC2_NullConnectionHandle) {
  auto conn = std::make_shared<ODBCHandles>();
  SQLUSMALLINT odbc2_fns[100];

  EXPECT_EQ(Connect(kDefaultConnectionString, conn), SQL_SUCCESS);
  EXPECT_EQ(SQL_INVALID_HANDLE,
            SQLGetFunctions(nullptr, SQL_API_ALL_FUNCTIONS, odbc2_fns));
  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}

TEST(SQLGetFunctionsInternal, SQLGetFunctions_ODBC3_NullConnectionHandle) {
  auto conn = std::make_shared<ODBCHandles>();
  SQLUSMALLINT odbc3_fns[SQL_API_ODBC3_ALL_FUNCTIONS_SIZE];

  EXPECT_EQ(Connect(kDefaultConnectionString, conn), SQL_SUCCESS);
  EXPECT_EQ(SQL_INVALID_HANDLE,
            SQLGetFunctions(nullptr, SQL_API_ODBC3_ALL_FUNCTIONS, odbc3_fns));
  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
}

TEST(SQLGetFunctionsInternal,
     SQLGetFunctions_ODBC2_InvalidConnectionHandleType) {
  auto conn = std::make_shared<ODBCHandles>();
  EXPECT_EQ(SQL_INVALID_HANDLE,
            SQLGetFunctions(conn->henv, SQL_API_ALL_FUNCTIONS, nullptr));
}

TEST(SQLGetFunctionsInternal,
     SQLGetFunctions_ODBC3_InvalidConnectionHandleType) {
  auto conn = std::make_shared<ODBCHandles>();
  EXPECT_EQ(SQL_INVALID_HANDLE,
            SQLGetFunctions(conn->henv, SQL_API_ODBC3_ALL_FUNCTIONS, nullptr));
}

TEST(SQLGetFunctionsInternal,
     SQLGetFunctions_ODBC3_ConnectionHandleNotConnectedFailure) {
  auto conn = std::make_shared<ODBCHandles>();
  EXPECT_EQ(SQL_INVALID_HANDLE,
            SQLGetFunctions(conn->hdbc, SQL_API_ODBC3_ALL_FUNCTIONS, nullptr));
}

TEST(ConnectionTest, CheckTraceLogFileExist) {
#ifdef _WIN32
  std::string log_path = "C:\\b";
  std::string log_file = log_path + "\\odbcdriverforbigquery_0.log";
#else
  std::string log_path = "/tmp";
  std::string log_file = log_path + "/odbcdriverforbigquery_0.log";
#endif  // _WIN32
  auto conn_str =
      kDefaultConnectionString + ";LogPath=" + log_path + ";LogLevel=3";

  auto conn = std::make_shared<ODBCHandles>();
  EXPECT_EQ(Connect(conn_str, conn), SQL_SUCCESS);
  EXPECT_EQ(Disconnect(conn), SQL_SUCCESS);
  // check if the file exists
  EXPECT_TRUE(std::filesystem::exists(log_file));
  // Check that the file is not empty
  std::ifstream file(log_file, std::ios::binary);
  ASSERT_TRUE(file.is_open());

  file.seekg(0, std::ios::end);
  auto size = file.tellg();
  EXPECT_GT(size, 0);

  file.seekg(0, std::ios::beg);
  // Read the file contents
  std::string content((std::istreambuf_iterator<char>(file)),
                      std::istreambuf_iterator<char>());
  file.close();
  auto contains_text =
      content.find("SQLFreeHandle:: DBC handle is free") != std::string::npos;
  EXPECT_TRUE(contains_text);
}

#if !defined(_WIN32)
#include <sys/wait.h>
#include <dlfcn.h>
#include <filesystem>
#include <fstream>
#include <unistd.h>

static std::string FindDriverPath() {
  if (char const* env_driver = std::getenv("GOOGLE_ODBC_DRIVER_PATH")) {
    if (env_driver[0] != '\0' && std::filesystem::exists(env_driver)) {
      return env_driver;
    }
  }
  if (char const* odbc_ini = std::getenv("ODBCINI")) {
    std::ifstream file(odbc_ini);
    std::string line;
    while (std::getline(file, line)) {
      auto pos = line.find("Driver");
      if (pos != std::string::npos) {
        auto eq = line.find('=', pos);
        if (eq != std::string::npos) {
          std::string path = line.substr(eq + 1);
          path.erase(0, path.find_first_not_of(" \t\r\n"));
          path.erase(path.find_last_not_of(" \t\r\n") + 1);
          if (!path.empty() && std::filesystem::exists(path)) {
            return path;
          }
        }
      }
    }
  }
  return "libgoogle_cloud_odbc_bq_driver.so";
}

// Verifies that the BigQuery ODBC driver correctly handles UTF-16LE wire
// encoding for SQLWCHAR buffers when WcharEncoding=UTF-16LE is set in
// googlebigqueryodbc.ini.
//
// Background:
// On non-Windows platforms (Linux/macOS), the driver is typically compiled
// against iODBC headers where sizeof(SQLWCHAR) == 4. However, certain calling
// applications and internal ODBC managers (e.g., SAP HANA) use a 2-byte
// SQLWCHAR (UTF-16LE) wire format and directly invoke the driver's exported
// Unicode APIs without Driver Manager translation.
//
// Note on DriverUnicodeType vs. dlopen:
// While unixODBC supports a 'DriverUnicodeType=1' setting in odbcinst.ini to
// negotiate 2-byte UTF-16 wire format, it is specific to unixODBC and is
// ignored by iODBC and by direct driver loaders like SAP HANA. Testing via
// direct dlopen/dlsym ensures the test accurately replicates the real-world
// direct caller scenario across all CI environments (both iODBC and unixODBC).
//
// This test directly dlopens the driver shared library and calls
// SQLDriverConnectW using a 2-byte UTF-16LE connection string buffer to
// validate:
//   1. Default mode (WcharEncoding empty): The driver treats SQLWCHAR as 4-byte
//      and fails to parse the 2-byte buffer.
//   2. UTF-16LE override mode (WcharEncoding=UTF-16LE): The driver successfully
//      decodes the 2-byte UTF-16LE buffer and connects.
TEST(ConnectionTest, SQLDriverConnectW_Utf16EncodingOverride) {
  if (sizeof(SQLWCHAR) != 4) {
    GTEST_SKIP() << "WcharEncoding override is only applicable when "
                    "sizeof(SQLWCHAR) == 4 (iODBC / release build); current "
                    "sizeof(SQLWCHAR) is "
                 << sizeof(SQLWCHAR) << ".";
  }

  char const* orig_ini = std::getenv("GOOGLEBIGQUERYODBCINI");
  std::string saved_ini = orig_ini ? orig_ini : "";

  char const* utf16_ini = std::getenv("GOOGLEBIGQUERYODBCINI_UTF16");
  if (!utf16_ini || utf16_ini[0] == '\0') {
    GTEST_SKIP() << "GOOGLEBIGQUERYODBCINI_UTF16 is not set; skipping UTF-16 "
                    "encoding override test.";
  }

  std::string driver_path = FindDriverPath();
  void* handle =
      dlopen(driver_path.c_str(), RTLD_NOW | RTLD_LOCAL | RTLD_NODELETE);
  if (!handle) {
    handle = dlopen("libgoogle_cloud_odbc_bq_driver.so",
                    RTLD_NOW | RTLD_LOCAL | RTLD_NODELETE);
  }
  if (!handle) {
    GTEST_SKIP() << "Cannot dlopen BigQuery ODBC driver at " << driver_path
                 << " (" << dlerror() << "); skipping.";
  }

  auto sql_alloc_handle =
      reinterpret_cast<SQLRETURN (*)(SQLSMALLINT, SQLHANDLE, SQLHANDLE*)>(
          dlsym(handle, "SQLAllocHandle"));
  auto sql_set_env_attr = reinterpret_cast<SQLRETURN (*)(
      SQLHENV, SQLINTEGER, SQLPOINTER, SQLINTEGER)>(
      dlsym(handle, "SQLSetEnvAttr"));
  auto sql_driver_connect_w = reinterpret_cast<SQLRETURN (*)(
      SQLHDBC, SQLHWND, SQLWCHAR*, SQLSMALLINT, SQLWCHAR*, SQLSMALLINT,
      SQLSMALLINT*, SQLUSMALLINT)>(dlsym(handle, "SQLDriverConnectW"));
  auto sql_disconnect =
      reinterpret_cast<SQLRETURN (*)(SQLHDBC)>(dlsym(handle, "SQLDisconnect"));
  auto sql_free_handle =
      reinterpret_cast<SQLRETURN (*)(SQLSMALLINT, SQLHANDLE)>(
          dlsym(handle, "SQLFreeHandle"));

  ASSERT_TRUE(sql_alloc_handle && sql_set_env_attr && sql_driver_connect_w &&
              sql_disconnect && sql_free_handle);

  // Construct a UTF-16LE connection string buffer manually (2 bytes per char).
  std::string conn_str = kDefaultConnectionString;
  std::vector<uint16_t> utf16_conn;
  for (char c : conn_str) {
    utf16_conn.push_back(static_cast<uint16_t>(c));
  }
  utf16_conn.push_back(0);  // NUL terminator

  auto run_connect_attempt = [&](char const* ini_path) -> bool {
    if (ini_path && ini_path[0] != '\0') {
      setenv("GOOGLEBIGQUERYODBCINI", ini_path, 1);
    } else {
      unsetenv("GOOGLEBIGQUERYODBCINI");
    }

    SQLHENV henv = SQL_NULL_HENV;
    SQLHDBC hdbc = SQL_NULL_HDBC;
    bool connected = false;

    // SQLAllocHandle(SQL_HANDLE_ENV) reads GOOGLEBIGQUERYODBCINI and applies
    // WcharEncoding
    if (sql_alloc_handle(SQL_HANDLE_ENV, nullptr, &henv) == SQL_SUCCESS) {
      if (sql_set_env_attr(henv, SQL_ATTR_ODBC_VERSION,
                           (SQLPOINTER)SQL_OV_ODBC3, 0) == SQL_SUCCESS) {
        if (sql_alloc_handle(SQL_HANDLE_DBC, henv, &hdbc) == SQL_SUCCESS) {
          SQLWCHAR* in_str = reinterpret_cast<SQLWCHAR*>(utf16_conn.data());
          SQLRETURN rc =
              sql_driver_connect_w(hdbc, nullptr, in_str, SQL_NTS, nullptr, 0,
                                   nullptr, SQL_DRIVER_COMPLETE);
          if (rc == SQL_SUCCESS || rc == SQL_SUCCESS_WITH_INFO) {
            connected = true;
            sql_disconnect(hdbc);
          }
          sql_free_handle(SQL_HANDLE_DBC, hdbc);
        }
      }
      sql_free_handle(SQL_HANDLE_ENV, henv);
    }
    return connected;
  };

  // Test Case 1: Default configuration (should FAIL with 2-byte UTF-16 buffer)
  EXPECT_FALSE(run_connect_attempt(saved_ini.c_str()))
      << "Test Case 1 (Default / No Override) failed: expected connection to "
         "fail with UTF-16LE buffer but it succeeded.";

  // Test Case 2: UTF-16LE configuration (should SUCCEED)
  EXPECT_TRUE(run_connect_attempt(utf16_ini))
      << "Test Case 2 (UTF-16LE Override) failed: expected connection to "
         "succeed but it failed.";

  // Restore original environment variable and reset driver encoding
  if (!saved_ini.empty()) {
    setenv("GOOGLEBIGQUERYODBCINI", saved_ini.c_str(), 1);
  } else {
    unsetenv("GOOGLEBIGQUERYODBCINI");
  }
  SQLHENV reset_env = SQL_NULL_HENV;
  if (sql_alloc_handle(SQL_HANDLE_ENV, nullptr, &reset_env) == SQL_SUCCESS) {
    sql_free_handle(SQL_HANDLE_ENV, reset_env);
  }
}

// Validates that when WcharEncoding=UTF-8 is configured, the driver correctly
// parses a 1-byte UTF-8 SQLWCHAR buffer passed across the driver boundary.
TEST(ConnectionTest, SQLDriverConnectW_Utf8EncodingOverride) {
  if (sizeof(SQLWCHAR) != 4) {
    GTEST_SKIP() << "WcharEncoding override is only applicable when "
                    "sizeof(SQLWCHAR) == 4 (iODBC / release build); current "
                    "sizeof(SQLWCHAR) is "
                 << sizeof(SQLWCHAR) << ".";
  }

  char const* orig_ini = std::getenv("GOOGLEBIGQUERYODBCINI");
  std::string saved_ini = orig_ini ? orig_ini : "";

  char const* utf8_ini = std::getenv("GOOGLEBIGQUERYODBCINI_UTF8");
  if (!utf8_ini || utf8_ini[0] == '\0') {
    GTEST_SKIP() << "GOOGLEBIGQUERYODBCINI_UTF8 is not set; skipping UTF-8 "
                    "encoding override test.";
  }

  std::string driver_path = FindDriverPath();
  void* handle =
      dlopen(driver_path.c_str(), RTLD_NOW | RTLD_LOCAL | RTLD_NODELETE);
  if (!handle) {
    handle = dlopen("libgoogle_cloud_odbc_bq_driver.so",
                    RTLD_NOW | RTLD_LOCAL | RTLD_NODELETE);
  }
  if (!handle) {
    GTEST_SKIP() << "Cannot dlopen BigQuery ODBC driver at " << driver_path
                 << " (" << dlerror() << "); skipping.";
  }

  auto sql_alloc_handle =
      reinterpret_cast<SQLRETURN (*)(SQLSMALLINT, SQLHANDLE, SQLHANDLE*)>(
          dlsym(handle, "SQLAllocHandle"));
  auto sql_set_env_attr = reinterpret_cast<SQLRETURN (*)(
      SQLHENV, SQLINTEGER, SQLPOINTER, SQLINTEGER)>(
      dlsym(handle, "SQLSetEnvAttr"));
  auto sql_driver_connect_w = reinterpret_cast<SQLRETURN (*)(
      SQLHDBC, SQLHWND, SQLWCHAR*, SQLSMALLINT, SQLWCHAR*, SQLSMALLINT,
      SQLSMALLINT*, SQLUSMALLINT)>(dlsym(handle, "SQLDriverConnectW"));
  auto sql_disconnect =
      reinterpret_cast<SQLRETURN (*)(SQLHDBC)>(dlsym(handle, "SQLDisconnect"));
  auto sql_free_handle =
      reinterpret_cast<SQLRETURN (*)(SQLSMALLINT, SQLHANDLE)>(
          dlsym(handle, "SQLFreeHandle"));

  ASSERT_TRUE(sql_alloc_handle && sql_set_env_attr && sql_driver_connect_w &&
              sql_disconnect && sql_free_handle);

  // Construct a UTF-8 connection string buffer (1 byte per char).
  std::string conn_str = kDefaultConnectionString;

  auto run_connect_attempt = [&](char const* ini_path) -> bool {
    if (ini_path && ini_path[0] != '\0') {
      setenv("GOOGLEBIGQUERYODBCINI", ini_path, 1);
    } else {
      unsetenv("GOOGLEBIGQUERYODBCINI");
    }

    SQLHENV henv = SQL_NULL_HENV;
    SQLHDBC hdbc = SQL_NULL_HDBC;
    bool connected = false;

    // SQLAllocHandle(SQL_HANDLE_ENV) reads GOOGLEBIGQUERYODBCINI and applies
    // WcharEncoding
    if (sql_alloc_handle(SQL_HANDLE_ENV, nullptr, &henv) == SQL_SUCCESS) {
      if (sql_set_env_attr(henv, SQL_ATTR_ODBC_VERSION,
                           (SQLPOINTER)SQL_OV_ODBC3, 0) == SQL_SUCCESS) {
        if (sql_alloc_handle(SQL_HANDLE_DBC, henv, &hdbc) == SQL_SUCCESS) {
          SQLWCHAR* in_str =
              reinterpret_cast<SQLWCHAR*>(const_cast<char*>(conn_str.data()));
          SQLRETURN rc =
              sql_driver_connect_w(hdbc, nullptr, in_str, SQL_NTS, nullptr, 0,
                                   nullptr, SQL_DRIVER_COMPLETE);
          if (rc == SQL_SUCCESS || rc == SQL_SUCCESS_WITH_INFO) {
            connected = true;
            sql_disconnect(hdbc);
          }
          sql_free_handle(SQL_HANDLE_DBC, hdbc);
        }
      }
      sql_free_handle(SQL_HANDLE_ENV, henv);
    }
    return connected;
  };

  // Test Case 1: Connect with default configuration (should FAIL because
  // 1-byte chars are parsed as 4-byte chars)
  EXPECT_FALSE(run_connect_attempt(saved_ini.c_str()))
      << "Test Case 1 (Default / No Override) failed: expected connection to "
         "fail with UTF-8 buffer but it succeeded.";

  // Test Case 2: Connect with UTF-8 configuration (should SUCCEED)
  EXPECT_TRUE(run_connect_attempt(utf8_ini))
      << "Test Case 2 (UTF-8 Override) failed: expected connection to "
         "succeed but it failed.";

  // Restore original environment variable and reset driver encoding
  if (!saved_ini.empty()) {
    setenv("GOOGLEBIGQUERYODBCINI", saved_ini.c_str(), 1);
  } else {
    unsetenv("GOOGLEBIGQUERYODBCINI");
  }
  SQLHENV reset_env = SQL_NULL_HENV;
  if (sql_alloc_handle(SQL_HANDLE_ENV, nullptr, &reset_env) == SQL_SUCCESS) {
    sql_free_handle(SQL_HANDLE_ENV, reset_env);
  }
}
#endif  // !defined(_WIN32)

#endif  // BQ_DRIVER_INTEGRATION_TESTS

}  // namespace google::cloud::odbc_tests