test_invalid_odl.c File Reference

#include <sys/time.h>
#include <sys/resource.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <inttypes.h>
#include <limits.h>
#include <unistd.h>
#include <fcntl.h>
#include <cmocka.h>
#include <amxc/amxc.h>
#include <amxp/amxp_signal.h>
#include <amxd/amxd_dm.h>
#include <amxd/amxd_object.h>
#include <amxd/amxd_parameter.h>
#include <amxo/amxo.h>
#include "test_invalid_odl.h"
#include <amxc/amxc_macros.h>

Go to the source code of this file.

Functions
static amxd_status_t	test_dummy_action (UNUSED amxd_object_t *const object, UNUSED amxd_param_t *const param, UNUSED amxd_action_t reason, UNUSED const amxc_var_t *const args, UNUSED amxc_var_t *const retval, UNUSED void *priv)
static void	_print_event (const char *const sig_name, UNUSED const amxc_var_t *const data, UNUSED void *const priv)
void	test_invalid_object_attrs (UNUSED void **state)
void	test_invalid_param_attrs (UNUSED void **state)
void	test_invalid_func_attrs (UNUSED void **state)
void	test_add_inst_on_singelton (UNUSED void **state)
void	test_duplicate_inst_index (UNUSED void **state)
void	test_duplicate_inst_name (UNUSED void **state)
void	test_invalid_inst_name (UNUSED void **state)
void	test_instance_of_singleton (UNUSED void **state)
void	test_duplicate_obj_name (UNUSED void **state)
void	test_invalid_obj_name (UNUSED void **state)
void	test_duplicate_param_name (UNUSED void **state)
void	test_duplicate_param_name_with_counter (UNUSED void **state)
void	test_invalid_param_name (UNUSED void **state)
void	test_invalid_func_name (UNUSED void **state)
void	test_duplicate_func_arg_name (UNUSED void **state)
void	test_select_none_existing_obj (UNUSED void **state)
void	test_select_none_existing_param (UNUSED void **state)
void	test_invalid_param_value (UNUSED void **state)
void	test_invalid_param_value_validate (UNUSED void **state)
void	test_invalid_action_name (UNUSED void **state)
void	test_invalid_object_action_name (UNUSED void **state)
void	test_invalid_resolvers (UNUSED void **state)
void	test_not_existing_entry_point (UNUSED void **state)
void	test_invalid_parameter_actions (UNUSED void **state)
void	test_not_resolved_action (UNUSED void **state)
void	test_add_not_existing_mib (UNUSED void **state)
void	test_add_mib_with_duplicates (UNUSED void **state)
void	test_invalid_regexp_in_filter (UNUSED void **state)
void	test_invalid_key_params (UNUSED void **state)
void	test_empty_file_name (UNUSED void **state)
void	test_parse_non_existing_file (UNUSED void **state)

Function Documentation

_print_event()

static void _print_event ( const char *const  sig_name, UNUSED const amxc_var_t *const  data, UNUSED void *const  priv  )

static

Definition at line 90 of file test_invalid_odl.c.

                                                  {
 
    printf("Event received %s\n", sig_name);
}

test_add_inst_on_singelton()

void test_add_inst_on_singelton

(

UNUSED void **

state

)

Definition at line 175 of file test_invalid_odl.c.

                                                     {
    amxd_dm_t dm;
    amxo_parser_t parser;
    const char* odl =
        "%define { object Test; }" \
        "%populate { object Test { instance add(0,\"\"); } }";
 
    amxd_dm_init(&dm);
    amxo_parser_init(&parser);
 
    assert_int_not_equal(amxo_parser_parse_string(&parser, odl, amxd_dm_get_root(&dm)), 0);
    assert_int_equal(amxo_parser_get_status(&parser), amxd_status_invalid_type);
 
    amxo_parser_clean(&parser);
    amxd_dm_clean(&dm);
}

test_add_mib_with_duplicates()

void test_add_mib_with_duplicates

(

UNUSED void **

state

)

