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

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));}

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_createBuffer(void **state){    Buffer *buffer = NULL;    assert_int_equal(0, BufferNew(&buffer));    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(-1, BufferNew(NULL));}

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 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);}

Buffer *StringSetToBuffer(StringSet *set, const char delimiter){    Buffer *buf = BufferNew();    StringSetIterator it = StringSetIteratorInit(set);    const char *element = NULL;    int pos = 0;    int size = StringSetSize(set);    char minibuf[2];    minibuf[0] = delimiter;    minibuf[1] = '/0';    while ((element = StringSetIteratorNext(&it)))    {        BufferAppend(buf, element, strlen(element));        if (pos < size-1)        {            BufferAppend(buf, minibuf, sizeof(char));        }        pos++;    }    return buf;}

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

void DoExtDiskSpace(tBuffer *bIn, tBuffer *bOut, u_int32_t id){	struct STATFS stfs;	tFSPath	*realPath;	char *path;	path = convertFromUtf8(BufferGetString(bIn), 1);	realPath = FSCheckPath(path);	DEBUG((MYLOG_DEBUG, "[DoExtDiskSpaceOpenSSH]Path: %s", path));	if (realPath != NULL && !HAS_BIT(gl_var->flagsDisable, SFTP_DISABLE_STATSFS))	{		DEBUG((MYLOG_DEBUG, "[DoExtDiskSpaceOpenSSH]Realpath: %s", realPath->realPath));		if (STATFS(realPath->realPath, &stfs) == 0)		{			tBuffer *b;			b = BufferNew();			BufferPutInt8(b, SSH2_FXP_EXTENDED_REPLY);			BufferPutInt32(b, id);			BufferPutInt64(b, (u_int64_t) stfs.f_blocks * (u_int64_t) stfs.f_bsize);			BufferPutInt64(b, (u_int64_t) stfs.f_bfree * (u_int64_t) stfs.f_bsize);			BufferPutInt64(b, 0);			BufferPutInt64(b, (u_int64_t) stfs.f_bavail * (u_int64_t) stfs.f_bsize);			BufferPutInt32(b, stfs.f_bsize);			BufferPutPacket(bOut, b);		}		else			SendStatus(bOut, id, errnoToPortable(errno));	}	else		SendStatus(bOut, id, SSH2_FX_PERMISSION_DENIED);	FSDestroyPath(realPath);	free(path);}

Rval ExpandBundleReference(EvalContext *ctx,                           const char *ns, const char *scope,                           Rval rval){    // Allocates new memory for the copy    switch (rval.type)    {    case RVAL_TYPE_SCALAR:        {            Buffer *buffer = BufferNew();            ExpandScalar(ctx, ns, scope, RvalScalarValue(rval), buffer);            return (Rval) { BufferClose(buffer), RVAL_TYPE_SCALAR };        }    case RVAL_TYPE_FNCALL:        return (Rval) {ExpandFnCall(ctx, ns, scope, RvalFnCallValue(rval)), RVAL_TYPE_FNCALL};    case RVAL_TYPE_CONTAINER:    case RVAL_TYPE_LIST:    case RVAL_TYPE_NOPROMISEE:         return RvalNew(NULL, RVAL_TYPE_NOPROMISEE);    }    assert(false);    return RvalNew(NULL, RVAL_TYPE_NOPROMISEE);}

    static PyObject *WindowGetattr(PyObject *self, char *name){    WindowObject *this = (WindowObject *)(self);    if (CheckWindow(this))	return NULL;    if (strcmp(name, "buffer") == 0)	return (PyObject *)BufferNew(this->win->w_buffer);    else if (strcmp(name, "cursor") == 0)    {	pos_T *pos = &this->win->w_cursor;	return Py_BuildValue("(ll)", (long)(pos->lnum), (long)(pos->col));    }    else if (strcmp(name, "height") == 0)	return Py_BuildValue("l", (long)(this->win->w_height));#ifdef FEAT_VERTSPLIT    else if (strcmp(name, "width") == 0)	return Py_BuildValue("l", (long)(W_WIDTH(this->win)));#endif    else if (strcmp(name,"__members__") == 0)	return Py_BuildValue("[sss]", "buffer", "cursor", "height");    else	return Py_FindMethod(WindowMethods, self, name);}

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 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);}

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 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    DoAdminStats(tStats *stats){  u_int32_t	lastRefresh;  tBuffer	*b;  lastRefresh = BufferGetInt32(bIn);  b = BufferNew();  BufferPutInt8FAST(b, SSH_ADMIN_STATS_REPLY);  StatsSend(stats, lastRefresh, b);  BufferPutPacket(bOut, b);  DEBUG((MYLOG_DEBUG, "[DoAdminStats]Last refresh :%u", lastRefresh));  BufferDelete(b);}

void SendAttributes(tBuffer *bOut, u_int32_t id, const tAttributes *a, const char *file){	tBuffer *b;	b = BufferNew();	if (b != NULL)	{		BufferPutInt8FAST(b, SSH2_FXP_ATTRS);		BufferPutInt32(b, id);		EncodeAttributes(b, a, file);		BufferPutPacket(bOut, b);		BufferDelete(b);	}}

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);}

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;}

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);}

void	DoAdminServerGetStatus(){  struct stat	st;  tBuffer		*b;  char		state;    b = BufferNew();  BufferPutInt8FAST(b, SSH_ADMIN_SERVER_GET_STATUS_REPLY);  if (stat(SHUTDOWN_FILE, &st) == -1)    state = 1;  else    state = 0;  BufferPutInt8(b, state);  BufferPutPacket(bOut, b);  BufferDelete(b);  DEBUG((MYLOG_DEBUG, "[DoAdminServerGetStatus]state:'%i'", state));}

