Method BasicTest

src/datacell/graph_interface_test.cpp:29–177

using namespace vsag;

void
GraphInterfaceTest::BasicTest(uint64_t max_id,
                              uint64_t count,
                              const GraphInterfacePtr& other,
                              bool test_delete) {
    auto allocator = SafeAllocator::FactoryDefaultAllocator();
    auto max_degree = this->graph_->MaximumDegree();
    this->graph_->Resize(max_id);
    UnorderedMap<InnerIdType, std::shared_ptr<Vector<InnerIdType>>> maps(allocator.get());
    std::unordered_set<InnerIdType> unique_keys;
    while (unique_keys.size() < count) {
        InnerIdType new_key = random() % max_id;
        unique_keys.insert(new_key);
    }

    std::vector<InnerIdType> keys(unique_keys.begin(), unique_keys.end());
    for (auto key : keys) {
        maps[key] = std::make_shared<Vector<InnerIdType>>(allocator.get());
    }

    std::random_device rd;
    std::mt19937 rng(rd());

    for (auto& pair : maps) {
        auto& vec_ptr = pair.second;
        int max_possible_length = keys.size();
        int length = random() % (max_degree - 1) + 2;
        length = std::min(length, max_possible_length);
        std::vector<InnerIdType> temp_keys = keys;
        std::shuffle(temp_keys.begin(), temp_keys.end(), rng);

        vec_ptr->resize(length);
        for (int i = 0; i < length; ++i) {
            (*vec_ptr)[i] = temp_keys[i];
        }
    }

    if (require_sorted_) {
        for (auto& [key, value] : maps) {
            std::sort(value->begin(), value->end());
        }
    }

    for (auto& [key, value] : maps) {
        this->graph_->InsertNeighborsById(key, *value);
    }

    // Test GetNeighborSize
    SECTION("Test GetNeighborSize") {
        for (auto& [key, value] : maps) {
            REQUIRE(this->graph_->GetNeighborSize(key) == value->size());
        }
    }

    // Test GetNeighbors
    SECTION("Test GetNeighbors") {
        for (auto& [key, value] : maps) {
            Vector<InnerIdType> neighbors(allocator.get());