Definition at line 600 of file test_invalid_odl.c.

                                                       {
    amxd_dm_t dm;
    amxo_parser_t parser;
    const char* odls[] = {
        "%define { mib TestMib { string Text; } object Test { string Text; extend with mib TestMib; } }",
        "%define { mib TestMib { string Text; } object Test { extend with mib TestMib; string Text; } }",
        NULL
    };
 
    amxd_dm_init(&dm);
    amxo_parser_init(&parser);
 
    for(int i = 0; odls[i] != NULL; i++) {
        assert_int_not_equal(amxo_parser_parse_string(&parser, odls[i], amxd_dm_get_root(&dm)), 0);
        assert_int_equal(amxo_parser_get_status(&parser), amxd_status_duplicate);
        amxd_dm_clean(&dm);
    }
 
    amxo_parser_clean(&parser);
    amxd_dm_clean(&dm);
}

test_add_not_existing_mib()

void test_add_not_existing_mib

(

UNUSED void **

state

)

Definition at line 579 of file test_invalid_odl.c.

                                                    {
    amxd_dm_t dm;
    amxo_parser_t parser;
    const char* odls[] = {
        "%define { object Test { extend with mib FakeMib; } }",
        NULL
    };
 
    amxd_dm_init(&dm);
    amxo_parser_init(&parser);
 
    for(int i = 0; odls[i] != NULL; i++) {
        assert_int_not_equal(amxo_parser_parse_string(&parser, odls[i], amxd_dm_get_root(&dm)), 0);
        assert_int_equal(amxo_parser_get_status(&parser), amxd_status_object_not_found);
        amxd_dm_clean(&dm);
    }
 
    amxo_parser_clean(&parser);
    amxd_dm_clean(&dm);
}

test_dummy_action()

static amxd_status_t test_dummy_action ( UNUSED amxd_object_t *const  object, UNUSED amxd_param_t *const  param, UNUSED amxd_action_t  reason, UNUSED const amxc_var_t *const  args, UNUSED amxc_var_t *const  retval, UNUSED void *  priv  )

static

Definition at line 81 of file test_invalid_odl.c.

                                                          {
    return amxd_status_ok;
}

test_duplicate_func_arg_name()

void test_duplicate_func_arg_name

(

UNUSED void **

state

)

Definition at line 350 of file test_invalid_odl.c.

                                                       {
    amxd_dm_t dm;
    amxo_parser_t parser;
    const char* odl = "%define { object Test { void F1(bool a1, bool a2, bool a1); } }";
 
    amxd_dm_init(&dm);
    amxo_parser_init(&parser);
 
    assert_int_not_equal(amxo_parser_parse_string(&parser, odl, amxd_dm_get_root(&dm)), 0);
    assert_int_equal(amxo_parser_get_status(&parser), amxd_status_invalid_name);
 
    amxo_parser_clean(&parser);
    amxd_dm_clean(&dm);
}

test_duplicate_inst_index()

void test_duplicate_inst_index

(

UNUSED void **

state

)

Definition at line 192 of file test_invalid_odl.c.

                                                    {
    amxd_dm_t dm;
    amxo_parser_t parser;
    const char* odl =
        "%define { object Test[]; }" \
        "%populate { object Test { instance add(1,\"\"); instance add(1,\"\"); } }";
 
    amxd_dm_init(&dm);
    amxo_parser_init(&parser);
 
    assert_int_not_equal(amxo_parser_parse_string(&parser, odl, amxd_dm_get_root(&dm)), 0);
    assert_int_equal(amxo_parser_get_status(&parser), amxd_status_duplicate);
 
    amxo_parser_clean(&parser);
    amxd_dm_clean(&dm);
}

test_duplicate_inst_name()

void test_duplicate_inst_name

(

UNUSED void **

state

)