static void DoExtDiskSpaceOpenSSH_Path(tBuffer *bOut, u_int32_t id, const char *path){	struct STATFS stfs;	tFSPath	*realPath;	DEBUG((MYLOG_DEBUG, "[DoExtDiskSpaceOpenSSH_Path]Path: %s", path));	realPath = FSCheckPath(path);	if (realPath != NULL && !HAS_BIT(gl_var->flagsDisable, SFTP_DISABLE_STATSFS))	{		DEBUG((MYLOG_DEBUG, "[DoExtDiskSpaceOpenSSH_Path]Realpath: %s", realPath->realPath));		if (STATFS(realPath->realPath, &stfs) == 0)		{			tBuffer *b;			b = BufferNew();			BufferPutInt8(b, SSH2_FXP_EXTENDED_REPLY);			BufferPutInt32(b, id);			BufferPutInt64(b, stfs.f_bsize); /* file system block size */			BufferPutInt64(b, stfs.f_frsize); /* fundamental fs block size */			BufferPutInt64(b, stfs.f_blocks); /* number of blocks (unit f_frsize) */			BufferPutInt64(b, stfs.f_bfree); /* free blocks in file system */			BufferPutInt64(b, stfs.f_bavail); /* free blocks for non-root */			BufferPutInt64(b, stfs.f_files); /* total file inodes */			BufferPutInt64(b, stfs.f_ffree); /* free file inodes */			BufferPutInt64(b, stfs.f_favail); /* free file inodes for to non-root */			BufferPutInt64(b, stfs.f_fsid); /* file system id */			BufferPutInt64(b, stfs.f_flag); /* bit mask of f_flag values */			BufferPutInt64(b, stfs.f_namemax); /* maximum filename length */			BufferPutPacket(bOut, b);			BufferDelete(b);		}		else		{			DEBUG((MYLOG_DEBUG, "[DoExtDiskSpaceOpenSSH_Path]error: %s", strerror(errno)));			SendStatus(bOut, id, errnoToPortable(errno));		}	}	else	{		DEBUG((MYLOG_DEBUG, "[DoExtDiskSpaceOpenSSH_Path]FSCheckPath failed"));		SendStatus(bOut, id, SSH2_FX_PERMISSION_DENIED);	}	FSDestroyPath(realPath);}

void	DoAdminConfigGet(){	struct stat	st;	u_int32_t	status = SSH2_FX_FAILURE;	int			fd;	if (stat(CONFIG_FILE, &st) != -1 && (fd = open(CONFIG_FILE, O_RDONLY)) >= 0)	{		u_int32_t	r;		tBuffer		*b = BufferNew();		char		*buffer;		BufferPutInt8FAST(b, SSH2_FXP_DATA);		BufferPutInt32(b, 0);		if ((buffer = malloc(st.st_size)) != NULL)		{			r = read(fd, buffer, st.st_size);			BufferPutData(b, buffer, r);			free(buffer);			status = SSH2_FX_OK;		}		xclose(fd);		if (stat("/etc/shells", &st) != -1 && (fd = open("/etc/shells", O_RDONLY)) >= 0)		{			if ((buffer = malloc(st.st_size)) != NULL)			{				r = read(fd, buffer, st.st_size);				BufferPutData(b, buffer, r);				free(buffer);			}			else				BufferPutInt32(b, 0);			xclose(fd);		}		if (status == SSH2_FX_OK)			BufferPutPacket(bOut, b);		BufferDelete(b);	}	else		status = errnoToPortable(errno);	DEBUG((MYLOG_DEBUG, "[DoAdminConfigGet]status: %i", status));	if (status != SSH2_FX_OK)		SendStatus(bOut, 0, status);}

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

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

static void test_zeroBuffer(void **state){    char element0[] = "element0";    unsigned int element0size = strlen(element0);    const char *element0pointer = NULL;    Buffer *buffer = NULL;    assert_int_equal(0, BufferNew(&buffer));    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));    assert_true(element0pointer == buffer->buffer);    BufferZero(NULL);    assert_int_equal(0, BufferDestroy(&buffer));}

static void test_extract_scalar_prefix(){    Buffer *b = BufferNew();    assert_int_equal(sizeof("hello ") - 1, ExtractScalarPrefix(b, "hello $(world) xy", sizeof("hello $(world) xy") -1));    assert_string_equal("hello ", BufferData(b));    BufferClear(b);    assert_int_equal(sizeof("hello (world) xy") -1, ExtractScalarPrefix(b, "hello (world) xy", sizeof("hello (world) xy") -1));    assert_string_equal("hello (world) xy", BufferData(b));    BufferClear(b);    assert_int_equal(sizeof("hello$)") -1, ExtractScalarPrefix(b, "hello$)$(world)xy", sizeof("hello$)$(world)xy") -1));    assert_string_equal("hello$)", BufferData(b));    BufferClear(b);    assert_int_equal(0, ExtractScalarPrefix(b, "", 0));    assert_string_equal("", BufferData(b));    BufferDestroy(b);}

Buffer* BufferFilter(Buffer *buffer, BufferFilterFn filter, const bool invert){    assert(buffer);    Buffer *filtered = BufferNew();    for (unsigned int i = 0; i < buffer->used; ++i)    {        bool test = (*filter)(buffer->buffer[i]);        if (invert)        {            test = !test;        }        if (test)        {            BufferAppendChar(filtered, buffer->buffer[i]);        }    }    return filtered;}