static int
replace_filter(DnfSack *sack, struct _Filter **fp, int keyname, int cmp_type,
const char *match)
{
if (*fp == NULL)
*fp = filter_create(1);
else
filter_reinit(*fp, 1);
struct _Filter *f = *fp;
f->keyname = keyname;
f->cmp_type = cmp_type;
if (keyname == HY_PKG_PROVIDES && cmp_type != HY_GLOB) {
f->match_type = _HY_RELDEP;
DnfReldep *reldep = reldep_from_str (sack, match);
if (reldep == NULL) {
filter_free(*fp);
*fp = NULL;
return DNF_ERROR_BAD_SELECTOR;
}
f->matches[0].reldep = reldep;
return 0;
}
f->match_type = _HY_STR;
f->matches[0].str = g_strdup(match);
return 0;
}
TEST(filter, match_false){
char * filter_str = my_strdup("(&(test_attr1=attr1)(&(test_attr2=attr2)(test_attr3=attr3)))");
filter_pt filter = filter_create(filter_str);
properties_pt props = properties_create();
char * key = my_strdup("test_attr1");
char * val = my_strdup("attr1");
char * key2 = my_strdup("test_attr2");
char * val2 = my_strdup("attr2");
properties_set(props, key, val);
properties_set(props, key2, val2);
bool result = true;
filter_match(filter, props, &result);
CHECK_FALSE(result);
//cleanup
properties_destroy(props);
filter_destroy(filter);
free(filter_str);
free(key);
free(key2);
free(val);
free(val2);
mock().checkExpectations();
}
TEST(filter, match_filter){
char * filter_str = my_strdup("(&(test_attr1=attr1)(|(test_attr2=attr2)(test_attr3=attr3)))");
char * compareTo_str = my_strdup("(&(test_attr1=attr1)(|(test_attr2=attr2)(test_attr3=attr3)))");
filter_pt filter = filter_create(filter_str);
filter_pt compareTo = filter_create(compareTo_str);
bool result;
filter_match_filter(filter, compareTo, &result);
//cleanup
filter_destroy(filter);
filter_destroy(compareTo);
free(filter_str);
free(compareTo_str);
mock().checkExpectations();
}
TEST(filter, create_fail_invalid_closing_brackets){
char * filter_str;
filter_pt get_filter;
//test missing closing brackets in substring
mock().expectNCalls(6, "framework_log");
filter_str = my_strdup("(&(test_attr1=attr1)(|(test_attr2=attr2)(test_attr3=at(tr3)))");
get_filter = filter_create(filter_str);
POINTERS_EQUAL(NULL, get_filter);
free(filter_str);
mock().checkExpectations();
//test missing closing brackets in value
mock().expectNCalls(5, "framework_log");
filter_str = my_strdup("(&(test_attr1=attr1)(|(test_attr2=attr2)(test_attr3>=att(r3)))");
get_filter = filter_create(filter_str);
POINTERS_EQUAL(NULL, get_filter);
free(filter_str);
mock().checkExpectations();
}
int streamdecode_init(struct stream_state **sp, struct audio_state *as, void *ud, streamdecode_callback *cb, int channel)
{
if (channel != 0 && channel != 1)
return -1;
struct stream_state *s = *sp = malloc(sizeof *s);
const int len = ((int)SAMPLES_PER_BIT(as)) | 1;
struct argset {
enum filter_type type;
double freq;
int len;
int rate;
double att;
} args[][3] = {
{ { FILTER_TYPE_LOW_PASS , bell103_freqs[0][1] + 300, len, as->sample_rate, 21 },
{ FILTER_TYPE_LOW_PASS , bell103_freqs[0][0] + 100, len, as->sample_rate, 21 },
{ FILTER_TYPE_HIGH_PASS, bell103_freqs[0][0] + 100, len, as->sample_rate, 21 }, },
{ { FILTER_TYPE_HIGH_PASS, bell103_freqs[1][0] - 300, len, as->sample_rate, 21 },
{ FILTER_TYPE_LOW_PASS , bell103_freqs[1][0] + 100, len, as->sample_rate, 21 },
{ FILTER_TYPE_HIGH_PASS, bell103_freqs[1][0] + 100, len, as->sample_rate, 21 }, },
};
s->cb = cb;
s->userdata = ud;
s->state = STATE_NOSYNC;
s->as = *as;
// should stop hard-coding channel 0
const struct argset *arg = args[channel];
s->chan = filter_create(arg[0].type, arg[0].freq, arg[0].len, arg[0].rate, arg[0].att);
s->bit[0] = filter_create(arg[1].type, arg[1].freq, arg[1].len, arg[1].rate, arg[1].att);
s->bit[1] = filter_create(arg[2].type, arg[2].freq, arg[2].len, arg[2].rate, arg[2].att);
// depends on IEEE-754-type zeros
s->ehist[0] = calloc(WINDOW_SIZE(&s->as), sizeof *s->ehist[0]);
s->ehist[1] = calloc(WINDOW_SIZE(&s->as), sizeof *s->ehist[1]);
s->tick = 0;
s->levhist = -1;
s->gbltick = 0;
return 0;
}
SPAN_DECLARE(cfilter_t *) cfilter_create(fspec_t *fs)
{
cfilter_t *cfi;
if ((cfi = (cfilter_t *) malloc(sizeof(*cfi))))
{
if ((cfi->ref = filter_create(fs)) == NULL)
{
free(cfi);
return NULL;
}
if ((cfi->imf = filter_create(fs)) == NULL)
{
free(cfi->ref);
free(cfi);
return NULL;
}
}
return cfi;
}
/**
* Initialize the J2EE-NSAPI filter subsystem.
*/
PRStatus j2eefilter_init(JNIEnv* env)
{
FilterMethods methods = FILTER_METHODS_INITIALIZER;
methods.insert = j2eefilter_method_insert;
methods.remove = j2eefilter_method_remove;
methods.read = j2eefilter_method_read;
methods.write = j2eefilter_method_write;
methods.writev = j2eefilter_method_writev;
methods.sendfile = j2eefilter_method_sendfile;
methods.flush = j2eefilter_method_flush;
// Create an NSAPI filter that will call OutputStream.write
_j2eefilter = filter_create("j2ee-filter", FILTER_SUBREQUEST_BOUNDARY, &methods);
if (!_j2eefilter)
return PR_FAILURE;
// Lookup HttpServletResponse methods
jclass response_class = NSJavaUtil::findClassGlobal(env, "javax/servlet/http/HttpServletResponse");
if (!response_class)
return PR_FAILURE;
_response_setStatus = env->GetMethodID(response_class, "setStatus", "(I)V");
if (!_response_setStatus)
return PR_FAILURE;
_response_setHeader = env->GetMethodID(response_class, "setHeader", "(Ljava/lang/String;Ljava/lang/String;)V");
if (!_response_setHeader)
return PR_FAILURE;
_response_addHeader = env->GetMethodID(response_class, "addHeader", "(Ljava/lang/String;Ljava/lang/String;)V");
if (!_response_addHeader)
return PR_FAILURE;
_response_flushBuffer = env->GetMethodID(response_class, "flushBuffer", "()V");
if (!_response_flushBuffer)
return PR_FAILURE;
// Lookup InputStream.read
jclass inputstream_class = NSJavaUtil::findClassGlobal(env, "java/io/InputStream");
if (!inputstream_class)
return PR_FAILURE;
_inputstream_read = env->GetMethodID(inputstream_class, "read", "([BII)I");
if (!_inputstream_read)
return PR_FAILURE;
// Lookup OutputStream methods
jclass outputstream_class = NSJavaUtil::findClassGlobal(env, "java/io/OutputStream");
if (!outputstream_class)
return PR_FAILURE;
_outputstream_write = env->GetMethodID(outputstream_class, "write", "([BII)V");
if (!_outputstream_write)
return PR_FAILURE;
_outputstream_flush = env->GetMethodID(outputstream_class, "flush", "()V");
if (!_outputstream_flush)
return PR_FAILURE;
return PR_SUCCESS;
}
celix_status_t wiringTopologyManager_wiringEndpointListenerAdded(void* handle, service_reference_pt reference, void* service) {
celix_status_t status = CELIX_SUCCESS;
wiring_topology_manager_pt manager = handle;
char *scope = NULL;
char* wtm = NULL;
serviceReference_getProperty(reference, (char *) INAETICS_WIRING_ENDPOINT_LISTENER_SCOPE, &scope);
serviceReference_getProperty(reference, "WTM", &wtm);
if (wtm != NULL && strcmp(wtm, "true") == 0) {
printf("WTM: Ignoring own ENDPOINT_LISTENER\n");
}
else {
status = celixThreadMutex_lock(&manager->listenerListLock);
if (status == CELIX_SUCCESS) {
hashMap_put(manager->listenerList, reference, NULL);
celixThreadMutex_unlock(&manager->listenerListLock);
}
filter_pt filter = filter_create(scope);
status = celixThreadMutex_lock(&manager->exportedWiringEndpointsLock);
if (status == CELIX_SUCCESS) {
hash_map_iterator_pt propIter = hashMapIterator_create(manager->exportedWiringEndpoints);
while (hashMapIterator_hasNext(propIter)) {
hash_map_pt wiringAdminList = hashMapIterator_nextValue(propIter);
hash_map_iterator_pt waIter = hashMapIterator_create(wiringAdminList);
while (hashMapIterator_hasNext(waIter)) {
wiring_endpoint_description_pt wEndpoint = hashMapIterator_nextValue(waIter);
bool matchResult = false;
filter_match(filter, wEndpoint->properties, &matchResult);
if (matchResult) {
wiring_endpoint_listener_pt listener = (wiring_endpoint_listener_pt) service;
status = listener->wiringEndpointAdded(listener->handle, wEndpoint, scope);
}
}
hashMapIterator_destroy(waIter);
}
hashMapIterator_destroy(propIter);
celixThreadMutex_unlock(&manager->exportedWiringEndpointsLock);
}
filter_destroy(filter);
}
return status;
}
/**************************************************************************
Create a new rule
**************************************************************************/
static void filter_new(void)
{
#if 0
struct filter *f = filter_create();
if (f)
{
DoMethod(filter_listview, MUIM_NList_InsertSingle, f, MUIV_NList_Insert_Bottom);
filter_dispose(f);
set(filter_listview, MUIA_NList_Active, xget(filter_listview, MUIA_NList_Entries)-1);
filter_edit();
}
#endif
}
TEST(filter, getString){
char * filter_str = my_strdup("(&(test_attr1=attr1)(|(test_attr2=attr2)(test_attr3=attr3)))");
filter_pt filter = filter_create(filter_str);
char * get_str;
filter_getString(filter, &get_str);
//cleanup
filter_destroy(filter);
free(filter_str);
mock().checkExpectations();
}
/**
* Creates a new filter.
*/
static void filter_new(void)
{
struct filter *f = filter_create();
if (f)
{
DoMethod(filter_list, MUIM_NList_InsertSingle, (ULONG)f, MUIV_NList_Insert_Bottom);
filter_dispose(f);
set(filter_list, MUIA_NList_Active, MUIV_NList_Active_Bottom);
if (filter_last_selected) set(filter_name_string, MUIA_BetterString_SelectSize, -utf8len(filter_last_selected->name));
set(filter_wnd, MUIA_Window_ActiveObject, filter_name_string);
}
}
int filters_init(cfg_t *cfg)
{
filters = g_hash_table_new_full(&g_str_hash, &g_str_equal, &g_free, (GDestroyNotify)&filter_free);
int index = cfg_size(cfg, "filter");
while (index--) {
cfg_t *sec = cfg_getnsec(cfg, "filter", index);
filter *f = filter_create();
add_filter_restrictions(f, sec);
g_hash_table_insert(filters, g_strdup(cfg_title(sec)), f);
}
return 1;
}
TEST(filter, create_fail_missing_opening_brackets){
char * filter_str;
filter_pt get_filter;
//test missing opening brackets in main filter
mock().expectNCalls(2, "framework_log");
filter_str = my_strdup("&(test_attr1=attr1)(|(test_attr2=attr2)(test_attr3=attr3))");
get_filter = filter_create(filter_str);
POINTERS_EQUAL(NULL, get_filter);
free(filter_str);
mock().checkExpectations();
//test missing opening brackets in AND comparator
mock().expectNCalls(3, "framework_log");
filter_str = my_strdup("(&test_attr1=attr1|(test_attr2=attr2)(test_attr3=attr3))");
get_filter = filter_create(filter_str);
POINTERS_EQUAL(NULL, get_filter);
free(filter_str);
mock().checkExpectations();
//test missing opening brackets in AND comparator
mock().expectNCalls(4, "framework_log");
filter_str = my_strdup("(&(test_attr1=attr1)(|test_attr2=attr2(test_attr3=attr3))");
get_filter = filter_create(filter_str);
POINTERS_EQUAL(NULL, get_filter);
free(filter_str);
mock().checkExpectations();
//test missing opening brackets in NOT comparator
mock().expectNCalls(4, "framework_log");
filter_str = my_strdup("(&(test_attr1=attr1)(!test_attr2=attr2)");
get_filter = filter_create(filter_str);
POINTERS_EQUAL(NULL, get_filter);
free(filter_str);
mock().checkExpectations();
}
static int
replace_pkg_filter(DnfSack *sack, struct _Filter **fp, int keyname, int cmp_type,
const DnfPackageSet *pset)
{
if (*fp == NULL)
*fp = filter_create(1);
else
filter_reinit(*fp, 1);
struct _Filter *f = *fp;
f->keyname = keyname;
f->cmp_type = cmp_type;
f->match_type = _HY_PKG;
f->matches[0].pset = dnf_packageset_clone((DnfPackageSet*)pset);
return 0;
}
struct tsproc *tsproc_create(enum tsproc_mode mode,
enum filter_type delay_filter, int filter_length)
{
struct tsproc *tsp;
tsp = calloc(1, sizeof(*tsp));
if (!tsp)
return NULL;
switch (mode) {
case TSPROC_FILTER:
tsp->raw_mode = 0;
tsp->weighting = 0;
break;
case TSPROC_RAW:
tsp->raw_mode = 1;
tsp->weighting = 0;
break;
case TSPROC_FILTER_WEIGHT:
tsp->raw_mode = 0;
tsp->weighting = 1;
break;
case TSPROC_RAW_WEIGHT:
tsp->raw_mode = 1;
tsp->weighting = 1;
break;
default:
free(tsp);
return NULL;
}
tsp->delay_filter = filter_create(delay_filter, filter_length);
if (!tsp->delay_filter) {
free(tsp);
return NULL;
}
tsp->clock_rate_ratio = 1.0;
return tsp;
}
int main(int argc, char ** argv){
srand(time(NULL));
Config_t * config = config_create (argc, argv);
if (!config_is_valid (config)) { config_usage (config); exit(-1); }
pDEBUG("Got config from command line\n");
config_set (config);
pDEBUG("Config set\n");
// en fonction de la commande
switch (config->command){
case COMMAND_TP1_FILTER_EX2:
{
Filter_t * filter = filter_create(&(config->io),
config->filter_size,
config->filter_offset);
filter_run (filter);
filter_destroy (filter);
}
break;
case COMMAND_TP1_DEGREE_EX3:
{
Degree_t * degree = degree_create (&(config->io),
config->nodecount,
MODE_DEGREE);
degree_set_output (degree, true);
degree_fill_from_input_graph (degree);
degree_destroy (degree);
}
break;
case COMMAND_TP1_STORE_GRAPH_EX4:
{
Store_t * store = store_create(&(config->io),
config->nodecount);
store_fill_from_input_graph (store);
store_destroy (store);
}
break;
case COMMAND_TP1_DENSITY_AVGDEGREE_MAXDEGREE_EX5:
{
Degree_t * degree = degree_create (&(config->io),
config->nodecount,
MODE_DEGSTATS);
degree_set_output (degree, true);
degree_fill_from_input_graph (degree);
degree_destroy (degree);
}
break;
case COMMAND_TP1_CONNEXITY_EX6:
{
Store_t * store = store_create(&(config->io),
config->nodecount);
store_fill_from_input_graph (store);
store_connexity (store, NULL);
store_destroy (store);
}
break;
case COMMAND_TP1_CONNEXITY_DEFI:
{
Defi_t * defi = defi_create(&(config->io),
config->nodecount);
defi_run (defi);
defi_destroy (defi);
}
break;
case COMMAND_TP2_DISTANCE_ONE_TO_OTHER_EX1:
{
fprintf(stderr,"Exercice 1 - Ecrire un programme qui, étant donné un\n");
fprintf(stderr," graphe et un de ses noeud, calcule la distance de ce\n");
fprintf(stderr," noeud a tous les autres, ainsi que la moyenne de\n");
fprintf(stderr," toutes ces distances.\n\n");
Distance_t * distance = distance_create((&config->io),
config->nodecount);
distance_set_mode (distance, MODE_MAX_AND_AVERAGE);
distance_set_root (distance, config->root_index);
distance_set_iterations (distance, 1);
distance_compute (distance);
distance_destroy (distance);
}
break;
case COMMAND_TP2_PLOT_DISTRIB_DISTANCES_EX2:
{
fprintf(stderr,"Exercice 2 - Tracer la distribution des distances à un\n");
fprintf(stderr," noeud donné, c'est à dire pour chaque entier i le nom-\n");
fprintf(stderr," bre de noeuds à distance i du noeud donné.\n\n");
Distance_t * distance = distance_create((&config->io),
config->nodecount);
distance_set_mode (distance, MODE_MAX_DISTRIBUTION);
distance_set_root (distance, config->root_index);
distance_set_iterations (distance, 1);
distance_compute (distance);
distance_destroy (distance);
}
break;
case COMMAND_TP2_EVOL_OF_DISTS_FNC_NB_PARCOURS_EX3:
{
fprintf(stderr, "Exercice 3 - Ecrire un programme qui permet de tracer\n");
fprintf(stderr, " l'évolution de l'estimation de la distance moyenne en\n");
fprintf(stderr, " fonction du nombre de parcours effectués.\n");
fprintf(stderr, "A chaque étape, le programme calcule la distance moyenne\n");
fprintf(stderr, " d'un noeud à tous les autres, puis fait la moyenne avec\n");
fprintf(stderr, " toutes les valeurs précédentes.\n\n");
Distance_t * distance = distance_create((&config->io),
config->nodecount);
distance_set_mode (distance, MODE_EVOLUTION);
distance_set_root (distance, config->root_index);
distance_set_iterations (distance, config->iterations);
distance_compute (distance);
distance_destroy (distance);
}
break;
case COMMAND_TP2_LIMIT_INFERIOR_EX4:
{
fprintf(stderr, "Exercice 4 - Ecrire un programme qui calcule une borne\n");
fprintf(stderr, " inférieure du diamètre, en prenant la distance maximale\n");
fprintf(stderr, " d'un noeud donné à tous les autres.\n\n");
Distance_t * distance = distance_create((&config->io),
config->nodecount);
distance_set_mode (distance, MODE_SHOW_LIMIT_INF);
distance_set_root (distance, config->root_index);
distance_set_iterations (distance, config->iterations);
distance_compute (distance);
distance_destroy (distance);
}
break;
case COMMAND_TP2_LIMIT_SUPERIOR_EX5:
{
fprintf(stderr, "Exercice 5 - Ecrire un programme qui calcule une borne\n");
fprintf(stderr, " supérieure du diamètre, en prenant la distance maximale\n");
fprintf(stderr, " dans l'arbre du parcours en largeur.\n\n");
Distance_t * distance = distance_create((&config->io),
config->nodecount);
distance_set_mode (distance, MODE_SHOW_LIMIT_SUP);
distance_set_root (distance, config->root_index);
distance_set_iterations (distance, config->iterations);
distance_compute (distance);
distance_destroy (distance);
}
break;
case COMMAND_TP2_EVOLUTION_AND_LIMITS_DEFI:
{
fprintf(stderr, "Défi - Ecrire un programme qui donne un encadrement de\n");
fprintf(stderr, " plus en plus fin du diamètre d'un graphe. Le programme\n");
fprintf(stderr, " effectue à chaque étape un parcours en largeur et en\n");
fprintf(stderr, " déduit une borne inférieure et une borne supérieure pour\n");
fprintf(stderr, " le diamètre. Si elle améliorent le résultat elle sont\n");
fprintf(stderr, " conservées à la place des meilleures valeurs trouvées\n");
fprintf(stderr, " lors des étapes précédentes.\n\n");
Distance_t * distance = distance_create((&config->io),
config->nodecount);
distance_set_mode (distance, MODE_DEFI);
distance_set_root (distance, config->root_index);
distance_set_iterations (distance, config->iterations);
distance_compute (distance);
distance_destroy (distance);
}
break;
case COMMAND_TP3_DISTRIB_DEG_EX1:
{
fprintf(stderr, "Exercice 1 - Ecrire un programme qui calcule la distribu-\n");
fprintf(stderr, " tion des degrés d'un graphe.\n");
Degree_t * degree = degree_create (&(config->io),
config->nodecount,
MODE_DEGREE);
degree_set_output (degree, false);
degree_fill_from_input_graph (degree);
degree_output_distribution (degree);
degree_destroy (degree);
}
break;
case COMMAND_TP3_EVOL_AVG_DEG_EX2:
{
Store_t * store = store_create(&(config->io),
config->nodecount);
store_fill_from_input_graph (store);
store_compute_avg_degree(store, config->iterations);
store_destroy (store);
}
break;
case COMMAND_TP3_GENERATE_EX3:
{
fprintf(stderr, "Generating a random graph\n");
Generator_t * generator = generator_create(&(config->io),
config->nodecount,
config->filter_size);
generator_run (generator);
generator_destroy (generator);
}
break;
case COMMAND_TP3_DEGENERATE_EX5:
{
fprintf(stderr, "Degenerating input graph\n");
Degenerator_t * degen = degenerator_create (&(config->io),
config->nodecount, config->iterations);
degenerator_set_select_mode (degen, DEGENERATOR_SELECT_RANDOM);
degenerator_compute (degen);
degenerator_destroy (degen);
}
break;
case COMMAND_TP3_DEGENERATE_MAX_DEG_EX7:
{
fprintf(stderr, "Degenerating input graph with max degrees first\n");
Degenerator_t * degen = degenerator_create (&(config->io),
config->nodecount, config->iterations);
degenerator_set_select_mode (degen, DEGENERATOR_SELECT_MAX_DEG);
degenerator_compute (degen);
degenerator_destroy (degen);
}
break;
default:
{
printf("Undefined mode\n");
}
break;
}
config_destroy (config);
return EXIT_SUCCESS;
}
TEST(filter, create_misc){
char * filter_str;
filter_pt get_filter;
//test trailing chars
mock().expectOneCall("framework_log");
filter_str = my_strdup("(&(test_attr1=attr1)(|(test_attr2=attr2)(test_attr3=attr3))) oh no! trailing chars");
get_filter = filter_create(filter_str);
POINTERS_EQUAL(NULL, get_filter);
free(filter_str);
mock().checkExpectations();
//test half APPROX operator (should be "~=", instead is "~")
mock().expectNCalls(5, "framework_log");
filter_str = my_strdup("(&(test_attr1=attr1)(|(test_attr2=attr2)(test_attr3~attr3)))");
get_filter = filter_create(filter_str);
POINTERS_EQUAL(NULL, get_filter);
free(filter_str);
mock().checkExpectations();
//test PRESENT operator with trailing chars (should just register as substrings: "*" and "attr3")
filter_str = my_strdup("(test_attr3=*attr3)");
get_filter = filter_create(filter_str);
CHECK(get_filter != NULL);
LONGS_EQUAL(SUBSTRING, get_filter->operand)
LONGS_EQUAL(2, arrayList_size((array_list_pt) get_filter->value));
filter_destroy(get_filter);
free(filter_str);
mock().checkExpectations();
//test parsing a attribute of 0 length
mock().expectNCalls(3, "framework_log");
filter_str = my_strdup("(>=attr3)");
get_filter = filter_create(filter_str);
POINTERS_EQUAL(NULL, get_filter);
free(filter_str);
mock().checkExpectations();
//test parsing a value of 0 length
mock().expectOneCall("framework_log");
filter_str = my_strdup("(test_attr3>=)");
get_filter = filter_create(filter_str);
POINTERS_EQUAL(NULL, get_filter);
free(filter_str);
mock().checkExpectations();
//test parsing a value with a escaped closing bracket "\)"
filter_str = my_strdup("(test_attr3>=strWith\\)inIt)");
get_filter = filter_create(filter_str);
CHECK(get_filter != NULL);
STRCMP_EQUAL("strWith)inIt", (char*)get_filter->value);
filter_destroy(get_filter);
free(filter_str);
mock().checkExpectations();
//test parsing a substring with a escaped closing bracket "\)"
filter_str = my_strdup("(test_attr3=strWith\\)inIt)");
get_filter = filter_create(filter_str);
CHECK(get_filter != NULL);
STRCMP_EQUAL("strWith)inIt", (char*)get_filter->value);
filter_destroy(get_filter);
free(filter_str);
mock().checkExpectations();
}
TEST(filter, match_operators){
char * filter_str;
filter_pt filter;
properties_pt props = properties_create();
char * key = my_strdup("test_attr1");
char * val = my_strdup("attr1");
char * key2 = my_strdup("test_attr2");
char * val2 = my_strdup("attr2");
properties_set(props, key, val);
properties_set(props, key2, val2);
//test EQUALS
filter_str = my_strdup("(test_attr1=attr1)");
filter = filter_create(filter_str);
bool result = false;
filter_match(filter, props, &result);
CHECK(result);
//test EQUALS false
filter_destroy(filter);
free(filter_str);
filter_str = my_strdup("(test_attr1=falseString)");
filter = filter_create(filter_str);
result = true;
filter_match(filter, props, &result);
CHECK_FALSE(result);
//test APPROX TODO: update this test once APPROX is implemented
filter_destroy(filter);
free(filter_str);
filter_str = my_strdup("(test_attr1~=attr1)");
filter = filter_create(filter_str);
result = false;
filter_match(filter, props, &result);
CHECK(result);
//test APROX false TODO: update this test once APPROX is implemented
filter_destroy(filter);
free(filter_str);
filter_str = my_strdup("(test_attr1~=ATTR1)");
filter = filter_create(filter_str);
result = true;
filter_match(filter, props, &result);
CHECK_FALSE(result);
//test PRESENT
filter_destroy(filter);
free(filter_str);
filter_str = my_strdup("(test_attr1=*)");
filter = filter_create(filter_str);
result = false;
filter_match(filter, props, &result);
CHECK(result);
//test PRESENT false
filter_destroy(filter);
free(filter_str);
filter_str = my_strdup("(test_attr3=*)");
filter = filter_create(filter_str);
result = true;
filter_match(filter, props, &result);
CHECK_FALSE(result);
//test LESSEQUAL less
filter_destroy(filter);
free(filter_str);
filter_str = my_strdup("(test_attr1<=attr5)");
filter = filter_create(filter_str);
result = false;
filter_match(filter, props, &result);
CHECK(result);
//test LESSEQUAL equals
filter_destroy(filter);
free(filter_str);
filter_str = my_strdup("(test_attr2<=attr2)");
filter = filter_create(filter_str);
result = false;
filter_match(filter, props, &result);
CHECK(result);
//test LESSEQUAL false
filter_destroy(filter);
free(filter_str);
filter_str = my_strdup("(test_attr2<=attr1)");
filter = filter_create(filter_str);
result = true;
filter_match(filter, props, &result);
CHECK_FALSE(result);
//test GREATEREQUAL greater
filter_destroy(filter);
free(filter_str);
filter_str = my_strdup("(test_attr2>=attr1)");
filter = filter_create(filter_str);
result = false;
filter_match(filter, props, &result);
CHECK(result);
//test GREATEREQUAL equals
filter_destroy(filter);
free(filter_str);
filter_str = my_strdup("(test_attr2>=attr2)");
filter = filter_create(filter_str);
result = false;
filter_match(filter, props, &result);
CHECK(result);
//test GREATEREQUAL false
filter_destroy(filter);
free(filter_str);
filter_str = my_strdup("(test_attr1>=attr5)");
filter = filter_create(filter_str);
result = true;
filter_match(filter, props, &result);
CHECK_FALSE(result);
//test LESS less
filter_destroy(filter);
free(filter_str);
filter_str = my_strdup("(test_attr1<attr5)");
filter = filter_create(filter_str);
result = false;
filter_match(filter, props, &result);
CHECK(result);
//test LESS equals
filter_destroy(filter);
free(filter_str);
filter_str = my_strdup("(test_attr2<attr2)");
filter = filter_create(filter_str);
result = true;
filter_match(filter, props, &result);
CHECK_FALSE(result);
//test LESS false
filter_destroy(filter);
free(filter_str);
filter_str = my_strdup("(test_attr2<attr1)");
filter = filter_create(filter_str);
result = true;
filter_match(filter, props, &result);
CHECK_FALSE(result);
//test GREATER greater
filter_destroy(filter);
free(filter_str);
filter_str = my_strdup("(test_attr2>attr1)");
filter = filter_create(filter_str);
result = false;
filter_match(filter, props, &result);
CHECK(result);
//test GREATER equals
filter_destroy(filter);
free(filter_str);
filter_str = my_strdup("(test_attr2>attr2)");
filter = filter_create(filter_str);
result = true;
filter_match(filter, props, &result);
CHECK_FALSE(result);
//test GREATER false
filter_destroy(filter);
free(filter_str);
filter_str = my_strdup("(test_attr1>attr5)");
filter = filter_create(filter_str);
result = true;
filter_match(filter, props, &result);
CHECK_FALSE(result);
//test SUBSTRING equals
filter_destroy(filter);
free(filter_str);
filter_str = my_strdup("(test_attr1=attr*)");
filter = filter_create(filter_str);
result = true;
filter_match(filter, props, &result);
CHECK(result);
//test SUBSTRING false
filter_destroy(filter);
free(filter_str);
filter_str = my_strdup("(test_attr1=attr*charsNotPresent)");
filter = filter_create(filter_str);
result = true;
filter_match(filter, props, &result);
CHECK_FALSE(result);
//cleanup
properties_destroy(props);
filter_destroy(filter);
free(filter_str);
free(key);
free(key2);
free(val);
free(val2);
mock().checkExpectations();
}