Definition at line 209 of file test_invalid_odl.c.

                                                   {
    amxd_dm_t dm;
    amxo_parser_t parser;
    const char* odl =
        "%define { object Test[]; }" \
        "%populate { object Test { instance add(0,\"AB\"); instance add(0,\"AB\"); } }";
 
    amxd_dm_init(&dm);
    amxo_parser_init(&parser);
 
    assert_int_not_equal(amxo_parser_parse_string(&parser, odl, amxd_dm_get_root(&dm)), 0);
    assert_int_equal(amxo_parser_get_status(&parser), amxd_status_duplicate);
 
    amxo_parser_clean(&parser);
    amxd_dm_clean(&dm);
}

test_duplicate_obj_name()

void test_duplicate_obj_name

(

UNUSED void **

state

)

Definition at line 260 of file test_invalid_odl.c.

                                                  {
    amxd_dm_t dm;
    amxo_parser_t parser;
    const char* odl = "%define { object Test1; object Test2; object Test1; }";
 
    amxd_dm_init(&dm);
    amxo_parser_init(&parser);
 
    assert_int_not_equal(amxo_parser_parse_string(&parser, odl, amxd_dm_get_root(&dm)), 0);
    assert_int_equal(amxo_parser_get_status(&parser), amxd_status_duplicate);
 
    amxo_parser_clean(&parser);
    amxd_dm_clean(&dm);
}

test_duplicate_param_name()

void test_duplicate_param_name

(

UNUSED void **

state

)

Definition at line 290 of file test_invalid_odl.c.

                                                    {
    amxd_dm_t dm;
    amxo_parser_t parser;
    const char* odl = "%define { object Test { string P1; string P2; string P1; } }";
 
    amxd_dm_init(&dm);
    amxo_parser_init(&parser);
 
    assert_int_not_equal(amxo_parser_parse_string(&parser, odl, amxd_dm_get_root(&dm)), 0);
    assert_int_equal(amxo_parser_get_status(&parser), amxd_status_duplicate);
 
    amxo_parser_clean(&parser);
    amxd_dm_clean(&dm);
}

test_duplicate_param_name_with_counter()

void test_duplicate_param_name_with_counter

(

UNUSED void **

state

)

Definition at line 305 of file test_invalid_odl.c.

                                                                 {
    amxd_dm_t dm;
    amxo_parser_t parser;
    const char* odl = "%define { object Test { string P1; object TT[] { counted with P1; } } }";
 
    amxd_dm_init(&dm);
    amxo_parser_init(&parser);
 
    assert_int_not_equal(amxo_parser_parse_string(&parser, odl, amxd_dm_get_root(&dm)), 0);
    assert_int_equal(amxo_parser_get_status(&parser), amxd_status_duplicate);
 
    amxo_parser_clean(&parser);
    amxd_dm_clean(&dm);
}

test_empty_file_name()

void test_empty_file_name

(

UNUSED void **

state

)

Definition at line 734 of file test_invalid_odl.c.

                                               {
    amxd_dm_t dm;
    amxo_parser_t parser;
 
    amxd_dm_init(&dm);
    amxo_parser_init(&parser);
 
    assert_int_not_equal(amxo_parser_parse_file(&parser, "", amxd_dm_get_root(&dm)), 0);
 
    amxo_parser_clean(&parser);
    amxd_dm_clean(&dm);
}

test_instance_of_singleton()

void test_instance_of_singleton

(

UNUSED void **

state

)

Definition at line 243 of file test_invalid_odl.c.

                                                     {
    amxd_dm_t dm;
    amxo_parser_t parser;
    const char* odl =
        "%define { object Test; }" \
        "%populate { object Test { instance add(0,\"Text\"); instance add(0,\"AB\"); } }";
 
    amxd_dm_init(&dm);
    amxo_parser_init(&parser);
 
    assert_int_not_equal(amxo_parser_parse_string(&parser, odl, amxd_dm_get_root(&dm)), 0);
    assert_int_equal(amxo_parser_get_status(&parser), amxd_status_invalid_type);
 
    amxo_parser_clean(&parser);
    amxd_dm_clean(&dm);
}

test_invalid_action_name()

void test_invalid_action_name

(

UNUSED void **

state

)

