Function TEST_F

test/api/arrow_node_table_test.cpp:18–73

};

TEST_F(ArrowNodeTableTest, CreateArrowTableFromVectors) {
    // Create test data
    std::vector<int32_t> intData = {1, 2, 3, 4, 5};
    std::vector<std::string> stringData = {"a", "b", "c", "d", "e"};

    // Create Arrow schema with 2 fields
    ArrowSchema schema;
    createStructSchema(&schema, 2);
    createSchema<int32_t>(schema.children[0], "int_col");
    createSchema<std::string>(schema.children[1], "string_col");

    // Create Arrow array with 2 children
    ArrowArray array;
    array.length = intData.size();
    array.null_count = 0;
    array.offset = 0;
    array.n_buffers = 1;
    array.n_children = 2;
    array.buffers = static_cast<const void**>(malloc(sizeof(void*)));
    array.buffers[0] = nullptr;
    array.children = static_cast<ArrowArray**>(malloc(sizeof(ArrowArray*) * 2));
    for (int i = 0; i < 2; i++) {
        array.children[i] = static_cast<ArrowArray*>(malloc(sizeof(ArrowArray)));
    }
    createInt32Array(array.children[0], intData);
    createStringArray(array.children[1], stringData);
    array.dictionary = nullptr;
    array.release = [](ArrowArray* arr) {
        if (arr->children) {
            for (int64_t i = 0; i < arr->n_children; i++) {
                if (arr->children[i]->release) {
                    arr->children[i]->release(arr->children[i]);
                }
                free(arr->children[i]);
            }
            free(arr->children);
        }
        if (arr->buffers) {
            free(const_cast<void**>(arr->buffers));
        }
        arr->release = nullptr;
    };
    array.private_data = nullptr;

    // Verify properties
    EXPECT_EQ(array.length, 5);
    EXPECT_EQ(array.n_children, 2);
    EXPECT_STREQ(schema.children[0]->name, "int_col");
    EXPECT_STREQ(schema.children[1]->name, "string_col");

    // Cleanup
    if (schema.release)
        schema.release(&schema);
    if (array.release)
        array.release(&array);
}

TEST_F(ArrowNodeTableTest, ArrowTableTypeConversions) {