自学教程：C++ BufferDestroy函数代码示例

int IsIPV6Address(char *name){    if (!name)    {        return false;    }    Buffer *buffer = BufferNewFrom(name, strlen(name));    if (!buffer)    {        return false;    }    IPAddress *ip_address = NULL;    bool is_ip = false;    is_ip = IPAddressIsIPAddress(buffer, &ip_address);    if (!is_ip)    {        BufferDestroy(buffer);        return false;    }    if (IPAddressType(ip_address) != IP_ADDRESS_TYPE_IPV6)    {        BufferDestroy(buffer);        IPAddressDestroy(&ip_address);        return false;    }    BufferDestroy(buffer);    IPAddressDestroy(&ip_address);    return true;}

static void test_copyEqualBuffer(void **state){    char element0[] = "element0";    unsigned int element0size = strlen(element0);    char element1[] = "element1";    unsigned int element1size = strlen(element1);    Buffer *buffer0 = NULL;    Buffer *buffer1 = NULL;    Buffer *buffer2 = NULL;    // Empty buffers, all empty buffers are the same    assert_int_equal(0, BufferNew(&buffer0));    assert_int_equal(0, BufferNew(&buffer1));    assert_true(BufferEqual(buffer0, buffer0));    assert_true(BufferEqual(buffer0, buffer1));    assert_int_equal(0, BufferCopy(buffer0, &buffer2));    assert_true(BufferEqual(buffer0, buffer2));    // Add some flavour    assert_int_equal(0, BufferDestroy(&buffer2));    assert_int_equal(element0size, BufferSet(buffer0, element0, element0size));    assert_int_equal(element1size, BufferSet(buffer1, element1, element1size));    assert_true(BufferEqual(buffer0, buffer0));    assert_false(BufferEqual(buffer0, buffer1));    assert_int_equal(0, BufferCopy(buffer0, &buffer2));    assert_true(BufferEqual(buffer0, buffer2));    // Destroy the buffers    assert_int_equal(0, BufferDestroy(&buffer0));    assert_int_equal(0, BufferDestroy(&buffer1));    assert_int_equal(0, BufferDestroy(&buffer2));}

static void test_zeroBuffer(void){    char *element0 = xstrdup("element0");    unsigned int element0size = strlen(element0);    const char *element0pointer = NULL;    Buffer *buffer = BufferNew();    assert_int_equal(element0size, BufferSet(buffer, element0, element0size));    element0pointer = buffer->buffer;    assert_int_equal(element0size, buffer->used);    assert_int_equal(element0size, BufferSize(buffer));    BufferZero(buffer);    assert_int_equal(DEFAULT_BUFFER_SIZE, buffer->capacity);    assert_int_equal(0, buffer->used);    assert_int_equal(0, BufferSize(buffer));	const char *data = BufferData(buffer);	assert_string_equal(data, "");    assert_true(element0pointer == buffer->buffer);    BufferZero(NULL);    assert_int_equal(0, BufferDestroy(&buffer));    /*     * Release the resources     */    BufferDestroy(&buffer);    free (element0);}

static void test_destroyBuffer(void){    Buffer *buffer = BufferNew();    assert_int_equal(0, BufferDestroy(&buffer));    assert_true(buffer == NULL);    assert_int_equal(0, BufferDestroy(NULL));}

static bool Epimenides(EvalContext *ctx, const char *ns, const char *scope, const char *var, Rval rval, int level){    switch (rval.type)    {    case RVAL_TYPE_SCALAR:        if (StringContainsVar(RvalScalarValue(rval), var))        {            Log(LOG_LEVEL_ERR, "Scalar variable '%s' contains itself (non-convergent) '%s'", var, RvalScalarValue(rval));            return true;        }        if (IsCf3VarString(RvalScalarValue(rval)))        {            Buffer *exp = BufferNew();            ExpandScalar(ctx, ns, scope, RvalScalarValue(rval), exp);            if (strcmp(BufferData(exp), RvalScalarValue(rval)) == 0)            {                BufferDestroy(exp);                return false;            }            if (level > 3)            {                BufferDestroy(exp);                return false;            }            if (Epimenides(ctx, ns, scope, var, (Rval) { BufferGet(exp), RVAL_TYPE_SCALAR}, level + 1))            {                BufferDestroy(exp);                return true;            }            BufferDestroy(exp);        }        break;    case RVAL_TYPE_LIST:        for (const Rlist *rp = RvalRlistValue(rval); rp != NULL; rp = rp->next)        {            if (Epimenides(ctx, ns, scope, var, rp->val, level))            {                return true;            }        }        break;    case RVAL_TYPE_CONTAINER:    case RVAL_TYPE_FNCALL:    case RVAL_TYPE_NOPROMISEE:        return false;    }    return false;}

static VersionCmpResult RunCmpCommand(EvalContext *ctx, const char *command, const char *v1, const char *v2, Attributes a,                                      const Promise *pp, PromiseResult *result){    Buffer *expanded_command = BufferNew();    {        VarRef *ref_v1 = VarRefParseFromScope("v1", PACKAGES_CONTEXT);        EvalContextVariablePut(ctx, ref_v1, v1, CF_DATA_TYPE_STRING, "source=promise");        VarRef *ref_v2 = VarRefParseFromScope("v2", PACKAGES_CONTEXT);        EvalContextVariablePut(ctx, ref_v2, v2, CF_DATA_TYPE_STRING, "source=promise");        ExpandScalar(ctx, NULL, PACKAGES_CONTEXT, command, expanded_command);        EvalContextVariableRemove(ctx, ref_v1);        VarRefDestroy(ref_v1);        EvalContextVariableRemove(ctx, ref_v2);        VarRefDestroy(ref_v2);    }    FILE *pfp = a.packages.package_commands_useshell ? cf_popen_sh(BufferData(expanded_command), "w") : cf_popen(BufferData(expanded_command), "w", true);    if (pfp == NULL)    {        cfPS(ctx, LOG_LEVEL_ERR, PROMISE_RESULT_FAIL, pp, a, "Can not start package version comparison command '%s'. (cf_popen: %s)",             BufferData(expanded_command), GetErrorStr());        *result = PromiseResultUpdate(*result, PROMISE_RESULT_FAIL);        BufferDestroy(expanded_command);        return VERCMP_ERROR;    }    Log(LOG_LEVEL_VERBOSE, "Executing '%s'", BufferData(expanded_command));    int retcode = cf_pclose(pfp);    if (retcode == -1)    {        cfPS(ctx, LOG_LEVEL_ERR, PROMISE_RESULT_FAIL, pp, a, "Error during package version comparison command execution '%s'. (cf_pclose: %s)",             BufferData(expanded_command), GetErrorStr());        *result = PromiseResultUpdate(*result, PROMISE_RESULT_FAIL);        BufferDestroy(expanded_command);        return VERCMP_ERROR;    }    BufferDestroy(expanded_command);    return retcode == 0;}

char *VarRefToString(const VarRef *ref, bool qualified){    assert(ref->lval);    Buffer *buf = BufferNew();    if (qualified && VarRefIsQualified(ref))    {        const char *ns = ref->ns ? ref->ns : "default";        BufferAppend(buf, ns, strlen(ns));        BufferAppend(buf, ":", sizeof(char));        BufferAppend(buf, ref->scope, strlen(ref->scope));        BufferAppend(buf, ".", sizeof(char));    }    BufferAppend(buf, ref->lval, strlen(ref->lval));    for (size_t i = 0; i < ref->num_indices; i++)    {        BufferAppend(buf, "[", sizeof(char));        BufferAppend(buf, ref->indices[i], strlen(ref->indices[i]));        BufferAppend(buf, "]", sizeof(char));    }    char *var_string = xstrdup(BufferData(buf));    BufferDestroy(&buf);    return var_string;}

static void ShowContextsFormatted(EvalContext *ctx){    ClassTableIterator *iter = EvalContextClassTableIteratorNewGlobal(ctx, NULL, true, true);    Class *cls = NULL;    Seq *seq = SeqNew(1000, free);    while ((cls = ClassTableIteratorNext(iter)))    {        char *class_name = ClassRefToString(cls->ns, cls->name);        StringSet *tagset = EvalContextClassTags(ctx, cls->ns, cls->name);        Buffer *tagbuf = StringSetToBuffer(tagset, ',');        char *line;        xasprintf(&line, "%-60s %-40s", class_name, BufferData(tagbuf));        SeqAppend(seq, line);        BufferDestroy(tagbuf);        free(class_name);    }    SeqSort(seq, (SeqItemComparator)strcmp, NULL);    printf("%-60s %-40s/n", "Class name", "Meta tags");    for (size_t i = 0; i < SeqLength(seq); i++)    {        const char *context = SeqAt(seq, i);        printf("%s/n", context);    }    SeqDestroy(seq);    ClassTableIteratorDestroy(iter);}

static void ShowVariablesFormatted(EvalContext *ctx){    VariableTableIterator *iter = EvalContextVariableTableIteratorNew(ctx, NULL, NULL, NULL);    Variable *v = NULL;    Seq *seq = SeqNew(2000, free);    while ((v = VariableTableIteratorNext(iter)))    {        char *varname = VarRefToString(v->ref, true);        Writer *w = StringWriter();        switch (DataTypeToRvalType(v->type))        {        case RVAL_TYPE_CONTAINER:            JsonWriteCompact(w, RvalContainerValue(v->rval));            break;        default:            RvalWrite(w, v->rval);        }        const char *var_value;        if (StringIsPrintable(StringWriterData(w)))        {            var_value = StringWriterData(w);        }        else        {            var_value = "<non-printable>";        }        StringSet *tagset = EvalContextVariableTags(ctx, v->ref);        Buffer *tagbuf = StringSetToBuffer(tagset, ',');        char *line;        xasprintf(&line, "%-40s %-60s %-40s", varname, var_value, BufferData(tagbuf));        SeqAppend(seq, line);        BufferDestroy(tagbuf);        WriterClose(w);        free(varname);    }    SeqSort(seq, (SeqItemComparator)strcmp, NULL);    printf("%-40s %-60s %-40s/n", "Variable name", "Variable value", "Meta tags");    for (size_t i = 0; i < SeqLength(seq); i++)    {        const char *variable = SeqAt(seq, i);        printf("%s/n", variable);    }    SeqDestroy(seq);    VariableTableIteratorDestroy(iter);}

void BufferRewrite(Buffer *buffer, BufferFilterFn filter, const bool invert){    assert(buffer);    Buffer *rewrite = BufferFilter(buffer, filter, invert);    BufferSet(buffer, BufferData(rewrite), BufferSize(rewrite));    BufferDestroy(rewrite);}

void TestCreateBuffer(CuTest* tc){    buffer_t *buf = BufferCreate();    CuAssertTrue(tc, buf != NULL);    CuAssertIntEquals(tc, 0, BufferGetSize(buf));    BufferDestroy(&buf);    CuAssertPtrEquals(tc, 0, buf);}

Rlist *RlistFromSplitRegex(const char *string, const char *regex, size_t max_entries, bool allow_blanks){    assert(string);    if (!string)    {        return NULL;    }    const char *sp = string;    size_t entry_count = 0;    int start = 0;    int end = 0;    Rlist *result = NULL;    Buffer *buffer = BufferNewWithCapacity(CF_MAXVARSIZE);    pcre *rx = CompileRegex(regex);    if (rx)    {        while ((entry_count < max_entries) &&               StringMatchWithPrecompiledRegex(rx, sp, &start, &end))        {            if (end == 0)            {                break;            }            BufferClear(buffer);            BufferAppend(buffer, sp, start);            if (allow_blanks || BufferSize(buffer) > 0)            {                RlistAppendScalar(&result, BufferData(buffer));                entry_count++;            }            sp += end;        }        pcre_free(rx);    }    if (entry_count < max_entries)    {        BufferClear(buffer);        size_t remaining = strlen(sp);        BufferAppend(buffer, sp, remaining);        if ((allow_blanks && sp != string) || BufferSize(buffer) > 0)        {            RlistAppendScalar(&result, BufferData(buffer));        }    }    BufferDestroy(buffer);    return result;}

static void test_expand_scalar_undefined(void **state){    EvalContext *ctx = *state;    Buffer *res = BufferNew();    ExpandScalar(ctx, "default", "bundle", "a$(undefined)b", res);    assert_string_equal("a$(undefined)b", BufferData(res));    BufferDestroy(res);}

void CreateHardClassesFromFeatures(EvalContext *ctx, char *tags){    Buffer *buffer = BufferNew();    for(int i=0 ; features[i]!=NULL ; i++) {        BufferPrintf(buffer, "feature_%s", features[i]);        CreateHardClassesFromCanonification(ctx, BufferData(buffer), tags);    }    BufferDestroy(buffer);}

void TestAppend(CuTest* tc){    buffer_t *buf = BufferCreate();    uint8_t data[2] = { 1, 2 };    BufferAppend(buf, data, sizeof(data));    CuAssertIntEquals(tc, 2, BufferGetSize(buf));    CuAssertIntEquals(tc, 1, BufferGetByte(buf, 0));    CuAssertIntEquals(tc, 2, BufferGetByte(buf, 1));    BufferDestroy(&buf);}

void ZmtpReaderDestroy(zmtpreader_t **self){    assert(self);    zmtpreader_t *reader = *self;    if (reader != NULL) {        free((void*) reader->id);        BufferDestroy(&reader->buffer);        free(reader);    }    *self = NULL;}

voidLineDestroy(Line l){	Line aux = NULL;	while (l) {		BufferDestroy(l->b);		aux = l->next;			free(l);		l = aux;	}}

static PromiseResult ExpandPromiseAndDo(EvalContext *ctx, const Promise *pp,                                        Rlist *lists, Rlist *containers,                                        PromiseActuator *ActOnPromise, void *param){    const char *handle = PromiseGetHandle(pp);    EvalContextStackPushPromiseFrame(ctx, pp, true);    PromiseIterator *iter_ctx = NULL;    size_t i = 0;    PromiseResult result = PROMISE_RESULT_NOOP;    Buffer *expbuf = BufferNew();    for (iter_ctx = PromiseIteratorNew(ctx, pp, lists, containers); PromiseIteratorHasMore(iter_ctx); i++, PromiseIteratorNext(iter_ctx))    {        if (handle)        {            // This ordering is necessary to get automated canonification            BufferClear(expbuf);            ExpandScalar(ctx, NULL, "this", handle, expbuf);            CanonifyNameInPlace(BufferGet(expbuf));            EvalContextVariablePutSpecial(ctx, SPECIAL_SCOPE_THIS, "handle", BufferData(expbuf), CF_DATA_TYPE_STRING, "source=promise");        }        else        {            EvalContextVariablePutSpecial(ctx, SPECIAL_SCOPE_THIS, "handle", PromiseID(pp), CF_DATA_TYPE_STRING, "source=promise");        }        const Promise *pexp = EvalContextStackPushPromiseIterationFrame(ctx, i, iter_ctx);        if (!pexp)        {            // excluded            result = PromiseResultUpdate(result, PROMISE_RESULT_SKIPPED);            continue;        }        PromiseResult iteration_result = ActOnPromise(ctx, pexp, param);        NotifyDependantPromises(ctx, pexp, iteration_result);        result = PromiseResultUpdate(result, iteration_result);        if (strcmp(pp->parent_promise_type->name, "vars") == 0 || strcmp(pp->parent_promise_type->name, "meta") == 0)        {            VerifyVarPromise(ctx, pexp, true);        }        EvalContextStackPopFrame(ctx);    }    BufferDestroy(expbuf);    PromiseIteratorDestroy(iter_ctx);    EvalContextStackPopFrame(ctx);    return result;}

static bool RlistItemIPLess(void *lhs, void *rhs, ARG_UNUSED void *ctx){    const char *left_item = RlistScalarValue((Rlist*)lhs);    const char *right_item = RlistScalarValue((Rlist*)rhs);    Buffer *left_buffer = BufferNewFrom(left_item, strlen(left_item));    Buffer *right_buffer = BufferNewFrom(right_item, strlen(right_item));    IPAddress *left = IPAddressNew(left_buffer);    IPAddress *right = IPAddressNew(right_buffer);    bool matched_left = left != NULL;    bool matched_right = right != NULL;    BufferDestroy(&left_buffer);    BufferDestroy(&right_buffer);    if (matched_left && matched_right)    {        int less = IPAddressCompareLess(left, right);        IPAddressDestroy(&left);        IPAddressDestroy(&right);        return less;    }    IPAddressDestroy(&left);    IPAddressDestroy(&right);    if (matched_left)    {        return false;    }    if (matched_right)    {        return true;    }    // neither item matched    return RlistItemLess(lhs, rhs, ctx);}

/***************************************************************************** * Destroy: destroy adjust video thread output method ***************************************************************************** * Terminate an output method created by adjustCreateOutputMethod *****************************************************************************/static void Destroy( vlc_object_t *p_this ){    filter_t *p_filter = (filter_t *)p_this;    filter_sys_t *p_sys = p_filter->p_sys;    BufferDestroy( &p_sys->input );    BufferDestroy( &p_sys->output );    QueueDestroy( &p_sys->atomic );    QueueDestroy( &p_sys->pending );    QueueDestroy( &p_sys->processed );    do_ListDestroy( &p_sys->overlays );    UnregisterCommand( p_filter );    var_DelCallback( p_filter, "overlay-input", AdjustCallback, p_sys );    var_DelCallback( p_filter, "overlay-output", AdjustCallback, p_sys );    vlc_mutex_destroy( &p_sys->lock );    free( p_sys->psz_inputfile );    free( p_sys->psz_outputfile );    free( p_sys );}

void TestCopyBuffer(CuTest* tc){    buffer_t *buf = BufferCreate();    uint8_t data[4] = { 1, 2, 3, 4 };    BufferAppend(buf, data, sizeof(data));    uint8_t *data_out;    size_t size_out;    BufferCopy(buf, 2, &data_out, &size_out);    CuAssertIntEquals(tc, 2, size_out);    CuAssertIntEquals(tc, 0, memcmp(data, data_out, 2));    free(data_out);    BufferDestroy(&buf);}

static void test_copyCompareBuffer(void){    char *element0 = xstrdup("element0");    unsigned int element0size = strlen(element0);    char *element1 = xstrdup("element1");    unsigned int element1size = strlen(element1);    Buffer *buffer0 = NULL;    Buffer *buffer1 = NULL;    Buffer *buffer2 = NULL;    assert_int_equal(0, BufferCompare(buffer0, buffer1));    buffer0 = BufferNew();    assert_int_equal(-1, BufferCompare(NULL, buffer0));    assert_int_equal(1, BufferCompare(buffer0, NULL));    buffer1 = BufferNew();    assert_int_equal(0, BufferCompare(buffer0, buffer0));    assert_int_equal(0, BufferCompare(buffer0, buffer1));    assert_int_equal(0, BufferCopy(buffer0, &buffer2));    assert_int_equal(0, BufferCompare(buffer0, buffer2));    // Add some flavour    assert_int_equal(0, BufferDestroy(&buffer2));    assert_int_equal(element0size, BufferSet(buffer0, element0, element0size));    assert_int_equal(element1size, BufferSet(buffer1, element1, element1size));    assert_int_equal(0, BufferCompare(buffer0, buffer0));    assert_int_equal(-1, BufferCompare(buffer0, buffer1));    assert_int_equal(1, BufferCompare(buffer1, buffer0));    assert_int_equal(0, BufferCopy(buffer0, &buffer2));    assert_int_equal(0, BufferCompare(buffer0, buffer2));    // Destroy the buffers    assert_int_equal(0, BufferDestroy(&buffer0));    assert_int_equal(0, BufferDestroy(&buffer1));    assert_int_equal(0, BufferDestroy(&buffer2));    free (element0);    free (element1);}

void TestAccessBufferData(CuTest* tc){    buffer_t *buf = BufferCreate();    uint8_t data1[4] = { 1, 2, 3, 4 };    BufferAppend(buf, data1, sizeof(data1));    uint8_t *buffer_data;    size_t buffer_size;    BufferGetData(buf, &buffer_data, &buffer_size);    CuAssertTrue(tc, buffer_data != NULL);    CuAssertIntEquals(tc, 4, buffer_size);    BufferDestroy(&buf);}

static void test_createBuffer(void){    Buffer *buffer = BufferNew();    assert_true(buffer != NULL);    assert_true(buffer->buffer != NULL);    assert_int_equal(buffer->mode, BUFFER_BEHAVIOR_CSTRING);    assert_int_equal(buffer->capacity, DEFAULT_BUFFER_SIZE);    assert_int_equal(buffer->used, 0);    assert_int_equal(buffer->beginning, 0);    assert_int_equal(buffer->end, 0);    assert_true(buffer->ref_count != NULL);    assert_int_equal(buffer->ref_count->user_count, 1);    assert_int_equal(0, BufferDestroy(&buffer));}

Buffer *IPAddressGetAddress(IPAddress *address){    if (!address)    {        return NULL;    }    Buffer *buffer = NULL;    int result = 0;    if (address->type == IP_ADDRESS_TYPE_IPV4)    {        struct IPV4Address *ipv4 = (struct IPV4Address *)address->address;        buffer = BufferNew();#if BIG_ENDIAN        result = BufferPrintf(buffer, "%u.%u.%u.%u", ipv4->octets[0], ipv4->octets[1], ipv4->octets[2], ipv4->octets[3]);#elif LITTLE_ENDIAN        result = BufferPrintf(buffer, "%u.%u.%u.%u", ipv4->octets[3], ipv4->octets[2], ipv4->octets[1], ipv4->octets[0]);#else#warning "Unrecognized endianness, assuming big endian"        result = BufferPrintf(buffer, "%u.%u.%u.%u", ipv4->octets[0], ipv4->octets[1], ipv4->octets[2], ipv4->octets[3]);#endif    }    else if (address->type == IP_ADDRESS_TYPE_IPV6)    {        struct IPV6Address *ipv6 = (struct IPV6Address *)address->address;        buffer = BufferNew();#if BIG_ENDIAN        result = BufferPrintf(buffer, "%x:%x:%x:%x:%x:%x:%x:%x", ipv6->sixteen[0], ipv6->sixteen[1], ipv6->sixteen[2],                              ipv6->sixteen[3], ipv6->sixteen[4], ipv6->sixteen[5], ipv6->sixteen[6], ipv6->sixteen[7]);#elif LITTLE_ENDIAN        result = BufferPrintf(buffer, "%x:%x:%x:%x:%x:%x:%x:%x", ipv6->sixteen[7], ipv6->sixteen[6], ipv6->sixteen[5],                              ipv6->sixteen[4], ipv6->sixteen[3], ipv6->sixteen[2], ipv6->sixteen[1], ipv6->sixteen[0]);#else#warning "Unrecognized endianness, assuming big endian"        result = BufferPrintf(buffer, "%x:%x:%x:%x:%x:%x:%x:%x", ipv6->sixteen[0], ipv6->sixteen[1], ipv6->sixteen[2],                              ipv6->sixteen[3], ipv6->sixteen[4], ipv6->sixteen[5], ipv6->sixteen[6], ipv6->sixteen[7]);#endif    }    else    {        buffer = NULL;    }    if (result < 0)    {        BufferDestroy(buffer);        return NULL;    }    return buffer;}

static void test_expand_scalar_nested_inner_undefined(void **state){    EvalContext *ctx = *state;    {        VarRef *lval = VarRefParse("default:bundle.foo[one]");        EvalContextVariablePut(ctx, lval, "first", CF_DATA_TYPE_STRING, NULL);        VarRefDestroy(lval);    }    Buffer *res = BufferNew();    ExpandScalar(ctx, "default", "bundle", "a$(foo[$(undefined)])b", res);    assert_string_equal("a$(foo[$(undefined)])b", BufferData(res));    BufferDestroy(res);}

void TestExtractBuffer(CuTest* tc){    buffer_t *buf = BufferCreate();    uint8_t data[4] = { 1, 2, 3, 4 };    BufferAppend(buf, data, sizeof(data));    uint8_t *data_out;    size_t size_out;    BufferExtract(buf, 2, &data_out, &size_out);    CuAssertIntEquals(tc, 2, size_out);    CuAssertIntEquals(tc, 0, memcmp(data, data_out, 2));    free(data_out);    CuAssertIntEquals(tc, 2, BufferGetSize(buf));    CuAssertIntEquals(tc, 3, BufferGetByte(buf, 0));    CuAssertIntEquals(tc, 4, BufferGetByte(buf, 1));    BufferDestroy(&buf);}

static void test_extract_reference_(const char *scalar, bool expect_success, const char *outer, const char *inner){    Buffer *b = BufferNew();    size_t len = strlen(scalar);    bool success = ExtractScalarReference(b, scalar, len, false);    assert_true(success == expect_success);    assert_string_equal(outer, BufferData(b));    BufferClear(b);    success = ExtractScalarReference(b, scalar, len, true);    assert_true(success == expect_success);    assert_string_equal(inner, BufferData(b));    BufferDestroy(b);}

static void test_generic_interface(void){    /*     * This test might seem short, but it is intentional.     * All the parsing tests should be implemented directly     * on the corresponding parser test. Keep this test as     * lean as possible.     */    IPAddress *address = NULL;    Buffer *buffer = NULL;    buffer = BufferNew();    assert_true(buffer != NULL);    BufferSet(buffer, "127.0.0.1", strlen("127.0.0.1"));    address = IPAddressNew(buffer);    assert_true(address != NULL);    assert_int_equal(IP_ADDRESS_TYPE_IPV4, IPAddressType(address));    assert_string_equal("127.0.0.1", BufferData(IPAddressGetAddress(address)));    assert_int_equal(0, IPAddressGetPort(address));    assert_int_equal(0, IPAddressDestroy(&address));    BufferSet(buffer, "127.0.0.1:8080", strlen("127.0.0.1:8080"));    address = IPAddressNew(buffer);    assert_true(address != NULL);    assert_int_equal(IP_ADDRESS_TYPE_IPV4, IPAddressType(address));    assert_string_equal("127.0.0.1", BufferData(IPAddressGetAddress(address)));    assert_int_equal(8080, IPAddressGetPort(address));    assert_int_equal(0, IPAddressDestroy(&address));    BufferSet(buffer, "0:1:2:3:4:5:6:7", strlen("0:1:2:3:4:5:6:7"));    address = IPAddressNew(buffer);    assert_true(address != NULL);    assert_int_equal(IP_ADDRESS_TYPE_IPV6, IPAddressType(address));    assert_string_equal("0:1:2:3:4:5:6:7", BufferData(IPAddressGetAddress(address)));    assert_int_equal(0, IPAddressGetPort(address));    assert_int_equal(0, IPAddressDestroy(&address));    BufferSet(buffer, "[0:1:2:3:4:5:6:7]:9090", strlen("[0:1:2:3:4:5:6:7]:9090"));    address = IPAddressNew(buffer);    assert_true(address != NULL);    assert_int_equal(IP_ADDRESS_TYPE_IPV6, IPAddressType(address));    assert_string_equal("0:1:2:3:4:5:6:7", BufferData(IPAddressGetAddress(address)));    assert_int_equal(9090, IPAddressGetPort(address));    assert_int_equal(0, IPAddressDestroy(&address));    BufferDestroy(buffer);}

static void test_createBufferFrom(void){    char *data = xstrdup("this is some data");    unsigned int dataLength = strlen(data);    Buffer *buffer = BufferNewFrom(data, dataLength);    assert_true(buffer != NULL);    assert_true(buffer->buffer != NULL);    assert_string_equal(data, buffer->buffer);    assert_int_equal(buffer->mode, BUFFER_BEHAVIOR_CSTRING);    assert_int_equal(buffer->capacity, DEFAULT_BUFFER_SIZE);    assert_int_equal(buffer->used, dataLength);    assert_int_equal(buffer->beginning, 0);    assert_int_equal(buffer->end, 0);    assert_true(buffer->ref_count != NULL);    assert_int_equal(buffer->ref_count->user_count, 1);    assert_int_equal(0, BufferDestroy(&buffer));    free (data);}