Definition at line 438 of file test_invalid_odl.c.

                                                   {
    amxd_dm_t dm;
    amxo_parser_t parser;
    const char* odl =
        "%define {"
        "    object Test {"
        "        uint32 P1 {"
        "            default 50;"
        "            on action reset call dummy;"
        "        }"
        "    }"
        "}";
 
    amxd_dm_init(&dm);
    amxo_parser_init(&parser);
 
    amxo_resolver_ftab_add(&parser, "dummy", AMXO_FUNC(test_dummy_action));
 
    assert_int_not_equal(amxo_parser_parse_string(&parser, odl, amxd_dm_get_root(&dm)), 0);
    assert_int_equal(amxo_parser_get_status(&parser), amxd_status_invalid_action);
 
    amxo_parser_clean(&parser);
    amxd_dm_clean(&dm);
}

test_invalid_func_attrs()

void test_invalid_func_attrs

(

UNUSED void **

state

)

Definition at line 148 of file test_invalid_odl.c.

                                                  {
    amxd_dm_t dm;
    amxo_parser_t parser;
    const char* odls[] = {
        "%define { object Test { %read-only void Func(); } }",
        "%define { object Test { %persistent void Func(); } }",
        "%define { object Test { %in void Func(); } }",
        "%define { object Test { %out void Func(); } }",
        "%define { object Test { %mandatory void Func(); } }",
        "%define { object Test { %strict void Func(); } }",
        "%define { object Test { %volatile void Func(); } }",
        NULL
    };
 
    amxd_dm_init(&dm);
    amxo_parser_init(&parser);
 
    for(int i = 0; odls[i] != NULL; i++) {
        assert_int_not_equal(amxo_parser_parse_string(&parser, odls[i], amxd_dm_get_root(&dm)), 0);
        assert_int_equal(amxo_parser_get_status(&parser), amxd_status_invalid_attr);
        amxd_dm_clean(&dm);
    }
 
    amxo_parser_clean(&parser);
    amxd_dm_clean(&dm);
}

test_invalid_func_name()

void test_invalid_func_name

(

UNUSED void **

state

)

Definition at line 335 of file test_invalid_odl.c.

                                                 {
    amxd_dm_t dm;
    amxo_parser_t parser;
    const char* odl = "%define { object Test { void \"F$1\"(); } }";
 
    amxd_dm_init(&dm);
    amxo_parser_init(&parser);
 
    assert_int_not_equal(amxo_parser_parse_string(&parser, odl, amxd_dm_get_root(&dm)), 0);
    assert_int_equal(amxo_parser_get_status(&parser), amxd_status_invalid_name);
 
    amxo_parser_clean(&parser);
    amxd_dm_clean(&dm);
}

test_invalid_inst_name()

void test_invalid_inst_name

(

UNUSED void **

state

)

Definition at line 226 of file test_invalid_odl.c.

                                                 {
    amxd_dm_t dm;
    amxo_parser_t parser;
    const char* odl =
        "%define { object Test[]; }" \
        "%populate { object Test { instance add(0,\"%Text$\"); instance add(0,\"AB\"); } }";
 
    amxd_dm_init(&dm);
    amxo_parser_init(&parser);
 
    assert_int_not_equal(amxo_parser_parse_string(&parser, odl, amxd_dm_get_root(&dm)), 0);
    assert_int_equal(amxo_parser_get_status(&parser), amxd_status_invalid_name);
 
    amxo_parser_clean(&parser);
    amxd_dm_clean(&dm);
}

test_invalid_key_params()

void test_invalid_key_params

(

UNUSED void **

state

)

