static void
S_run_basic_tests(CFCTest *test) {
CFCParcel *neato_parcel = CFCParcel_new("Neato", NULL, NULL, NULL);
CFCParcel_register(neato_parcel);
CFCType *type = CFCType_new(0, neato_parcel, "mytype_t", 0);
OK(test, CFCType_get_parcel(type) == neato_parcel, "get_parcel");
STR_EQ(test, CFCType_to_c(type), "mytype_t", "to_c");
STR_EQ(test, CFCType_get_specifier(type), "mytype_t", "get_specifier");
#define TEST_BOOL_ACCESSOR(type, name) \
OK(test, !CFCType_ ## name(type), #name " false by default");
TEST_BOOL_ACCESSOR(type, const);
TEST_BOOL_ACCESSOR(type, nullable);
TEST_BOOL_ACCESSOR(type, incremented);
TEST_BOOL_ACCESSOR(type, decremented);
TEST_BOOL_ACCESSOR(type, is_void);
TEST_BOOL_ACCESSOR(type, is_object);
TEST_BOOL_ACCESSOR(type, is_primitive);
TEST_BOOL_ACCESSOR(type, is_integer);
TEST_BOOL_ACCESSOR(type, is_floating);
TEST_BOOL_ACCESSOR(type, is_string_type);
TEST_BOOL_ACCESSOR(type, is_va_list);
TEST_BOOL_ACCESSOR(type, is_arbitrary);
TEST_BOOL_ACCESSOR(type, is_composite);
CFCBase_decref((CFCBase*)neato_parcel);
CFCBase_decref((CFCBase*)type);
CFCParcel_reap_singletons();
}
static void
S_run_void_tests(CFCTest *test) {
CFCParser *parser = CFCParser_new();
{
CFCType *type = CFCType_new_void(false);
STR_EQ(test, CFCType_get_specifier(type), "void", "get_specifier");
STR_EQ(test, CFCType_to_c(type), "void", "to_c");
OK(test, CFCType_is_void(type), "is_void");
CFCBase_decref((CFCBase*)type);
}
{
CFCType *type = CFCType_new_void(true);
STR_EQ(test, CFCType_to_c(type), "const void",
"'const' in C representation");
CFCBase_decref((CFCBase*)type);
}
{
CFCType *type = CFCTest_parse_type(test, parser, "void");
OK(test, CFCType_is_void(type), "void is_void");
CFCBase_decref((CFCBase*)type);
}
{
CFCType *type = CFCTest_parse_type(test, parser, "const void");
OK(test, CFCType_is_void(type), "const void is_void");
OK(test, CFCType_const(type), "const void is const");
CFCBase_decref((CFCBase*)type);
}
CFCBase_decref((CFCBase*)parser);
}
static void
render_html(test_batch_runner *runner)
{
char *html;
static const char markdown[] =
"foo *bar*\n"
"\n"
"paragraph 2\n";
cmark_node *doc = cmark_parse_document(markdown, sizeof(markdown) - 1,
CMARK_OPT_DEFAULT);
cmark_node *paragraph = cmark_node_first_child(doc);
html = cmark_render_html(paragraph, CMARK_OPT_DEFAULT);
STR_EQ(runner, html, "<p>foo <em>bar</em></p>\n",
"render single paragraph");
free(html);
cmark_node *string = cmark_node_first_child(paragraph);
html = cmark_render_html(string, CMARK_OPT_DEFAULT);
STR_EQ(runner, html, "foo ", "render single inline");
free(html);
cmark_node *emph = cmark_node_next(string);
html = cmark_render_html(emph, CMARK_OPT_DEFAULT);
STR_EQ(runner, html, "<em>bar</em>", "render inline with children");
free(html);
cmark_node_free(doc);
}
/**
* @brief set the parameters for the node
*/
int set_dmq_node_params(dmq_node_t *node, param_t *params)
{
str *status;
if(!params) {
LM_DBG("no parameters given\n");
return 0;
}
status = get_param_value(params, &dmq_node_status_str);
if(status) {
if(STR_EQ(*status, dmq_node_active_str)) {
node->status = DMQ_NODE_ACTIVE;
} else if(STR_EQ(*status, dmq_node_timeout_str)) {
node->status = DMQ_NODE_TIMEOUT;
} else if(STR_EQ(*status, dmq_node_disabled_str)) {
node->status = DMQ_NODE_DISABLED;
} else if(STR_EQ(*status, dmq_node_pending_str)) {
node->status = DMQ_NODE_PENDING;
} else {
LM_ERR("invalid status parameter: %.*s\n", STR_FMT(status));
goto error;
}
}
return 0;
error:
return -1;
}
static void
S_run_tests(CFCTest *test) {
CFCParser *parser = CFCParser_new();
{
CFCCBlock *block = CFCCBlock_new("int foo;");
STR_EQ(test, CFCCBlock_get_contents(block), "int foo;",
"get_contents");
CFCBase_decref((CFCBase*)block);
}
{
const char *cblock_string =
" __C__\n"
"#define FOO_BAR 1\n"
"__END_C__ ";
CFCBase *result = CFCParser_parse(parser, cblock_string);
OK(test, result != NULL, "parse cblock");
STR_EQ(test, CFCBase_get_cfc_class(result),
"Clownfish::CFC::Model::CBlock", "result class of cblock");
CFCCBlock *block = (CFCCBlock*)result;
STR_EQ(test, CFCCBlock_get_contents(block), "#define FOO_BAR 1\n",
"parse embed_c");
CFCBase_decref((CFCBase*)block);
}
CFCBase_decref((CFCBase*)parser);
}
/**
* @brief compare dmq node addresses
*/
int cmp_dmq_node(dmq_node_t *node, dmq_node_t *cmpnode)
{
if(!node || !cmpnode) {
LM_ERR("cmp_dmq_node - null node received\n");
return -1;
}
return STR_EQ(node->uri.host, cmpnode->uri.host)
&& STR_EQ(node->uri.port, cmpnode->uri.port);
}
char *test_parse_store()
{
char *resp, buf[BUFSIZE];
parsed_text *parsed = malloc(sizeof(parsed_text));
prime_buf(buf, "set");
resp = parse_store(buf, parsed);
mu_assert("set != key_error", STR_EQ(resp, "CLIENT_ERROR: no key received\r\n"));
prime_buf(buf, "set ");
resp = parse_store(buf, parsed);
mu_assert("set[space] != key_error", STR_EQ(resp, "CLIENT_ERROR: no key received\r\n"));
prime_buf(buf, "set foo");
resp = parse_store(buf, parsed);
mu_assert("set foo != flags error", STR_EQ(resp, "CLIENT_ERROR: no flags received\r\n"));
prime_buf(buf, "set foo 14hi");
resp = parse_store(buf, parsed);
mu_assert("set foo 14hi != flag convert error", STR_EQ(resp, "CLIENT_ERROR: flags not number\r\n"));
prime_buf(buf, "set foo bar");
resp = parse_store(buf, parsed);
mu_assert("set foo 14hi != flag convert error", STR_EQ(resp, "CLIENT_ERROR: flags not number\r\n"));
prime_buf(buf, "set foo 17");
resp = parse_store(buf, parsed);
mu_assert("set foo 17 != no exptime error", STR_EQ(resp, "CLIENT_ERROR: no exptime received\r\n"));
prime_buf(buf, "set foo 17 bar");
resp = parse_store(buf, parsed);
mu_assert("set foo 17 bar != exptime convert error", STR_EQ(resp, "CLIENT_ERROR: exptime not number\r\n"));
prime_buf(buf, "set foo 17 12");
resp = parse_store(buf, parsed);
mu_assert("set foo 17 12 != bytes error", STR_EQ(resp, "CLIENT_ERROR: no bytes (length) received\r\n"));
prime_buf(buf, "set foo 17 12 14ar");
resp = parse_store(buf, parsed);
mu_assert("set foo 17 12 14ar != bytes error", STR_EQ(resp, "CLIENT_ERROR: bytes not number\r\n"));
prime_buf(buf, "set foo 17 12 14");
resp = parse_store(buf, parsed);
mu_assert("set foo 17 12 14 != NULL", (resp == NULL) && (!parsed->no_reply));
prime_buf(buf, "set foo 17 12 14 noreply");
resp = parse_store(buf, parsed);
mu_assert("set foo 17 12 14 noreply != NULL", ((resp == NULL) && parsed->no_reply));
prime_buf(buf, "set foo 17 12 14 foo");
resp = parse_store(buf, parsed);
mu_assert("set foo 17 12 14 foo != tokens error", STR_EQ(resp, "CLIENT_ERROR: too many tokens sent\r\n"));
return 0;
}
int xbuff_match_type_re(str *s, xbuff_type_t *type, sr_xavp_t **addr)
{
size_t nmatch = 3;
regmatch_t matches[3];
int e;
size_t bfsz = 128;
char errbuff[128];
str tname;
str a;
xbuff_type_t t;
matches[0].rm_so = 0;
matches[0].rm_eo = s->len;
e = regexec(&xbuff_type_re,s->s,nmatch,matches,REG_STARTEND);
if (e == 0) {
tname.s = s->s + matches[1].rm_so;
tname.len = matches[1].rm_eo - matches[1].rm_so;
a.s = s->s + matches[2].rm_so;
a.len = matches[2].rm_eo - matches[1].rm_so;
if (STR_EQ(tname,xbuff_types[XBUFF_TYPE_ATOM])) {
t = XBUFF_TYPE_ATOM;
} else if (STR_EQ(tname,xbuff_types[XBUFF_TYPE_LIST])) {
t = XBUFF_TYPE_LIST;
} else if (STR_EQ(tname,xbuff_types[XBUFF_TYPE_TUPLE])) {
t = XBUFF_TYPE_TUPLE;
} else if (STR_EQ(tname,xbuff_types[XBUFF_TYPE_PID])) {
t = XBUFF_TYPE_PID;
} else if (STR_EQ(tname,xbuff_types[XBUFF_TYPE_REF])) {
t = XBUFF_TYPE_REF;
} else {
LM_ERR("BUG: unknown xbuff type");
return -1;
}
if(type) *type = t;
if (addr)
sscanf(a.s,"%lx>>",(long unsigned int *)addr);
return 0;
} else if (e != REG_NOMATCH) {
regerror(e,&xbuff_type_re,errbuff,bfsz);
LM_ERR("regexec error: %s\n",errbuff);
}
return -1;
}
char *test_parse_del()
{
char *resp, buf[BUFSIZE];
parsed_text *parsed = malloc(sizeof(parsed_text));
prime_buf(buf, "delete");
resp = parse_del(buf, parsed);
mu_assert("delete != key error", STR_EQ(resp, "CLIENT_ERROR: no key provided for delete\r\n"));
prime_buf(buf, "delete foo");
resp = parse_del(buf, parsed);
mu_assert("delete foo != NULL", ((resp == NULL) && STR_EQ("foo", parsed->key)));
return 0;
}
static void
S_run_integer_tests(CFCTest *test) {
{
CFCType *type = CFCType_new_integer(CFCTYPE_CONST, "int32_t");
OK(test, CFCType_const(type), "const");
STR_EQ(test, CFCType_get_specifier(type), "int32_t", "get_specifier");
STR_EQ(test, CFCType_to_c(type), "const int32_t",
"'const' in C representation");
CFCBase_decref((CFCBase*)type);
}
{
CFCParser *parser = CFCParser_new();
static const char *specifiers[14] = {
"bool",
"char",
"short",
"int",
"long",
"size_t",
"int8_t",
"int16_t",
"int32_t",
"int64_t",
"uint8_t",
"uint16_t",
"uint32_t",
"uint64_t"
};
for (int i = 0; i < 14; ++i) {
const char *specifier = specifiers[i];
CFCType *type;
type = CFCTest_parse_type(test, parser, specifier);
OK(test, CFCType_is_integer(type), "%s is_integer", specifier);
CFCBase_decref((CFCBase*)type);
char *const_specifier = CFCUtil_sprintf("const %s", specifier);
type = CFCTest_parse_type(test, parser, const_specifier);
OK(test, CFCType_is_integer(type), "%s is_integer",
const_specifier);
OK(test, CFCType_const(type), "%s is const", const_specifier);
FREEMEM(const_specifier);
CFCBase_decref((CFCBase*)type);
}
CFCBase_decref((CFCBase*)parser);
}
}
/**
* @brief notification response callback
*/
int notification_resp_callback_f(struct sip_msg* msg, int code,
dmq_node_t* node, void* param)
{
int ret;
int nodes_recv;
LM_DBG("notification_callback_f triggered [%p %d %p]\n", msg, code, param);
if(code == 200) {
nodes_recv = extract_node_list(node_list, msg);
LM_DBG("received %d new or changed nodes\n", nodes_recv);
if (dmq_init_callback_done && !*dmq_init_callback_done) {
*dmq_init_callback_done = 1;
run_init_callbacks();
}
} else if(code == 408) {
/* deleting node - the server did not respond */
LM_ERR("deleting server %.*s because of failed request\n", STR_FMT(&node->orig_uri));
if (STR_EQ(node->orig_uri, dmq_notification_address)) {
LM_ERR("not deleting notification_peer\n");
return 0;
}
ret = del_dmq_node(node_list, node);
LM_DBG("del_dmq_node returned %d\n", ret);
}
return 0;
}
/**
* creates and push a table for the key name in xavp
* if simple_flag is != 0 it will return only the first value
*/
static void lua_sr_push_xavp_name_table(lua_State *L, sr_xavp_t *xavp,
str name, const int simple_flag)
{
lua_Number i = 1;
lua_Number elem = 1;
sr_xavp_t *avp = xavp;
while(avp!=NULL&&!STR_EQ(avp->name,name))
{
avp = avp->next;
}
if(simple_flag==0) lua_newtable(L);
while(avp!=NULL){
if(simple_flag==0) lua_pushnumber(L, elem);
switch(avp->val.type) {
case SR_XTYPE_NULL:
lua_pushnil(L);
break;
case SR_XTYPE_INT:
i = avp->val.v.i;
lua_pushnumber(L, i);
break;
case SR_XTYPE_STR:
lua_pushlstring(L, avp->val.v.s.s, avp->val.v.s.len);
break;
case SR_XTYPE_TIME:
case SR_XTYPE_LONG:
case SR_XTYPE_LLONG:
case SR_XTYPE_DATA:
lua_pushnil(L);
LM_WARN("XAVP type:%d value not supported\n", avp->val.type);
break;
case SR_XTYPE_XAVP:
if(!lua_sr_push_xavp_table(L,avp->val.v.xavp, simple_flag)){
LM_ERR("xavp:%.*s subtable error. Nil value added\n",
avp->name.len, avp->name.s);
lua_pushnil(L);
}
break;
default:
LM_ERR("xavp:%.*s unknown type: %d. Nil value added\n",
avp->name.len, avp->name.s, avp->val.type);
lua_pushnil(L);
break;
}
if(simple_flag==0)
{
lua_rawset(L, -3);
elem = elem + 1;
avp = xavp_get_next(avp);
}
else {
lua_setfield(L, -2, name.s);
avp = NULL;
}
}
if(simple_flag==0) lua_setfield(L, -2, name.s);
}
static DWORD PluginLoadGenericMultiple(
_Inout_ LPTSTR names,
_Inout_ PBYTE pluginsArray,
_In_ DWORD max,
_In_ PLUGIN_TYPE const * const type
) {
DWORD count = 0;
DWORD i = 0;
LPTSTR pluginName = NULL;
LPTSTR ctx = NULL;
PPLUGIN_HEAD plugin = NULL;
while (StrNextToken(names, _T(","), &ctx, &pluginName)) {
LOG(Info, SUB_LOG(_T("Loading %s <%s>")), type->name, pluginName);
if (count >= max) {
FATAL(_T("Cannot load more than <%u> %ss"), max, type->name);
}
for (i = 0; i < count; i++) {
if (STR_EQ(pluginName, PLUGIN_GET_NAME((PPLUGIN_HEAD)(pluginsArray + (i * type->size))))) {
FATAL(_T("%s <%s> is already loaded"), type->name, pluginName);
}
}
plugin = (PPLUGIN_HEAD)(pluginsArray + (count * type->size));
PLUGIN_SET_NAME(plugin, pluginName);
PLUGIN_SET_TYPE(plugin, type);
PluginLoadGenericSingle(plugin);
count++;
}
return count;
}
/*!
* \brief Helper function that outputs the dialogs belonging to a given profile via the RPC interface
* \see rpc_profile_print_dlgs
* \see rpc_profile_w_value_print_dlgs
* \param rpc RPC node that should be filled
* \param c RPC void pointer
* \param profile_name the given profile
* \param value the given profile value
* \param with_context if 1 then the dialog context will be also printed
*/
static void internal_rpc_profile_print_dlgs(rpc_t *rpc, void *c, str *profile_name,
str *value) {
dlg_profile_table_t *profile;
dlg_profile_hash_t *ph;
unsigned int i;
profile = search_dlg_profile( profile_name );
if (!profile) {
rpc->fault(c, 404, "Profile not found: %.*s",
profile_name->len, profile_name->s);
return;
}
/* go through the hash and print the dialogs */
if (profile->has_value==0)
value=NULL;
lock_get( &profile->lock );
for ( i=0 ; i< profile->size ; i++ ) {
ph = profile->entries[i].first;
if(ph) {
do {
if ((!value || (STR_EQ(*value, ph->value))) && ph->dlg) {
/* print dialog */
internal_rpc_print_dlg(rpc, c, ph->dlg, 0);
}
/* next */
ph=ph->next;
}while(ph!=profile->entries[i].first);
}
lock_release(&profile->lock);
}
}
static void
version(test_batch_runner *runner)
{
INT_EQ(runner, cmark_version, CMARK_VERSION, "cmark_version");
STR_EQ(runner, cmark_version_string, CMARK_VERSION_STRING,
"cmark_version_string");
}
int _cfgt_get_obj_avp_vals(str name, sr_xavp_t *xavp, srjson_doc_t *jdoc, srjson_t **jobj)
{
sr_xavp_t *avp = NULL;
srjson_t *jobjt = NULL;
*jobj = srjson_CreateArray(jdoc);
if(*jobj==NULL)
{
LM_ERR("cannot create json object\n");
return -1;
}
avp = xavp;
while(avp!=NULL&&!STR_EQ(avp->name,name))
{
avp = avp->next;
}
while(avp!=NULL)
{
_cfgt_get_obj_xavp_val(avp, jdoc, &jobjt);
srjson_AddItemToArray(jdoc, *jobj, jobjt);
jobjt = NULL;
avp = xavp_get_next(avp);
}
return 0;
}
void
grg_recent_dox_push (const guchar * file)
{
GSList *cur, *tmp;
if (file == NULL)
return;
tmp = grg_recent_dox;
while (tmp)
{
cur = tmp;
tmp = tmp->next;
if (STR_EQ (cur->data, file) ||
(g_slist_position (grg_recent_dox, cur) >=
GRG_RECENT_LIMIT - 1))
{
grg_recent_dox =
g_slist_remove_link (grg_recent_dox, cur);
g_free (cur->data);
g_slist_free_1 (cur);
}
}
grg_recent_dox =
g_slist_prepend (grg_recent_dox, g_strdup ((guchar *) file));
recent_dox_save ();
grg_menu_update ();
}
/*true if the action gets performed*/
gboolean
grg_attachment_change_comment (GtkWidget * parent)
{
GList *tmp = ((struct grg_entry *) current->data)->attach;
struct grg_attachment *att;
gchar *comment;
while (tmp && ((struct grg_attachment*) tmp->data)->ID != current_attach_ID)
tmp = tmp->next;
if (!tmp)
return FALSE;
att = (struct grg_attachment *) tmp->data;
comment = grg_input_dialog (_("Enter comment"),
_("Please enter a comment for this\nfile (max. 32 chars)"),
att->comment, FALSE, parent);
if (!comment)
return FALSE;
if (STR_EQ (comment, ""))
comment = g_strdup (_("none"));
GRGAFREE (att->comment);
att->comment = comment;
return TRUE;
}
int
sca_event_from_str( str *event_str )
{
int event = SCA_EVENT_TYPE_UNKNOWN;
if ( event_str == NULL || event_str->s == NULL ) {
return( SCA_EVENT_TYPE_UNKNOWN );
}
if ( STR_EQ( *event_str, SCA_EVENT_NAME_CALL_INFO )) {
event = SCA_EVENT_TYPE_CALL_INFO;
} else if ( STR_EQ( *event_str, SCA_EVENT_NAME_LINE_SEIZE )) {
event = SCA_EVENT_TYPE_LINE_SEIZE;
}
return( event );
}
struct CFCMethod*
CFCTest_parse_method(CFCTest *test, CFCParser *parser, const char *src) {
CFCBase *result = CFCParser_parse(parser, src);
OK(test, result != NULL, "parse '%s'", src);
STR_EQ(test, CFCBase_get_cfc_class(result),
"Clownfish::CFC::Model::Method", "result class of '%s'", src);
return (struct CFCMethod*)result;
}
struct CFCClass*
CFCTest_parse_class(CFCTest *test, CFCParser *parser, const char *src) {
CFCBase *result = CFCParser_parse(parser, src);
OK(test, result != NULL, "parse class");
STR_EQ(test, CFCBase_get_cfc_class(result),
"Clownfish::CFC::Model::Class", "result class");
return (struct CFCClass*)result;
}
static void
test_md_to_html(test_batch_runner *runner, const char *markdown,
const char *expected_html, const char *msg)
{
char *html = cmark_markdown_to_html(markdown, strlen(markdown));
STR_EQ(runner, html, expected_html, msg);
free(html);
}
static int
parse_options(int ac, char **av) {
extern char *optarg;
extern int optind;
int c;
while ((c=getopt_long(ac, av, "+hrt:", longopts, NULL)) != -1) {
switch (c) {
case 'r':
recur = 1;
break;
case 't':
if (STR_EQ(optarg,"virtual"))
timer_type = ITIMER_VIRTUAL;
else if (STR_EQ(optarg,"cpu")) {
xcpu = 1;
}
else if (STR_EQ(optarg,"profile"))
timer_type = ITIMER_PROF;
else if (STR_EQ(optarg,"real"))
timer_type = ITIMER_REAL;
else
usage("Unknown timer type\n");
break;
case 'h':
usage(NULL);
break; /* not reached */
case 'V':
printf(VERSION_STR);
exit(0);
break;
default:
break;
}
}
if (xcpu && recur)
usage("cpu timer may not recur\n");
if (! av[optind] || !av[optind+1])
usage("Error: missing required parameter\n");
return optind;
}
static void
S_run_va_list_tests(CFCTest *test) {
{
CFCType *type = CFCType_new_va_list();
STR_EQ(test, CFCType_get_specifier(type), "va_list",
"specifier defaults to 'va_list'");
STR_EQ(test, CFCType_to_c(type), "va_list", "to_c");
CFCBase_decref((CFCBase*)type);
}
{
CFCParser *parser = CFCParser_new();
CFCType *type = CFCTest_parse_type(test, parser, "va_list");
OK(test, CFCType_is_va_list(type), "is_va_list");
CFCBase_decref((CFCBase*)type);
CFCBase_decref((CFCBase*)parser);
}
}
char *test_parse_get()
{
char *resp, buf[BUFSIZE];
parsed_text *parsed = malloc(sizeof(parsed_text));
prime_buf(buf, "get");
resp = parse_get(buf, parsed);
mu_assert("get != keys provided error", STR_EQ(resp, "CLIENT_ERROR: no keys provided in get command\r\n"));
prime_buf(buf, "get foo");
resp = parse_get(buf, parsed);
mu_assert("get foo != NULL", ((resp == NULL) && STR_EQ("foo", parsed->keys[0])));
prime_buf(buf, "gets foo bar");
resp = parse_get(buf, parsed);
mu_assert("get foo bar != NULL", ((resp == NULL) && STR_EQ("foo", parsed->keys[0]) && STR_EQ("bar", parsed->keys[1])));
return 0;
}
/**
* Searches our internal unit label mapping for the unit associated with
* the given unit label.
* @param label The unit label to search for.
* @return The unit if found, UNIT_UNKNOWN otherwise.
*/
enum unit units_get_unit(const char* label)
{
if (!label)
return UNIT_UNKNOWN;
for (int i = 0; i < ARRAY_LEN(unit_label_map); ++i) {
if (STR_EQ(unit_label_map[i].label, label))
return unit_label_map[i].unit;
}
return UNIT_UNKNOWN;
}
static int
severity_map(const struct syslog_names *table, char *name)
{
const struct syslog_names *t;
for (t = table; t->name; t++)
if (STR_EQ(t->name, name))
return (t->value);
tcpd_jump("bad syslog facility or severity: \"%s\"", name);
/* NOTREACHED */
return -1;
}
/* {{{ scalar_is_null(const char *,size_t,yaml_event_t)
* Does this scalar encode a NULL value?
*
* specification is found at http://yaml.org/type/null.html.
*/
int
scalar_is_null(const char *value, size_t length,
const yaml_event_t *event)
{
if (NULL != event && event->data.scalar.quoted_implicit) {
return 0;
}
if (NULL == event || event->data.scalar.plain_implicit) {
if ((length == 1 && *value == '~') || length == 0 ||
STR_EQ("NULL", value) || STR_EQ("Null", value) ||
STR_EQ("null", value)) {
return 1;
}
} else if (NULL != event && SCALAR_TAG_IS((*event), YAML_NULL_TAG)) {
return 1;
}
return 0;
}
static void
S_run_arbitrary_tests(CFCTest *test) {
{
CFCParcel *neato_parcel = CFCParcel_new("Neato", NULL, NULL, NULL);
CFCParcel_register(neato_parcel);
CFCType *foo = CFCType_new_arbitrary(neato_parcel, "foo_t");
STR_EQ(test, CFCType_get_specifier(foo), "foo_t", "get_specifier");
STR_EQ(test, CFCType_to_c(foo), "foo_t", "to_c");
CFCType *twin = CFCType_new_arbitrary(neato_parcel, "foo_t");
OK(test, CFCType_equals(foo, twin), "equals");
CFCType *compare_t
= CFCType_new_arbitrary(neato_parcel, "Sort_compare_t");
OK(test, !CFCType_equals(foo, compare_t),
"equals spoiled by different specifier");
CFCBase_decref((CFCBase*)neato_parcel);
CFCBase_decref((CFCBase*)foo);
CFCBase_decref((CFCBase*)compare_t);
CFCBase_decref((CFCBase*)twin);
}
{
CFCParser *parser = CFCParser_new();
static const char *specifiers[2] = { "foo_t", "Sort_compare_t" };
for (int i = 0; i < 2; ++i) {
const char *specifier = specifiers[i];
CFCType *type = CFCTest_parse_type(test, parser, specifier);
OK(test, CFCType_is_arbitrary(type), "arbitrary type %s",
specifier);
CFCBase_decref((CFCBase*)type);
}
CFCBase_decref((CFCBase*)parser);
}
CFCParcel_reap_singletons();
}
static void
S_run_tests(CFCTest *test) {
{
CFCFileSpec *file_spec
= CFCFileSpec_new("Clownfish/_include", "Stuff/Thing", ".cfh", 0);
STR_EQ(test, CFCFileSpec_get_source_dir(file_spec),
"Clownfish/_include", "get_source_dir");
STR_EQ(test, CFCFileSpec_get_path_part(file_spec),
"Stuff/Thing", "get_path_part");
OK(test, !CFCFileSpec_included(file_spec), "not included");
CFCBase_decref((CFCBase*)file_spec);
}
{
CFCFileSpec *file_spec
= CFCFileSpec_new("Clownfish/_include", "Stuff/Thing", ".cfh", 1);
OK(test, CFCFileSpec_included(file_spec), "included");
CFCBase_decref((CFCBase*)file_spec);
}
}
