Strs

    /// TAGS: Str, Validate, API
    ///
    void ValidateStrs(const Strs *vs);
    
    #endif // MISRA_STD_CONTAINER_STR_TYPE_H

    #define DnsResolverAddResolvPath_3(self, p, n) dns_resolver_add_resolv_path_zstr((self), (p), (n))
    
        bool dns_resolver_add_paths(DnsResolver *self, const Strs *paths);
        bool dns_resolver_add_hosts_paths(DnsResolver *self, const Strs *paths);
        bool dns_resolver_add_resolv_paths(DnsResolver *self, const Strs *paths);

    
        bool dns_resolver_add_paths(DnsResolver *self, const Strs *paths);
        bool dns_resolver_add_hosts_paths(DnsResolver *self, const Strs *paths);
        bool dns_resolver_add_resolv_paths(DnsResolver *self, const Strs *paths);
    #define DnsResolverAddPaths(self, paths)       dns_resolver_add_paths((self), (paths))

        bool dns_resolver_add_paths(DnsResolver *self, const Strs *paths);
        bool dns_resolver_add_hosts_paths(DnsResolver *self, const Strs *paths);
        bool dns_resolver_add_resolv_paths(DnsResolver *self, const Strs *paths);
    #define DnsResolverAddPaths(self, paths)       dns_resolver_add_paths((self), (paths))
    #define DnsResolverAddHostsPaths(self, paths)  dns_resolver_add_hosts_paths((self), (paths))

    }
    
    static Strs str_split_impl(Str *s, Zstr key, size keylen) {
        ValidateStr(s);

        ValidateStr(s);
    
        Strs sv        = (Strs)VecInit(s->allocator);
        sv.copy_deinit = (GenericCopyDeinit)str_deinit;
        Zstr prev      = s->data;

    }
    
    Strs str_split_zstr(Str *s, Zstr key) {
        return str_split_impl(s, key, ZstrLen(key));
    }

    }
    
    Strs str_split_str(Str *s, const Str *key) {
        if (!key) {
            LOG_FATAL("Invalid arguments");

    }
    
    void ValidateStrs(const Strs *vs) {
        ValidateVec(vs);
        VecForeachPtr(vs, sp) {

    }
    
    bool dns_resolver_add_paths(DnsResolver *self, const Strs *paths) {
        if (!self || !paths)
            return false;

    }
    
    bool dns_resolver_add_hosts_paths(DnsResolver *self, const Strs *paths) {
        if (!self || !paths)
            return false;

    }
    
    bool dns_resolver_add_resolv_paths(DnsResolver *self, const Strs *paths) {
        if (!self || !paths)
            return false;

    // so left_col is populated, drive --help, and require live_count == 0.
    static bool test_help_frees_left_col_strs(void) {
        WriteFmt("Testing print_help frees per-spec left-column Strs (414:9)\n");
    
        DebugAllocator dbg  = DebugAllocatorInit();

        // Test StrSplit
        Str  s     = StrInitFromZstr("Hello,World,Test", &alloc);
        Strs split = StrSplit(&s, ",");
    
        bool result = (VecLen(&split) == 3);

    
        Str  s     = StrInitFromZstr("ab", &alloc);
        Strs split = StrSplit(&s, "abc");
    
        bool result = (VecLen(&split) == 0);

    
        Str  s     = StrInitFromZstr("ab", &alloc);
        Strs split = StrSplit(&s, "abc");
    
        bool result = (VecLen(&split) == 0);

    
        Str  s                                    = StrInitFromZstr("a,b,c", &alloc);
        Strs strs                                 = StrSplit(&s, ",");
        GENERIC_VEC(VecPtrAt(&strs, 0))->__magic ^= 0x1;
        ValidateStrs(&strs);

        Str s      = StrInitFromZstr("a,b", &alloc);
        s.__magic  = 0; // corrupt the magic so ValidateStr aborts
        Strs split = StrSplit(&s, ",");
        (void)split;

        size before = DebugAllocatorLiveCount(&dbg);
    
        Strs parts = StrSplit(&s, ",");
        // Sanity: the split really produced multiple heap-backed elements,
        // otherwise the leak would be unobservable.

    // Test Strs type definition
    bool test_strs_type(void) {
        WriteFmt("Testing Strs type definition\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

    
        // Create a Strs object (vector of strings)
        Strs sv = VecInitWithDeepCopy(NULL, StrDeinit, &alloc);
    
        // Add some strings

    
        // Create a valid Strs
        Strs sv = VecInit(&alloc);
    
        // This should not crash

    // Deadend test: Test ValidateStrs with invalid Strs (should crash/abort)
    bool test_validate_invalid_strs(void) {
        WriteFmt("Testing ValidateStrs with invalid Strs (should abort)\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();

    
        // Create an invalid Strs by corrupting its fields
        Strs sv = VecInit(&alloc);
    
        // Corrupt the vector to make it invalid

        Str p1 = write_temp(a, "2.2.2.2 beta\n");
    
        Strs paths = VecInitT(paths, a);
        VecPushBackR(&paths, p0);
        VecPushBackR(&paths, p1);

        Str p1 = write_temp(a, "nameserver 10.0.0.2\n");
    
        Strs paths = VecInitT(paths, a);
        VecPushBackR(&paths, p0);
        VecPushBackR(&paths, p1);

        Str p1 = write_temp(a, "nameserver 9.9.9.9\n");
    
        Strs paths = VecInitT(paths, a);
        VecPushBackR(&paths, p0);
        VecPushBackR(&paths, p1);