Definition at line 646 of file test_invalid_odl.c.

                                                  {
    amxd_dm_t dm;
    amxo_parser_t parser;
 
    const char* odl_1 =
        "%define {\n"
        "    object TestRoot {\n"
        "        object Test[] {\n"
        "            %key string text;\n"
        "        }\n"
        "    }\n"
        "}\n"
        "%populate {\n"
        "   object TestRoot.Test {\n"
        "       instance add();\n"
        "   }\n"
        "}\n";
 
    const char* odl_2 =
        "%define {\n"
        "    object TestRoot {\n"
        "        object Test[] {\n"
        "            %key string text;\n"
        "        }\n"
        "    }\n"
        "}\n"
        "%populate {\n"
        "   object TestRoot.Test {\n"
        "       instance add() {\n"
        "           parameter text = \"KeyValue\";\n"
        "       }\n"
        "   }\n"
        "}\n";
 
    const char* odl_3 =
        "%define {\n"
        "    object TestRoot {\n"
        "        object Test[] {\n"
        "            %key string text;\n"
        "        }\n"
        "    }\n"
        "}\n"
        "%populate {\n"
        "   object TestRoot.Test {\n"
        "       instance add(text = \"key1\");\n"
        "       instance add(text = \"key1\");\n"
        "   }\n"
        "}\n";
 
    const char* odl_4 =
        "%define {\n"
        "    object TestRoot {\n"
        "        object Test[] {\n"
        "            %key string text = \"Hallo\";\n"
        "        }\n"
        "    }\n"
        "}\n";
 
    amxd_dm_init(&dm);
    amxo_parser_init(&parser);
 
    printf("%s\n", odl_1);
    fflush(stdout);
    assert_int_not_equal(amxo_parser_parse_string(&parser, odl_1, amxd_dm_get_root(&dm)), 0);
    assert_int_equal(amxo_parser_get_status(&parser), amxd_status_missing_key);
    amxd_dm_clean(&dm);
 
    printf("%s\n", odl_2);
    fflush(stdout);
    assert_int_not_equal(amxo_parser_parse_string(&parser, odl_2, amxd_dm_get_root(&dm)), 0);
    assert_int_equal(amxo_parser_get_status(&parser), amxd_status_missing_key);
    amxd_dm_clean(&dm);
 
    printf("%s\n", odl_3);
    fflush(stdout);
    assert_int_not_equal(amxo_parser_parse_string(&parser, odl_3, amxd_dm_get_root(&dm)), 0);
    assert_int_equal(amxo_parser_get_status(&parser), amxd_status_duplicate);
    amxd_dm_clean(&dm);
 
    printf("%s\n", odl_4);
    fflush(stdout);
    assert_int_not_equal(amxo_parser_parse_string(&parser, odl_4, amxd_dm_get_root(&dm)), 0);
    assert_int_equal(amxo_parser_get_status(&parser), amxd_status_invalid_value);
    amxd_dm_clean(&dm);
 
    amxo_parser_clean(&parser);
}

test_invalid_obj_name()

void test_invalid_obj_name

(

UNUSED void **

state

)

Definition at line 275 of file test_invalid_odl.c.

                                                {
    amxd_dm_t dm;
    amxo_parser_t parser;
    const char* odl = "%define { object \"23&Test1\";  }";
 
    amxd_dm_init(&dm);
    amxo_parser_init(&parser);
 
    assert_int_not_equal(amxo_parser_parse_string(&parser, odl, amxd_dm_get_root(&dm)), 0);
    assert_int_equal(amxo_parser_get_status(&parser), amxd_status_invalid_name);
 
    amxo_parser_clean(&parser);
    amxd_dm_clean(&dm);
}

test_invalid_object_action_name()

void test_invalid_object_action_name

(

UNUSED void **

state

)

Definition at line 463 of file test_invalid_odl.c.

                                                          {
    amxd_dm_t dm;
    amxo_parser_t parser;
    const char* odl =
        "%define {"
        "    object Test {"
        "        on action reset call dummy;"
        "    }"
        "}";
 
    amxd_dm_init(&dm);
    amxo_parser_init(&parser);
 
    amxo_resolver_ftab_add(&parser, "dummy", AMXO_FUNC(test_dummy_action));
 
    assert_int_not_equal(amxo_parser_parse_string(&parser, odl, amxd_dm_get_root(&dm)), 0);
    assert_int_equal(amxo_parser_get_status(&parser), amxd_status_invalid_action);
 
    amxo_parser_clean(&parser);
    amxd_dm_clean(&dm);
}

