enumeration BUGFIX enums are not sorted when compiled

Properly detect the highest enum value.

Fixes #2462

Author: michalvasko

src/plugins_types/enumeration.c

@@ -37,26 +37,29 @@
  * | fixed for a specific type | yes | `int32 *` | assigned little-endian value of the enum |
  */
 
-#define ENUM_FIXED_SIZE_BITS(type) \
-        lyplg_type_get_highest_set_bit_pos(\
-        ((struct lysc_type_enum *)type)->enums[LY_ARRAY_COUNT(((struct lysc_type_enum *)type)->enums) - 1].value)
-
 static void
 lyplg_type_lyb_size_enum(const struct lysc_type *type, enum lyplg_lyb_size_type *size_type, uint32_t *fixed_size_bits)
 {
     const struct lysc_type_enum *type_enum = (struct lysc_type_enum *)type;
-    uint32_t max_value;
-
-    *size_type = LYPLG_LYB_SIZE_FIXED_BITS;
+    LY_ARRAY_COUNT_TYPE u;
+    uint32_t max_value = 0;
 
-    if (type_enum->enums[0].value < 0) {
-        /* we need the full 4 bytes */
-        *fixed_size_bits = 32;
-        return;
+    if (size_type) {
+        *size_type = LYPLG_LYB_SIZE_FIXED_BITS;
     }
 
-    /* value of the last enum, sorted */
-    max_value = type_enum->enums[LY_ARRAY_COUNT(type_enum->enums) - 1].value;
+    /* learn the max value of enums */
+    LY_ARRAY_FOR(type_enum->enums, u) {
+        if (type_enum->enums[u].value < 0) {
+            /* we need the full 4 bytes */
+            *fixed_size_bits = 32;
+            return;
+        }
+
+        if ((unsigned)type_enum->enums[u].value > max_value) {
+            max_value = type_enum->enums[u].value;
+        }
+    }
 
     /* learn the position of the highest set bit, the least amount of bits that can hold the number */
     *fixed_size_bits = lyplg_type_get_highest_set_bit_pos(max_value);
@@ -71,6 +74,7 @@ lyplg_type_store_enum(const struct ly_ctx *ctx, const struct lysc_type *type, co
     struct lysc_type_enum *type_enum = (struct lysc_type_enum *)type;
     LY_ERR ret = LY_SUCCESS;
     LY_ARRAY_COUNT_TYPE u;
+    uint32_t fixed_size_bits;
     ly_bool found = 0;
     uint32_t value_size;
     int64_t num = 0;
@@ -81,8 +85,9 @@ lyplg_type_store_enum(const struct ly_ctx *ctx, const struct lysc_type *type, co
     storage->realtype = type;
 
     /* check value length */
+    lyplg_type_lyb_size_enum(type, NULL, &fixed_size_bits);
     ret = lyplg_type_check_value_size("enumeration", format, value_size_bits, LYPLG_LYB_SIZE_FIXED_BITS,
-            ENUM_FIXED_SIZE_BITS(type), &value_size, err);
+            fixed_size_bits, &value_size, err);
     LY_CHECK_GOTO(ret, cleanup);
 
     if (format == LY_VALUE_LYB) {
@@ -176,17 +181,20 @@ static const void *
 lyplg_type_print_enum(const struct ly_ctx *UNUSED(ctx), const struct lyd_value *value, LY_VALUE_FORMAT format,
         void *UNUSED(prefix_data), ly_bool *dynamic, uint32_t *value_size_bits)
 {
+    uint32_t fixed_size_bits;
     int64_t prev_num = 0, num = 0;
     void *buf;
 
     if (format == LY_VALUE_LYB) {
+        lyplg_type_lyb_size_enum(value->realtype, NULL, &fixed_size_bits);
+
         prev_num = num = value->enum_item->value;
         num = htole64(num);
         if (num == prev_num) {
             /* values are equal, little-endian */
             *dynamic = 0;
             if (value_size_bits) {
-                *value_size_bits = ENUM_FIXED_SIZE_BITS(value->realtype);
+                *value_size_bits = fixed_size_bits;
             }
             return &value->enum_item->value;
         } else {
@@ -196,7 +204,7 @@ lyplg_type_print_enum(const struct ly_ctx *UNUSED(ctx), const struct lyd_value *
 
             *dynamic = 1;
             if (value_size_bits) {
-                *value_size_bits = ENUM_FIXED_SIZE_BITS(value->realtype);
+                *value_size_bits = fixed_size_bits;
             }
             memcpy(buf, &num, 4);
             return buf;

tests/utests/data/test_lyb.c

@@ -2571,6 +2571,68 @@ test_shrink(void **state)
     lyd_free_all(tree1);
 }
 
+static void
+test_enumeration(void **state)
+{
+    const char *mod;
+    const char *data_xml;
+
+    mod =
+            "module enum { namespace \"urn:enum\"; prefix e;"
+            "  container cont {"
+            "    presence \"\";"
+            "    leaf test-value {"
+            "      type enumeration {"
+            "        enum value-1 { value 1; }"
+            "        enum value-56 { value 56; }"
+            "        enum value-25 { value 25; }"
+            "        enum value-39 { value 39; }"
+            "        enum value-32 { value 32; }"
+            "        enum value-31 { value 31; }"
+            "      }"
+            "    }"
+            "  }"
+            "}";
+    UTEST_ADD_MODULE(mod, LYS_IN_YANG, NULL, NULL);
+
+    data_xml =
+            "<cont xmlns=\"urn:enum\">\n"
+            "<test-value>value-56</test-value>\n"
+            "</cont>\n";
+    check_print_parse(state, data_xml);
+}
+
+static void
+test_bits(void **state)
+{
+    const char *mod;
+    const char *data_xml;
+
+    mod =
+            "module bits { namespace \"urn:bits\"; prefix b;"
+            "  container cont {"
+            "    presence \"\";"
+            "    leaf test-value {"
+            "      type bits {"
+            "        bit bit-1 { position 1; }"
+            "        bit bit-56 { position 56; }"
+            "        bit bit-25 { position 25; }"
+            "        bit bit-39 { position 39; }"
+            "        bit bit-32 { position 32; }"
+            "        bit bit-31 { position 31; }"
+            "      }"
+            "    }"
+            "  }"
+            "}";
+    UTEST_ADD_MODULE(mod, LYS_IN_YANG, NULL, NULL);
+
+    data_xml =
+            "<cont xmlns=\"urn:bits\">\n"
+            "<test-value>bit-56</test-value>\n"
+            "</cont>\n";
+    check_print_parse(state, data_xml);
+}
+
 int
 main(void)
 {
@@ -2584,6 +2646,8 @@ main(void)
         UTEST(test_opaq, setup),
         UTEST(test_collisions, setup),
         UTEST(test_shrink, setup),
+        UTEST(test_enumeration, setup),
+        UTEST(test_bits, setup),
     };
 
     return cmocka_run_group_tests(tests, NULL, NULL);