VecReserve

        }
        Buf copy = BufInit(alloc);
        if (!VecReserve(&copy, (u64)data_size)) {
            LOG_ERROR("MachoOpenFromMemoryCopy: allocation failed ({} bytes)", (u64)data_size);
            return false;

        }
        Buf copy = BufInit(alloc);
        if (!VecReserve(&copy, (u64)data_size)) {
            LOG_ERROR("ElfOpenFromMemoryCopy: allocation failed ({} bytes)", (u64)data_size);
            return false;

                if (*offset + 4 <= data_size) {
                    size_t capacity = extract_u32(data, offset, data_size) % 1000; // Limit to reasonable size
                    VecReserve(vec, capacity);
                }
                break;

                if (*offset + 4 <= data_size) {
                    size_t capacity = extract_u32(data, offset, data_size) % 1000; // Limit to reasonable size
                    VecReserve(vec, capacity);
                }
                break;

                uint16_t capacity = extract_u16(data, offset, data_size);
                capacity          = capacity % 1000; // Limit to reasonable capacity
                VecReserve(vec, capacity);
                break;
            }

    
        // Reserve more space than needed
        VecReserve(&vec, 100);
    
        // Add some data

    // Test VecReserve function
    bool test_vec_reserve(void) {
        WriteFmt("Testing VecReserve\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

    
        // Reserve space for 50 elements
        VecReserve(&vec, 50);
    
        // Capacity should now be at least 50

    
        // Reserve less space (should be a no-op)
        VecReserve(&vec, 20);
    
        // Capacity should still be at least 50

    
        // Ensure we have enough capacity to avoid reallocation during the test
        VecReserve(&vec2, VecLen(&vec2) + 10);
    
        // Try inserting just one element first with fast insert

    
        // Reserve zero capacity
        VecReserve(&vec, 0);
        result = result && (VecCapacity(&vec) == 0);

    
        // Make sure we have enough capacity to avoid reallocation issues
        VecReserve(&vec, 10);
    
        // Create several dummy items to populate the vector

    /// TAGS: Buf, Reserve, Capacity, Allocation
    ///
    #define BufReserve(b, n) VecReserve((b), (n))
    
    ///

    #define VecMustReserve(v, n)                                                                                           \
        do {                                                                                                               \
            if (!VecReserve((v), (n))) {                                                                                   \
                LOG_FATAL("VecReserve failed");                                                                            \
            }                                                                                                              \

        do {                                                                                                               \
            if (!VecReserve((v), (n))) {                                                                                   \
                LOG_FATAL("VecReserve failed");                                                                            \
            }                                                                                                              \
        } while (0)

    /// TAGS: Str, Memory, Reserve
    ///
    #define StrReserve(str, n) VecReserve((str), (n))
    
    ///