test_invalid_object_attrs()

void test_invalid_object_attrs

(

UNUSED void **

state

)

Definition at line 97 of file test_invalid_odl.c.

                                                    {
    amxd_dm_t dm;
    amxo_parser_t parser;
    const char* odls[] = {
        "%define { %in object Test; }",
        "%define { %out object Test; }",
        "%define { %mandatory object Test; }",
        "%define { %strict object Test; }",
        "%define { %volatile object Test; }",
        "%define { %template object Test; }",
        "%define { %instance object Test; }",
        NULL
    };
 
    amxd_dm_init(&dm);
    amxo_parser_init(&parser);
 
    for(int i = 0; odls[i] != NULL; i++) {
        assert_int_not_equal(amxo_parser_parse_string(&parser, odls[i], amxd_dm_get_root(&dm)), 0);
        assert_int_equal(amxo_parser_get_status(&parser), amxd_status_invalid_attr);
        amxd_dm_clean(&dm);
    }
 
    amxo_parser_clean(&parser);
    amxd_dm_clean(&dm);
}

test_invalid_param_attrs()

void test_invalid_param_attrs

(

UNUSED void **

state

)

Definition at line 124 of file test_invalid_odl.c.

                                                   {
    amxd_dm_t dm;
    amxo_parser_t parser;
    const char* odls[] = {
        "%define { object Test { %in string Param; } }",
        "%define { object Test { %out string Param; } }",
        "%define { object Test { %mandatory string Param; } }",
        "%define { object Test { %strict string Param; } }",
        NULL
    };
 
    amxd_dm_init(&dm);
    amxo_parser_init(&parser);
 
    for(int i = 0; odls[i] != NULL; i++) {
        assert_int_not_equal(amxo_parser_parse_string(&parser, odls[i], amxd_dm_get_root(&dm)), 0);
        assert_int_equal(amxo_parser_get_status(&parser), amxd_status_invalid_attr);
        amxd_dm_clean(&dm);
    }
 
    amxo_parser_clean(&parser);
    amxd_dm_clean(&dm);
}

test_invalid_param_name()

void test_invalid_param_name

(

UNUSED void **

state

)

Definition at line 320 of file test_invalid_odl.c.

                                                  {
    amxd_dm_t dm;
    amxo_parser_t parser;
    const char* odl = "%define { object Test { string \"12$P1\"; } }";
 
    amxd_dm_init(&dm);
    amxo_parser_init(&parser);
 
    assert_int_not_equal(amxo_parser_parse_string(&parser, odl, amxd_dm_get_root(&dm)), 0);
    assert_int_equal(amxo_parser_get_status(&parser), amxd_status_invalid_name);
 
    amxo_parser_clean(&parser);
    amxd_dm_clean(&dm);
}

test_invalid_param_value()

void test_invalid_param_value

(

UNUSED void **

state

)

Definition at line 395 of file test_invalid_odl.c.

                                                   {
    amxd_dm_t dm;
    amxo_parser_t parser;
    const char* odl = "%define { object Test { bool P1;} } %populate { object Test { parameter P1 = \"text\"; } }";
    const char* odl2 = "%define { object Test { string P1;} } %populate { object Test { parameter P1 = [ 1, 2, 3 ]; } }";
 
    amxd_dm_init(&dm);
    amxo_parser_init(&parser);
 
    assert_int_not_equal(amxo_parser_parse_string(&parser, odl, amxd_dm_get_root(&dm)), 0);
    assert_int_equal(amxo_parser_get_status(&parser), amxd_status_invalid_value);
    amxd_dm_clean(&dm);
 
    assert_int_not_equal(amxo_parser_parse_string(&parser, odl2, amxd_dm_get_root(&dm)), 0);
    assert_int_equal(amxo_parser_get_status(&parser), amxd_status_invalid_value);
 
    amxo_parser_clean(&parser);
    amxd_dm_clean(&dm);
}

