TEST_F(TestIBUtilField, AliasBytestr)
{
const char s1[] = "hello";
const char s2[] = "bye";
ib_field_t *f;
const ib_bytestr_t *obs;
ib_status_t rc;
ib_bytestr_t *bs;
uint8_t *copy;
copy = (uint8_t *)ib_mm_strdup(MM(), "x");
rc = ib_field_create_bytestr_alias(&f, MM(),
IB_S2SL("foo"), copy, 0);
ASSERT_EQ(IB_OK, rc);
rc = ib_bytestr_dup_nulstr(&bs, MM(), s1);
ASSERT_EQ(IB_OK, rc);
rc = ib_field_setv(f, bs);
ASSERT_EQ(IB_OK, rc);
rc = ib_field_value(f, ib_ftype_bytestr_out(&obs));
ASSERT_EQ(IB_OK, rc);
ASSERT_EQ(strlen(s1), ib_bytestr_length(obs));
ASSERT_EQ(0, memcmp(s1,
ib_bytestr_const_ptr(obs), ib_bytestr_length(obs)) );
rc = ib_bytestr_dup_nulstr(&bs, MM(), s2);
ASSERT_EQ(IB_OK, rc);
rc = ib_field_setv(f, bs);
ASSERT_EQ(IB_OK, rc);
rc = ib_field_value(f, ib_ftype_bytestr_out(&obs));
ASSERT_EQ(IB_OK, rc);
ASSERT_EQ(strlen(s2), ib_bytestr_length(obs));
ASSERT_EQ(0, memcmp(s2,
ib_bytestr_const_ptr(obs), ib_bytestr_length(obs)) );
}
ib_status_t ib_field_create(
ib_field_t **pf,
ib_mpool_t *mp,
const char *name,
size_t nlen,
ib_ftype_t type,
void *in_pval
)
{
ib_status_t rc;
rc = ib_field_create_alias(pf, mp, name, nlen, type, NULL);
if (rc != IB_OK) {
goto failed;
}
/* Point to internal memory */
(*pf)->val->pval = &((*pf)->val->u);
rc = ib_field_setv((*pf), in_pval);
if (rc != IB_OK) {
goto failed;
}
ib_field_util_log_debug("FIELD_CREATE", (*pf));
return IB_OK;
failed:
/* Make sure everything is cleaned up on failure. */
*pf = NULL;
return rc;
}
ib_status_t ib_cfgmap_set(ib_cfgmap_t *cm,
const char *name,
void *pval)
{
IB_FTRACE_INIT(ib_cfgmap_set);
ib_field_t *f;
ib_status_t rc;
rc = ib_hash_get(cm->hash, name, (void *)&f);
if (rc != IB_OK) {
IB_FTRACE_RET_STATUS(rc);
}
rc = ib_field_setv(f, pval);
/// @todo Remove this extra debugging
switch (f->type) {
case IB_FTYPE_BYTESTR:
ib_util_log_debug(4, "SET FIELD type=%d %" IB_BYTESTR_FMT "=\"%" IB_BYTESTR_FMT "\" (%p)", f->type, IB_BYTESTRSL_FMT_PARAM(f->name,f->nlen), IB_BYTESTR_FMT_PARAM(*(ib_bytestr_t **)pval), *(void **)pval);
break;
case IB_FTYPE_NULSTR:
ib_util_log_debug(4, "SET FIELD type=%d %" IB_BYTESTR_FMT "=\"%s\" (%p)", f->type, IB_BYTESTRSL_FMT_PARAM(f->name,f->nlen), *(char **)pval, *(void **)pval);
break;
case IB_FTYPE_NUM:
ib_util_log_debug(4, "SET FIELD type=%d %" IB_BYTESTR_FMT "=%d (%p)", f->type, IB_BYTESTRSL_FMT_PARAM(f->name,f->nlen), *(int *)pval, *(void **)pval);
break;
case IB_FTYPE_UNUM:
ib_util_log_debug(4, "SET FIELD type=%d %" IB_BYTESTR_FMT "=%d (%p)", f->type, IB_BYTESTRSL_FMT_PARAM(f->name,f->nlen), *(unsigned int *)pval, *(void **)pval);
break;
}
IB_FTRACE_RET_STATUS(rc);
}
TEST_F(CoreOperatorsTest, NeTest)
{
ib_status_t status;
ib_num_t call_result;
ib_operator_inst_t *op;
ib_rule_t *rule = NULL; /* Not used by this operator. */
status = ib_operator_inst_create(ib_engine,
NULL,
rule,
IB_OP_FLAG_PHASE,
"ne",
"1",
IB_OPINST_FLAG_NONE,
&op);
ASSERT_EQ(IB_OK, status);
// call contains
ib_field_t *field;
const ib_num_t matching = 2;
const ib_num_t nonmatching = 1;
ib_field_create(
&field,
ib_engine_pool_main_get(ib_engine),
IB_FIELD_NAME("testfield"),
IB_FTYPE_NUM,
ib_ftype_num_in(&matching)
);
ib_rule_exec_t rule_exec;
memset(&rule_exec, 0, sizeof(rule_exec));
rule_exec.ib = ib_engine;
rule_exec.tx = ib_tx;
rule_exec.rule = rule;
ib_field_setv(field, ib_ftype_num_in(&matching));
status = ib_operator_execute(&rule_exec, op, field, &call_result);
ASSERT_EQ(IB_OK, status);
EXPECT_EQ(1, call_result);
ib_field_setv(field, ib_ftype_num_in(&nonmatching));
status = ib_operator_execute(&rule_exec, op, field, &call_result);
ASSERT_EQ(IB_OK, status);
EXPECT_EQ(0, call_result);
}
TEST_F(TestIBUtilField, Alias)
{
ib_num_t num1;
ib_num_t num2;
ib_float_t flt1;
ib_float_t flt2;
char *s = NULL;
const char *v;
ib_field_t *f;
ib_status_t rc;
rc = ib_field_create_alias(&f, MM(), "foo", 3,
IB_FTYPE_NULSTR,
ib_ftype_nulstr_mutable_out(&s));
ASSERT_EQ(IB_OK, rc);
v = "hello";
rc = ib_field_setv(f, ib_ftype_nulstr_in(v));
ASSERT_EQ(IB_OK, rc);
ASSERT_STREQ(v, s);
/*
* Alias a numeric field
*/
num1 = 1;
rc = ib_field_create_alias(&f, MM(), "num", 3,
IB_FTYPE_NUM,
ib_ftype_num_in(&num1));
ASSERT_EQ(IB_OK, rc);
rc = ib_field_value(f, ib_ftype_num_out(&num2));
ASSERT_EQ(IB_OK, rc);
ASSERT_EQ(num1, num2);
num1 = 3;
rc = ib_field_value(f, ib_ftype_num_out(&num2));
ASSERT_EQ(IB_OK, rc);
ASSERT_EQ(num1, num2);
/*
* Alias a floating point field
*/
flt1 = 1.1;
rc = ib_field_create_alias(&f, MM(), "flt", 3,
IB_FTYPE_FLOAT,
ib_ftype_float_in(&flt1));
ASSERT_EQ(IB_OK, rc);
rc = ib_field_value(f, ib_ftype_float_out(&flt2));
ASSERT_EQ(IB_OK, rc);
ASSERT_EQ(flt1, flt2);
flt1 = 1.5;
rc = ib_field_value(f, ib_ftype_float_out(&flt2));
ASSERT_EQ(IB_OK, rc);
ASSERT_EQ(flt1, flt2);
}
TEST_F(CoreOperatorsTest, ContainsTest)
{
ib_status_t status;
ib_num_t call_result;
ib_operator_inst_t *op;
ib_rule_t *rule = NULL; /* Not used by this operator. */
status = ib_operator_inst_create(ib_engine,
NULL,
rule,
IB_OP_FLAG_PHASE,
"contains",
"needle",
IB_OPINST_FLAG_NONE,
&op);
ASSERT_EQ(IB_OK, status);
// call contains
ib_field_t *field;
const char *matching = "data with needle in it";
const char *nonmatching = "non matching string";
ib_field_create(
&field,
ib_engine_pool_main_get(ib_engine),
IB_FIELD_NAME("testfield"),
IB_FTYPE_NULSTR,
NULL
);
ib_rule_exec_t rule_exec;
memset(&rule_exec, 0, sizeof(rule_exec));
rule_exec.ib = ib_engine;
rule_exec.rule = rule;
ib_field_setv(field, ib_ftype_nulstr_in(matching));
status = ib_operator_execute(&rule_exec, op, field, &call_result);
ASSERT_EQ(IB_OK, status);
EXPECT_EQ(1, call_result);
ib_field_setv(field, ib_ftype_nulstr_in(nonmatching));
status = ib_operator_execute(&rule_exec, op, field, &call_result);
ASSERT_EQ(IB_OK, status);
EXPECT_EQ(0, call_result);
}
TEST_F(CoreOperatorsTest, ContainsTest)
{
ib_status_t status;
ib_num_t call_result;
const ib_operator_t *op;
void *instance_data;
status = ib_operator_lookup(ib_engine, "contains", &op);
ASSERT_EQ(IB_OK, status);
status = ib_operator_inst_create(op,
ib_context_main(ib_engine),
IB_OP_CAPABILITY_NON_STREAM,
"needle",
&instance_data);
ASSERT_EQ(IB_OK, status);
// call contains
ib_field_t *field;
const char *matching = "data with needle in it";
const char *nonmatching = "non matching string";
ib_field_create(
&field,
ib_engine_pool_main_get(ib_engine),
IB_FIELD_NAME("testfield"),
IB_FTYPE_NULSTR,
NULL
);
ib_field_setv(field, ib_ftype_nulstr_in(matching));
status = ib_operator_inst_execute(op, instance_data, ib_tx, field, NULL, &call_result);
ASSERT_EQ(IB_OK, status);
EXPECT_EQ(1, call_result);
ib_field_setv(field, ib_ftype_nulstr_in(nonmatching));
status = ib_operator_inst_execute(op, instance_data, ib_tx, field, NULL, &call_result);
ASSERT_EQ(IB_OK, status);
EXPECT_EQ(0, call_result);
}
TEST_F(CoreOperatorsTest, NeTest)
{
ib_status_t status;
ib_num_t call_result;
const ib_operator_t *op;
void *instance_data;
status = ib_operator_lookup(ib_engine, "ne", &op);
ASSERT_EQ(IB_OK, status);
status = ib_operator_inst_create(op,
ib_context_main(ib_engine),
IB_OP_CAPABILITY_NON_STREAM,
"1",
&instance_data);
ASSERT_EQ(IB_OK, status);
// call contains
ib_field_t *field;
const ib_num_t matching = 2;
const ib_num_t nonmatching = 1;
ib_field_create(
&field,
ib_engine_pool_main_get(ib_engine),
IB_FIELD_NAME("testfield"),
IB_FTYPE_NUM,
ib_ftype_num_in(&matching)
);
ib_field_setv(field, ib_ftype_num_in(&matching));
status = ib_operator_inst_execute(op, instance_data, ib_tx, field, NULL, &call_result);
ASSERT_EQ(IB_OK, status);
EXPECT_EQ(1, call_result);
ib_field_setv(field, ib_ftype_num_in(&nonmatching));
status = ib_operator_inst_execute(op, instance_data, ib_tx, field, NULL, &call_result);
ASSERT_EQ(IB_OK, status);
EXPECT_EQ(0, call_result);
}
ib_status_t ib_field_setv_no_copy(
ib_field_t *f,
void *mutable_in_pval
)
{
if (f->type == IB_FTYPE_NUM || ib_field_is_dynamic(f)) {
return ib_field_setv(f, mutable_in_pval);
}
*(void **)(f->val->pval) = mutable_in_pval;
return IB_OK;
}
TEST_F(TestIBUtilField, Alias)
{
char *s = NULL;
const char *v;
ib_field_t *f;
ib_status_t rc;
rc = ib_field_create_alias(&f, MemPool(), "foo", 3, IB_FTYPE_NULSTR,
ib_ftype_nulstr_mutable_out(&s));
ASSERT_EQ(IB_OK, rc);
v = "hello";
rc = ib_field_setv(f, ib_ftype_nulstr_in(v));
ASSERT_EQ(IB_OK, rc);
ASSERT_EQ(std::string(v), std::string(s));
}
ib_status_t ib_cfgmap_set(ib_cfgmap_t *cm,
const char *name,
void *in_val)
{
ib_field_t *f;
ib_status_t rc;
rc = ib_hash_get(cm->hash, &f, name);
if (rc != IB_OK) {
return rc;
}
rc = ib_field_setv(f, in_val);
return rc;
}
// Cached version of the above dyn_get function.
static ib_status_t dyn_get_cached(
const ib_field_t *f,
void *out_value,
const void *arg,
size_t alen,
void *data
)
{
/* Call the get function */
const char* cval;
dyn_get(f, &cval, arg, alen, data);
/* Cache the value */
/* Caching does not semantically change value, so we can safely ignore
* the constness of f. */
ib_field_make_static((ib_field_t *)f);
ib_field_setv((ib_field_t *)f, ib_ftype_nulstr_in(cval));
*reinterpret_cast<const char**>(out_value) = cval;
return IB_OK;
}
TEST_F(OperatorTest, OperatorCallTest)
{
ib_status_t status;
ib_num_t call_result;
void *instance_data;
ib_operator_t *op;
const ib_operator_t *cop;
status = ib_operator_create_and_register(
&op,
ib_engine,
"test_op",
IB_OP_CAPABILITY_NON_STREAM,
test_create_fn, NULL,
NULL, NULL,
test_execute_fn, NULL
);
ASSERT_EQ(IB_OK, status);
status = ib_operator_lookup(ib_engine, "test_op", &cop);
ASSERT_EQ(IB_OK, status);
status = ib_operator_inst_create(op,
ib_context_main(ib_engine),
IB_OP_CAPABILITY_NON_STREAM,
"INVALID",
&instance_data);
ASSERT_EQ(IB_EINVAL, status);
status = ib_operator_inst_create(op,
ib_context_main(ib_engine),
IB_OP_CAPABILITY_NON_STREAM,
"data",
&instance_data);
ASSERT_EQ(IB_OK, status);
ib_field_t *field;
const char *matching = "data matching string";
const char *nonmatching = "non matching string";
ib_field_create(
&field,
ib_engine_pool_main_get(ib_engine),
IB_FIELD_NAME("testfield"),
IB_FTYPE_NULSTR,
NULL
);
ib_field_setv(field, ib_ftype_nulstr_in(matching));
status = ib_operator_inst_execute(op, instance_data, ib_tx, field, NULL, &call_result);
ASSERT_EQ(IB_OK, status);
EXPECT_EQ(1, call_result);
ib_field_setv(field, ib_ftype_nulstr_in(nonmatching));
status = ib_operator_inst_execute(op, instance_data, ib_tx, field, NULL, &call_result);
ASSERT_EQ(IB_OK, status);
EXPECT_EQ(0, call_result);
status = ib_operator_inst_destroy(op, instance_data);
ASSERT_EQ(IB_OK, status);
}
ib_status_t ib_tfn_transform_field(ib_tfn_t *tfn,
ib_field_t *f,
ib_flags_t *pflags)
{
IB_FTRACE_INIT(ib_tfn_transform);
ib_bytestr_t *bs;
char *str;
uint8_t *data_out;
size_t dlen_out;
ib_status_t rc;
switch(f->type) {
case IB_FTYPE_BYTESTR:
bs = ib_field_value_bytestr(f);
rc = tfn->transform(tfn->fndata,
f->mp,
ib_bytestr_ptr(bs),
ib_bytestr_length(bs),
&data_out,
&dlen_out,
pflags);
/* If it is modified and not done inplace, then the
* field value needs to be updated.
*/
if ( IB_TFN_CHECK_FMODIFIED(*pflags)
&& !IB_TFN_CHECK_FINPLACE(*pflags))
{
ib_bytestr_t *bs_new;
rc = ib_bytestr_alias_mem(&bs_new, f->mp, data_out, dlen_out);
if (rc != IB_OK) {
IB_FTRACE_RET_STATUS(rc);
}
rc = ib_field_setv(f, bs_new);
}
IB_FTRACE_RET_STATUS(rc);
case IB_FTYPE_NULSTR:
str = ib_field_value_nulstr(f),
rc = tfn->transform(tfn->fndata,
f->mp,
(uint8_t *)str,
strlen(str),
&data_out,
&dlen_out,
pflags);
/* If it is modified and not done inplace, then the
* field value needs to be updated.
*
* NOTE: Anytime a transformation modifies data it
* MUST NUL terminate the data and it is a bug
* if this is not done.
*/
if ( IB_TFN_CHECK_FMODIFIED(*pflags)
&& !IB_TFN_CHECK_FINPLACE(*pflags))
{
rc = ib_field_setv(f, data_out);
}
IB_FTRACE_RET_STATUS(rc);
}
IB_FTRACE_RET_STATUS(IB_EINVAL);
}
TEST_F(OperatorTest, OperatorCallTest)
{
ib_status_t status;
ib_num_t call_result;
ib_rule_t *rule = NULL; /* Unused by this operator. */
ib_operator_inst_t *op;
status = ib_operator_register(ib_engine,
"test_op",
IB_OP_FLAG_PHASE,
test_create_fn,
NULL,
test_destroy_fn,
NULL,
test_execute_fn,
NULL);
ASSERT_EQ(IB_OK, status);
status = ib_operator_inst_create(ib_engine,
NULL,
rule,
IB_OP_FLAG_PHASE,
"test_op",
"INVALID",
IB_OPINST_FLAG_NONE,
&op);
ASSERT_EQ(IB_EINVAL, status);
status = ib_operator_inst_create(ib_engine,
NULL,
rule,
IB_OP_FLAG_PHASE,
"test_op",
"data",
IB_OPINST_FLAG_NONE,
&op);
ASSERT_EQ(IB_OK, status);
ib_rule_exec_t rule_exec;
memset(&rule_exec, 0, sizeof(rule_exec));
rule_exec.ib = ib_engine;
rule_exec.rule = rule;
ib_field_t *field;
const char *matching = "data matching string";
const char *nonmatching = "non matching string";
ib_field_create(
&field,
ib_engine_pool_main_get(ib_engine),
IB_FIELD_NAME("testfield"),
IB_FTYPE_NULSTR,
NULL
);
ib_field_setv(field, ib_ftype_nulstr_in(matching));
status = ib_operator_execute(&rule_exec, op, field, &call_result);
ASSERT_EQ(IB_OK, status);
EXPECT_EQ(1, call_result);
ib_field_setv(field, ib_ftype_nulstr_in(nonmatching));
status = ib_operator_execute(&rule_exec, op, field, &call_result);
ASSERT_EQ(IB_OK, status);
EXPECT_EQ(0, call_result);
status = ib_operator_inst_destroy(op);
ASSERT_EQ(IB_OK, status);
}
void set_value(ib_field_t* f, void* in_value)
{
ib_status_t rc = ib_field_setv(f, in_value);
throw_if_error(rc);
}
