more test coverage

[protos/libecoli.git] / lib / ecoli_node_str.c

diff --git a/lib/ecoli_node_str.c b/lib/ecoli_node_str.c
index 85a4046..80134b0 100644 (file)
--- a/lib/ecoli_node_str.c
+++ b/lib/ecoli_node_str.c
@@ -39,6 +39,8 @@
 #include <ecoli_completed.h>
 #include <ecoli_node_str.h>
 
+EC_LOG_TYPE_REGISTER(node_str);
+
 struct ec_node_str {
        struct ec_node gen;
        char *string;
@@ -55,7 +57,7 @@ ec_node_str_parse(const struct ec_node *gen_node,
 
        (void)state;
 
-       if (ec_strvec_len(strvec) != 1)
+       if (ec_strvec_len(strvec) == 0)
                return EC_PARSED_NOMATCH;
 
        str = ec_strvec_val(strvec, 0);
@@ -65,24 +67,17 @@ ec_node_str_parse(const struct ec_node *gen_node,
        return 1;
 }
 
-static struct ec_completed *
+static int
 ec_node_str_complete(const struct ec_node *gen_node,
-               struct ec_parsed *state,
+               struct ec_completed *completed,
                const struct ec_strvec *strvec)
 {
        struct ec_node_str *node = (struct ec_node_str *)gen_node;
-       struct ec_completed *completed;
-       const char *str, *add;
+       const char *str;
        size_t n = 0;
 
-       (void)state;
-
-       completed = ec_completed();
-       if (completed == NULL)
-               return NULL;
-
        if (ec_strvec_len(strvec) != 1)
-               return completed;
+               return 0;
 
        str = ec_strvec_val(strvec, 0);
        for (n = 0; n < node->len; n++) {
@@ -90,17 +85,15 @@ ec_node_str_complete(const struct ec_node *gen_node,
                        break;
        }
 
+       /* no completion */
        if (str[n] != '\0')
-               add = NULL;
-       else
-               add = node->string + n;
+               return EC_PARSED_NOMATCH;
 
-       if (ec_completed_add_elt(completed, state, gen_node, add) < 0) {
-               ec_completed_free(completed);
-               return NULL;
-       }
+       if (ec_completed_add_item(completed, gen_node, NULL, EC_COMP_FULL,
+                                       str, node->string) < 0)
+               return -1;
 
-       return completed;
+       return 0;
 }
 
 static const char *ec_node_str_desc(const struct ec_node *gen_node)
@@ -117,17 +110,10 @@ static void ec_node_str_free_priv(struct ec_node *gen_node)
        ec_free(node->string);
 }
 
-static size_t ec_node_str_get_max_parse_len(const struct ec_node *gen_node)
-{
-       (void)gen_node;
-       return 1;
-}
-
 static struct ec_node_type ec_node_str_type = {
        .name = "str",
        .parse = ec_node_str_parse,
        .complete = ec_node_str_complete,
-       .get_max_parse_len = ec_node_str_get_max_parse_len,
        .desc = ec_node_str_desc,
        .size = sizeof(struct ec_node_str),
        .free_priv = ec_node_str_free_priv,
@@ -138,12 +124,15 @@ EC_NODE_TYPE_REGISTER(ec_node_str_type);
 int ec_node_str_set_str(struct ec_node *gen_node, const char *str)
 {
        struct ec_node_str *node = (struct ec_node_str *)gen_node;
+       int ret;
+
+       ret = ec_node_check_type(gen_node, &ec_node_str_type);
+       if (ret < 0)
+               return ret;
 
        if (str == NULL)
                return -EINVAL;
-       if (node->string != NULL)
-               return -EEXIST; // XXX allow to replace
-
+       ec_free(node->string);
        node->string = ec_strdup(str);
        if (node->string == NULL)
                return -ENOMEM;
@@ -177,10 +166,9 @@ static int ec_node_str_testcase(void)
        struct ec_node *node;
        int ret = 0;
 
-       /* XXX use EC_NO_ID instead of NULL */
-       node = ec_node_str(NULL, "foo");
+       node = ec_node_str(EC_NO_ID, "foo");
        if (node == NULL) {
-               ec_log(EC_LOG_ERR, "cannot create node\n");
+               EC_LOG(EC_LOG_ERR, "cannot create node\n");
                return -1;
        }
        ret |= EC_TEST_CHECK_PARSE(node, 1, "foo");
@@ -190,9 +178,9 @@ static int ec_node_str_testcase(void)
        ret |= EC_TEST_CHECK_PARSE(node, -1, "");
        ec_node_free(node);
 
-       node = ec_node_str(NULL, "Здравствуйте");
+       node = ec_node_str(EC_NO_ID, "Здравствуйте");
        if (node == NULL) {
-               ec_log(EC_LOG_ERR, "cannot create node\n");
+               EC_LOG(EC_LOG_ERR, "cannot create node\n");
                return -1;
        }
        ret |= EC_TEST_CHECK_PARSE(node, 1, "Здравствуйте");
@@ -203,9 +191,9 @@ static int ec_node_str_testcase(void)
        ec_node_free(node);
 
        /* an empty string node always matches */
-       node = ec_node_str(NULL, "");
+       node = ec_node_str(EC_NO_ID, "");
        if (node == NULL) {
-               ec_log(EC_LOG_ERR, "cannot create node\n");
+               EC_LOG(EC_LOG_ERR, "cannot create node\n");
                return -1;
        }
        ret |= EC_TEST_CHECK_PARSE(node, 1, "");
@@ -214,31 +202,26 @@ static int ec_node_str_testcase(void)
        ec_node_free(node);
 
        /* test completion */
-       node = ec_node_str(NULL, "foo");
+       node = ec_node_str(EC_NO_ID, "foo");
        if (node == NULL) {
-               ec_log(EC_LOG_ERR, "cannot create node\n");
+               EC_LOG(EC_LOG_ERR, "cannot create node\n");
                return -1;
        }
        ret |= EC_TEST_CHECK_COMPLETE(node,
                EC_NODE_ENDLIST,
-               EC_NODE_ENDLIST,
-               "");
+               EC_NODE_ENDLIST);
        ret |= EC_TEST_CHECK_COMPLETE(node,
                "", EC_NODE_ENDLIST,
-               "foo", EC_NODE_ENDLIST,
-               "foo");
+               "foo", EC_NODE_ENDLIST);
        ret |= EC_TEST_CHECK_COMPLETE(node,
                "f", EC_NODE_ENDLIST,
-               "oo", EC_NODE_ENDLIST,
-               "oo");
+               "foo", EC_NODE_ENDLIST);
        ret |= EC_TEST_CHECK_COMPLETE(node,
                "foo", EC_NODE_ENDLIST,
-               "", EC_NODE_ENDLIST,
-               "");
+               "foo", EC_NODE_ENDLIST);
        ret |= EC_TEST_CHECK_COMPLETE(node,
                "x", EC_NODE_ENDLIST,
-               EC_NODE_ENDLIST,
-               "");
+               EC_NODE_ENDLIST);
        ec_node_free(node);
 
        return ret;