test_invalid_param_value_validate()

void test_invalid_param_value_validate

(

UNUSED void **

state

)

Definition at line 415 of file test_invalid_odl.c.

                                                            {
    amxd_dm_t dm;
    amxo_parser_t parser;
    const char* odl =
        "%define {"
        "    object Test {"
        "        uint32 P1 {"
        "            default 50;"
        "            on action validate call check_maximum 10;"
        "        }"
        "    }"
        "}";
 
    amxd_dm_init(&dm);
    amxo_parser_init(&parser);
 
    assert_int_not_equal(amxo_parser_parse_string(&parser, odl, amxd_dm_get_root(&dm)), 0);
    assert_int_equal(amxo_parser_get_status(&parser), amxd_status_invalid_value);
 
    amxo_parser_clean(&parser);
    amxd_dm_clean(&dm);
}

test_invalid_parameter_actions()

void test_invalid_parameter_actions

(

UNUSED void **

state

)

Definition at line 531 of file test_invalid_odl.c.

                                                         {
    amxd_dm_t dm;
    amxo_parser_t parser;
    const char* odls[] = {
        "%define { object Test { string Text { on action \"list\" call dummy; } } }",
        "%define { object Test { string Text { on action add-inst call dummy; } } }",
        "%define { object Test { string Text { on action del-inst call dummy; } } }",
        NULL
    };
 
    amxd_dm_init(&dm);
    amxo_parser_init(&parser);
 
    amxo_resolver_ftab_add(&parser, "dummy", AMXO_FUNC(test_dummy_action));
 
    for(int i = 0; odls[i] != NULL; i++) {
        assert_int_not_equal(amxo_parser_parse_string(&parser, odls[i], amxd_dm_get_root(&dm)), 0);
        assert_int_equal(amxo_parser_get_status(&parser), amxd_status_invalid_action);
        amxd_dm_clean(&dm);
    }
 
    amxo_parser_clean(&parser);
    amxd_dm_clean(&dm);
}

test_invalid_regexp_in_filter()

void test_invalid_regexp_in_filter

(

UNUSED void **

state

)

Definition at line 622 of file test_invalid_odl.c.

                                                        {
    amxd_dm_t dm;
    amxo_parser_t parser;
 
    const char* odl =
        "%define {\n"
        "    object Test { string text = \"Hallo\"; }\n"
        "}\n"
        "%populate {\n"
        "    on event \".*\" call print_event \n"
        "        filter \'object matches \"[(adsads[\"';\n"
        "}\n";
 
    amxd_dm_init(&dm);
    amxo_parser_init(&parser);
 
    amxo_resolver_ftab_add(&parser, "print_event", AMXO_FUNC(_print_event));
    assert_int_not_equal(amxo_parser_parse_string(&parser, odl, amxd_dm_get_root(&dm)), 0);
    assert_int_equal(amxo_parser_get_status(&parser), amxd_status_invalid_value);
 
    amxo_parser_clean(&parser);
    amxd_dm_clean(&dm);
}

test_invalid_resolvers()

void test_invalid_resolvers

(

UNUSED void **

state

)

Definition at line 485 of file test_invalid_odl.c.

                                                 {
    amxd_dm_t dm;
    amxo_parser_t parser;
    const char* odls[] = {
        "%define { object Test { void test()<!!>;} }",
        "%define { object Test { void test()<!:!>;} }",
        "%define { object Test { void test()<!:echo!>;} }",
        "%define { object Test { void test()<!invalid:echo!>;} }",
        "%define { object Test { void test()<!more!>;} }",
        NULL
    };
 
    amxd_dm_init(&dm);
    amxo_parser_init(&parser);
 
    for(int i = 0; odls[i] != NULL; i++) {
        assert_int_not_equal(amxo_parser_parse_string(&parser, odls[i], amxd_dm_get_root(&dm)), 0);
        assert_int_equal(amxo_parser_get_status(&parser), amxd_status_invalid_name);
        amxd_dm_clean(&dm);
    }
 
    amxo_parser_clean(&parser);
    amxd_dm_clean(&dm);
}

