void ConnectionTest::TestMetadataGetInfo()

in c/validation/adbc_validation.cc [250:331]
74 lines of code
9 McCabe index (conditional complexity)

void ConnectionTest::TestMetadataGetInfo() {
  ASSERT_THAT(AdbcConnectionNew(&connection, &error), IsOkStatus(&error));
  ASSERT_THAT(AdbcConnectionInit(&connection, &database, &error), IsOkStatus(&error));

  if (!quirks()->supports_get_sql_info()) {
    GTEST_SKIP();
  }

  StreamReader reader;
  std::vector<uint32_t> info = {
      ADBC_INFO_DRIVER_NAME,
      ADBC_INFO_DRIVER_VERSION,
      ADBC_INFO_VENDOR_NAME,
      ADBC_INFO_VENDOR_VERSION,
  };

  ASSERT_THAT(AdbcConnectionGetInfo(&connection, info.data(), info.size(),
                                    &reader.stream.value, &error),
              IsOkStatus(&error));
  ASSERT_NO_FATAL_FAILURE(reader.GetSchema());
  ASSERT_NO_FATAL_FAILURE(CompareSchema(
      &reader.schema.value, {
                                {"info_name", NANOARROW_TYPE_UINT32, NOT_NULL},
                                {"info_value", NANOARROW_TYPE_DENSE_UNION, NULLABLE},
                            }));
  ASSERT_NO_FATAL_FAILURE(
      CompareSchema(reader.schema->children[1],
                    {
                        {"string_value", NANOARROW_TYPE_STRING, NULLABLE},
                        {"bool_value", NANOARROW_TYPE_BOOL, NULLABLE},
                        {"int64_value", NANOARROW_TYPE_INT64, NULLABLE},
                        {"int32_bitmask", NANOARROW_TYPE_INT32, NULLABLE},
                        {"string_list", NANOARROW_TYPE_LIST, NULLABLE},
                        {"int32_to_int32_list_map", NANOARROW_TYPE_MAP, NULLABLE},
                    }));
  ASSERT_NO_FATAL_FAILURE(CompareSchema(reader.schema->children[1]->children[4],
                                        {
                                            {"item", NANOARROW_TYPE_STRING, NULLABLE},
                                        }));
  ASSERT_NO_FATAL_FAILURE(CompareSchema(reader.schema->children[1]->children[5],
                                        {
                                            {"entries", NANOARROW_TYPE_STRUCT, NOT_NULL},
                                        }));
  ASSERT_NO_FATAL_FAILURE(
      CompareSchema(reader.schema->children[1]->children[5]->children[0],
                    {
                        {"key", NANOARROW_TYPE_INT32, NOT_NULL},
                        {"value", NANOARROW_TYPE_LIST, NULLABLE},
                    }));
  ASSERT_NO_FATAL_FAILURE(
      CompareSchema(reader.schema->children[1]->children[5]->children[0]->children[1],
                    {
                        {"item", NANOARROW_TYPE_INT32, NULLABLE},
                    }));

  std::vector<uint32_t> seen;
  while (true) {
    ASSERT_NO_FATAL_FAILURE(reader.Next());
    if (!reader.array->release) break;

    for (int64_t row = 0; row < reader.array->length; row++) {
      ASSERT_FALSE(ArrowArrayViewIsNull(reader.array_view->children[0], row));
      const uint32_t code =
          reader.array_view->children[0]->buffer_views[1].data.as_uint32[row];
      seen.push_back(code);

      switch (code) {
        case ADBC_INFO_DRIVER_NAME:
        case ADBC_INFO_DRIVER_VERSION:
        case ADBC_INFO_VENDOR_NAME:
        case ADBC_INFO_VENDOR_VERSION:
          // UTF8
          ASSERT_EQ(uint8_t(0),
                    reader.array_view->children[1]->buffer_views[0].data.as_uint8[row]);
        default:
          // Ignored
          break;
      }
    }
  }
  ASSERT_THAT(seen, ::testing::UnorderedElementsAreArray(info));
}