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;
}
void
LineDestroy(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);
}