test_not_existing_entry_point()

void test_not_existing_entry_point

(

UNUSED void **

state

)

Definition at line 510 of file test_invalid_odl.c.

                                                        {
    amxd_dm_t dm;
    amxo_parser_t parser;
    const char* odls[] = {
        " import  \"../test_plugin/test_plugin.so\" as test_plugin; %define { entry-point test_plugin.not_existing;  }",
        NULL
    };
 
    amxd_dm_init(&dm);
    amxo_parser_init(&parser);
 
    for(int i = 0; odls[i] != NULL; i++) {
        assert_int_not_equal(amxo_parser_parse_string(&parser, odls[i], amxd_dm_get_root(&dm)), 0);
        assert_int_equal(amxo_parser_get_status(&parser), amxd_status_function_not_found);
        amxd_dm_clean(&dm);
    }
 
    amxo_parser_clean(&parser);
    amxd_dm_clean(&dm);
}

test_not_resolved_action()

void test_not_resolved_action

(

UNUSED void **

state

)

Definition at line 556 of file test_invalid_odl.c.

                                                   {
    amxd_dm_t dm;
    amxo_parser_t parser;
    const char* odls[] = {
        "%define { object Test { on action \"list\" call not_existing; } }",
        "%define { object Test { string Text { on action read call no_existing; } } }",
        "%define { object Test { on action write call not_existing; } }",
        NULL
    };
 
    amxd_dm_init(&dm);
    amxo_parser_init(&parser);
 
    for(int i = 0; odls[i] != NULL; i++) {
        assert_int_equal(amxo_parser_parse_string(&parser, odls[i], amxd_dm_get_root(&dm)), 0);
        assert_int_equal(amxo_parser_get_status(&parser), amxd_status_ok);
        amxd_dm_clean(&dm);
    }
 
    amxo_parser_clean(&parser);
    amxd_dm_clean(&dm);
}

test_parse_non_existing_file()

void test_parse_non_existing_file

(

UNUSED void **

state

)

Definition at line 747 of file test_invalid_odl.c.

                                                       {
    amxd_dm_t dm;
    amxo_parser_t* parser = NULL;
 
    amxd_dm_init(&dm);
    amxo_parser_new(&parser);
 
    assert_int_not_equal(amxo_parser_parse_file(parser, "./non-existing.odl", amxd_dm_get_root(&dm)), 0);
 
    amxo_parser_delete(&parser);
    amxd_dm_clean(&dm);
    amxo_resolver_import_close_all();
}

test_select_none_existing_obj()

void test_select_none_existing_obj

(

UNUSED void **

state

)

Definition at line 365 of file test_invalid_odl.c.

                                                        {
    amxd_dm_t dm;
    amxo_parser_t parser;
    const char* odl = "%define { object Test; } %populate { object NoneExisting; }";
 
    amxd_dm_init(&dm);
    amxo_parser_init(&parser);
 
    assert_int_not_equal(amxo_parser_parse_string(&parser, odl, amxd_dm_get_root(&dm)), 0);
    assert_int_equal(amxo_parser_get_status(&parser), amxd_status_object_not_found);
 
    amxo_parser_clean(&parser);
    amxd_dm_clean(&dm);
}

test_select_none_existing_param()

void test_select_none_existing_param

(

UNUSED void **

state

)

Definition at line 380 of file test_invalid_odl.c.

                                                          {
    amxd_dm_t dm;
    amxo_parser_t parser;
    const char* odl = "%define { object Test { string P1;} } %populate { object Test { parameter P2 = \"text\"; } }";
 
    amxd_dm_init(&dm);
    amxo_parser_init(&parser);
 
    assert_int_not_equal(amxo_parser_parse_string(&parser, odl, amxd_dm_get_root(&dm)), 0);
    assert_int_equal(amxo_parser_get_status(&parser), amxd_status_parameter_not_found);
 
    amxo_parser_clean(&parser);
    amxd_dm_clean(&dm);
}