Add C API tests for error handling, indexing, and search parameters

bindings/c/CMakeLists.txt

@@ -192,8 +192,9 @@ install(FILES
 )
 
 # Build tests if requested
-# if(SVS_BUILD_C_API_TESTS)
-#     add_subdirectory(tests)
-# endif()
+option(SVS_BUILD_C_API_TESTS "Build C API tests" ON)
+if(SVS_BUILD_C_API_TESTS)
+    add_subdirectory(tests)
+endif()
 
 add_subdirectory(samples)

bindings/c/src/svs_c.cpp

@@ -661,20 +661,32 @@ extern "C" size_t svs_index_dynamic_delete_points(
     svs_index_h index, const size_t* ids, size_t num_ids, svs_error_h out_err
 ) {
     using namespace svs::c_runtime;
-    return wrap_exceptions(
+    std::shared_ptr<DynamicIndex> dynamic_index_ptr;
+    auto result = wrap_exceptions(
         [&]() {
             EXPECT_ARG_NOT_NULL(index);
             EXPECT_ARG_NOT_NULL(ids);
             EXPECT_ARG_GT_THAN(num_ids, 0);
-            auto dynamic_index_ptr = std::dynamic_pointer_cast<DynamicIndex>(index->impl);
+            dynamic_index_ptr = std::dynamic_pointer_cast<DynamicIndex>(index->impl);
             INVALID_ARGUMENT_IF(
                 dynamic_index_ptr == nullptr, "Index does not support dynamic updates"
             );
-            return dynamic_index_ptr->delete_points(std::span(ids, num_ids));
+            return 0; // return 0 for success, actual deletion happens in the next
+                      // wrap_exceptions call
         },
         out_err,
         static_cast<size_t>(-1)
     );
+    if (result != 0) {
+        return result;
+    }
+    // Call delete_points in a separate wrap_exceptions to return 0 if no entries are
+    // deleted.
+    return wrap_exceptions(
+        [&]() { return dynamic_index_ptr->delete_points(std::span(ids, num_ids)); },
+        out_err,
+        0
+    );
 }
 
 extern "C" bool svs_index_dynamic_has_id(

bindings/c/tests/CMakeLists.txt

@@ -0,0 +1,105 @@
+# Copyright 2026 Intel Corporation
+#
+# 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.
+
+set(TARGET_NAME svs_c_api_test)
+
+# Check if Catch2 is available
+find_package(Catch2 3 QUIET)
+
+if(NOT Catch2_FOUND)
+    message(STATUS "Catch2 not found, fetching from GitHub...")
+    include(FetchContent)
+
+    # Do wide printing for the console logger for Catch2
+    set(CATCH_CONFIG_CONSOLE_WIDTH "100" CACHE STRING "" FORCE)
+    set(CATCH_BUILD_TESTING OFF CACHE BOOL "" FORCE)
+    set(CATCH_CONFIG_ENABLE_BENCHMARKING OFF CACHE BOOL "" FORCE)
+    set(CATCH_CONFIG_FAST_COMPILE OFF CACHE BOOL "" FORCE)
+    set(CATCH_CONFIG_PREFIX_ALL ON CACHE BOOL "" FORCE)
+
+    set(PRESET_CMAKE_CXX_STANDARD ${CMAKE_CXX_STANDARD})
+    set(CMAKE_CXX_STANDARD 20)
+    FetchContent_Declare(
+        Catch2
+        GIT_REPOSITORY https://github.com/catchorg/Catch2.git
+        GIT_TAG v3.11.0
+    )
+    FetchContent_MakeAvailable(Catch2)
+    set(CMAKE_CXX_STANDARD ${PRESET_CMAKE_CXX_STANDARD})
+endif()
+
+# Define test sources
+set(C_API_TEST_SOURCES
+    c_api_error.cpp
+    c_api_algorithm.cpp
+    c_api_storage.cpp
+    c_api_search_params.cpp
+    c_api_index_builder.cpp
+    c_api_index.cpp
+    c_api_dynamic_index.cpp
+)
+
+# Create test executable
+add_executable(${TARGET_NAME} ${C_API_TEST_SOURCES})
+
+# Link with C API library and Catch2
+target_link_libraries(${TARGET_NAME} PRIVATE
+    svs_c_api
+    Catch2::Catch2WithMain
+)
+
+# Set C++ standard
+target_compile_features(${TARGET_NAME} PRIVATE cxx_std_20)
+set_target_properties(${TARGET_NAME} PROPERTIES
+    CXX_STANDARD 20
+    CXX_STANDARD_REQUIRED ON
+    CXX_EXTENSIONS OFF
+)
+
+# Include directories
+target_include_directories(${TARGET_NAME} PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}/../include
+)
+
+# Add test to CTest
+include(CTest)
+enable_testing()
+
+# Add the test to CTest
+add_test(NAME ${TARGET_NAME} COMMAND ${TARGET_NAME})
+
+# Set test properties
+set_tests_properties(${TARGET_NAME} PROPERTIES
+    LABELS "c_api"
+)
+
+# Add Catch2 CMake module path
+if(NOT Catch2_FOUND)
+    # Catch2 was fetched, use its source directory
+    list(APPEND CMAKE_MODULE_PATH ${catch2_SOURCE_DIR}/extras)
+else()
+    # Catch2 was found via find_package, use its module directory
+    list(APPEND CMAKE_MODULE_PATH ${Catch2_DIR})
+endif()
+
+include(Catch)
+catch_discover_tests(${TARGET_NAME})
+
+# Add a custom target to run tests
+add_custom_target(run_c_api_tests
+    COMMAND ${TARGET_NAME}
+    DEPENDS ${TARGET_NAME}
+    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+    COMMENT "Running C API tests..."
+)

bindings/c/tests/README.md

@@ -0,0 +1,164 @@
+# C API Tests
+
+This directory contains comprehensive tests for the SVS C API using the Catch2 testing framework.
+
+## Test Structure
+
+The tests are organized into separate files by functionality:
+
+- **c_api_error.cpp**: Tests for error handling functionality
+- **c_api_algorithm.cpp**: Tests for algorithm creation and configuration (Vamana)
+- **c_api_storage.cpp**: Tests for storage configurations (Simple, LeanVec, LVQ, SQ)
+- **c_api_search_params.cpp**: Tests for search parameter creation and configuration
+- **c_api_index_builder.cpp**: Tests for index builder creation and configuration
+- **c_api_index.cpp**: Tests for index building, searching, and basic operations
+- **c_api_dynamic_index.cpp**: Tests for dynamic index operations (add, delete, consolidate, compact)
+
+Note: The main() function is provided by Catch2::Catch2WithMain automatically.
+
+## Building the Tests
+
+The tests are built as part of the C API build process. To build them:
+
+```bash
+# From the build directory
+cmake -DSVS_BUILD_C_API_TESTS=ON ..
+make svs_c_api_tests
+```
+
+To disable building tests:
+
+```bash
+cmake -DSVS_BUILD_C_API_TESTS=OFF ..
+```
+
+## Running the Tests
+
+### Run all tests
+
+```bash
+./svs_c_api_tests
+```
+
+### Run specific test cases
+
+```bash
+# Run error handling tests only
+./svs_c_api_tests "[c_api][error]"
+
+# Run algorithm tests only
+./svs_c_api_tests "[c_api][algorithm]"
+
+# Run all index tests
+./svs_c_api_tests "[c_api][index]"
+
+# Run dynamic index tests
+./svs_c_api_tests "[c_api][dynamic]"
+```
+
+### Run with verbose output
+
+```bash
+./svs_c_api_tests -s
+```
+
+### List all available tests
+
+```bash
+./svs_c_api_tests --list-tests
+```
+
+### Run with CTest
+
+```bash
+ctest -R svs_c_api_tests
+```
+
+## Test Coverage
+
+The tests cover the following aspects of the C API:
+
+### Error Handling
+
+- Error handle creation and cleanup
+- Error state checking
+- Error codes and messages
+- NULL error handle support
+
+### Algorithm Configuration
+
+- Vamana algorithm creation
+- Parameter getters and setters (graph_degree, build_window_size, alpha, search_history)
+- Invalid parameter handling
+
+### Storage Configuration
+
+- Simple storage (Float32, Float16, Int8, Uint8)
+- LeanVec storage (various primary/secondary combinations)
+- LVQ storage (with and without residual)
+- Scalar Quantization storage
+
+### Search Parameters
+
+- Vamana search parameter creation
+- Various window sizes
+
+### Index Builder
+
+- Index builder creation with different metrics (Euclidean, Cosine, Dot Product)
+- Storage configuration
+- Thread pool configuration (Native, OMP, Custom)
+
+### Index Operations
+
+- Index building from data
+- Searching with queries
+- Different K values
+- Distance calculation
+- Vector reconstruction
+- Thread count management
+
+### Dynamic Index Operations
+
+- Dynamic index building with/without explicit IDs
+- Adding points
+- Deleting points
+- ID existence checking
+- Index consolidation
+- Index compaction
+- Search after modifications
+
+## Test Patterns
+
+The tests follow the patterns established in the SVS project:
+
+1. Use `CATCH_TEST_CASE` for test case definitions
+2. Use `CATCH_SECTION` for test subsections
+3. Use `CATCH_REQUIRE` for assertions
+4. Clean up all resources (free handles) after each test
+5. Test both success and error paths
+6. Test with and without NULL error handles
+
+## Adding New Tests
+
+When adding new tests:
+
+1. Create a new `.cpp` file or add to an existing one
+2. Follow the existing structure and naming conventions
+3. Include proper copyright header
+4. Use appropriate test tags: `[c_api][functionality]`
+5. Add the new test file to `CMakeLists.txt` if needed
+6. Clean up all allocated resources
+7. Test both success and error conditions
+
+## Dependencies
+
+- Catch2 v3.x (automatically fetched if not found)
+- SVS C API library
+- C++17 or later compiler
+
+## Notes
+
+- Tests use a simple sequential thread pool for deterministic behavior
+- Test data is generated programmatically for repeatability
+- Some tests may be skipped if optional features are not enabled (e.g., LVQ/LeanVec)