base/test/property-entry-test.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 // Unit tests for property entries API
0003 //
0004 // Copyright 2019 Google LLC.
0005
0006 #include <kunit/test.h>
0007 #include <linux/property.h>
0008 #include <linux/types.h>
0009
0010 static void pe_test_uints(struct kunit *test)
0011 {
0012     static const struct property_entry entries[] = {
0013         PROPERTY_ENTRY_U8("prop-u8", 8),
0014         PROPERTY_ENTRY_U16("prop-u16", 16),
0015         PROPERTY_ENTRY_U32("prop-u32", 32),
0016         PROPERTY_ENTRY_U64("prop-u64", 64),
0017         { }
0018     };
0019
0020     struct fwnode_handle *node;
0021     u8 val_u8, array_u8[2];
0022     u16 val_u16, array_u16[2];
0023     u32 val_u32, array_u32[2];
0024     u64 val_u64, array_u64[2];
0025     int error;
0026
0027     node = fwnode_create_software_node(entries, NULL);
0028     KUNIT_ASSERT_NOT_ERR_OR_NULL(test, node);
0029
0030     error = fwnode_property_count_u8(node, "prop-u8");
0031     KUNIT_EXPECT_EQ(test, error, 1);
0032
0033     error = fwnode_property_read_u8(node, "prop-u8", &val_u8);
0034     KUNIT_EXPECT_EQ(test, error, 0);
0035     KUNIT_EXPECT_EQ(test, val_u8, 8);
0036
0037     error = fwnode_property_read_u8_array(node, "prop-u8", array_u8, 1);
0038     KUNIT_EXPECT_EQ(test, error, 0);
0039     KUNIT_EXPECT_EQ(test, array_u8[0], 8);
0040
0041     error = fwnode_property_read_u8_array(node, "prop-u8", array_u8, 2);
0042     KUNIT_EXPECT_NE(test, error, 0);
0043
0044     error = fwnode_property_read_u8(node, "no-prop-u8", &val_u8);
0045     KUNIT_EXPECT_NE(test, error, 0);
0046
0047     error = fwnode_property_read_u8_array(node, "no-prop-u8", array_u8, 1);
0048     KUNIT_EXPECT_NE(test, error, 0);
0049
0050     error = fwnode_property_read_u16(node, "prop-u16", &val_u16);
0051     KUNIT_EXPECT_EQ(test, error, 0);
0052     KUNIT_EXPECT_EQ(test, val_u16, 16);
0053
0054     error = fwnode_property_count_u16(node, "prop-u16");
0055     KUNIT_EXPECT_EQ(test, error, 1);
0056
0057     error = fwnode_property_read_u16_array(node, "prop-u16", array_u16, 1);
0058     KUNIT_EXPECT_EQ(test, error, 0);
0059     KUNIT_EXPECT_EQ(test, array_u16[0], 16);
0060
0061     error = fwnode_property_read_u16_array(node, "prop-u16", array_u16, 2);
0062     KUNIT_EXPECT_NE(test, error, 0);
0063
0064     error = fwnode_property_read_u16(node, "no-prop-u16", &val_u16);
0065     KUNIT_EXPECT_NE(test, error, 0);
0066
0067     error = fwnode_property_read_u16_array(node, "no-prop-u16", array_u16, 1);
0068     KUNIT_EXPECT_NE(test, error, 0);
0069
0070     error = fwnode_property_read_u32(node, "prop-u32", &val_u32);
0071     KUNIT_EXPECT_EQ(test, error, 0);
0072     KUNIT_EXPECT_EQ(test, val_u32, 32);
0073
0074     error = fwnode_property_count_u32(node, "prop-u32");
0075     KUNIT_EXPECT_EQ(test, error, 1);
0076
0077     error = fwnode_property_read_u32_array(node, "prop-u32", array_u32, 1);
0078     KUNIT_EXPECT_EQ(test, error, 0);
0079     KUNIT_EXPECT_EQ(test, array_u32[0], 32);
0080
0081     error = fwnode_property_read_u32_array(node, "prop-u32", array_u32, 2);
0082     KUNIT_EXPECT_NE(test, error, 0);
0083
0084     error = fwnode_property_read_u32(node, "no-prop-u32", &val_u32);
0085     KUNIT_EXPECT_NE(test, error, 0);
0086
0087     error = fwnode_property_read_u32_array(node, "no-prop-u32", array_u32, 1);
0088     KUNIT_EXPECT_NE(test, error, 0);
0089
0090     error = fwnode_property_read_u64(node, "prop-u64", &val_u64);
0091     KUNIT_EXPECT_EQ(test, error, 0);
0092     KUNIT_EXPECT_EQ(test, val_u64, 64);
0093
0094     error = fwnode_property_count_u64(node, "prop-u64");
0095     KUNIT_EXPECT_EQ(test, error, 1);
0096
0097     error = fwnode_property_read_u64_array(node, "prop-u64", array_u64, 1);
0098     KUNIT_EXPECT_EQ(test, error, 0);
0099     KUNIT_EXPECT_EQ(test, array_u64[0], 64);
0100
0101     error = fwnode_property_read_u64_array(node, "prop-u64", array_u64, 2);
0102     KUNIT_EXPECT_NE(test, error, 0);
0103
0104     error = fwnode_property_read_u64(node, "no-prop-u64", &val_u64);
0105     KUNIT_EXPECT_NE(test, error, 0);
0106
0107     error = fwnode_property_read_u64_array(node, "no-prop-u64", array_u64, 1);
0108     KUNIT_EXPECT_NE(test, error, 0);
0109
0110     /* Count 64-bit values as 16-bit */
0111     error = fwnode_property_count_u16(node, "prop-u64");
0112     KUNIT_EXPECT_EQ(test, error, 4);
0113
0114     fwnode_remove_software_node(node);
0115 }
0116
0117 static void pe_test_uint_arrays(struct kunit *test)
0118 {
0119     static const u8 a_u8[10] = { 8, 9 };
0120     static const u16 a_u16[10] = { 16, 17 };
0121     static const u32 a_u32[10] = { 32, 33 };
0122     static const u64 a_u64[10] = { 64, 65 };
0123     static const struct property_entry entries[] = {
0124         PROPERTY_ENTRY_U8_ARRAY("prop-u8", a_u8),
0125         PROPERTY_ENTRY_U16_ARRAY("prop-u16", a_u16),
0126         PROPERTY_ENTRY_U32_ARRAY("prop-u32", a_u32),
0127         PROPERTY_ENTRY_U64_ARRAY("prop-u64", a_u64),
0128         { }
0129     };
0130
0131     struct fwnode_handle *node;
0132     u8 val_u8, array_u8[32];
0133     u16 val_u16, array_u16[32];
0134     u32 val_u32, array_u32[32];
0135     u64 val_u64, array_u64[32];
0136     int error;
0137
0138     node = fwnode_create_software_node(entries, NULL);
0139     KUNIT_ASSERT_NOT_ERR_OR_NULL(test, node);
0140
0141     error = fwnode_property_read_u8(node, "prop-u8", &val_u8);
0142     KUNIT_EXPECT_EQ(test, error, 0);
0143     KUNIT_EXPECT_EQ(test, val_u8, 8);
0144
0145     error = fwnode_property_count_u8(node, "prop-u8");
0146     KUNIT_EXPECT_EQ(test, error, 10);
0147
0148     error = fwnode_property_read_u8_array(node, "prop-u8", array_u8, 1);
0149     KUNIT_EXPECT_EQ(test, error, 0);
0150     KUNIT_EXPECT_EQ(test, array_u8[0], 8);
0151
0152     error = fwnode_property_read_u8_array(node, "prop-u8", array_u8, 2);
0153     KUNIT_EXPECT_EQ(test, error, 0);
0154     KUNIT_EXPECT_EQ(test, array_u8[0], 8);
0155     KUNIT_EXPECT_EQ(test, array_u8[1], 9);
0156
0157     error = fwnode_property_read_u8_array(node, "prop-u8", array_u8, 17);
0158     KUNIT_EXPECT_NE(test, error, 0);
0159
0160     error = fwnode_property_read_u8(node, "no-prop-u8", &val_u8);
0161     KUNIT_EXPECT_NE(test, error, 0);
0162
0163     error = fwnode_property_read_u8_array(node, "no-prop-u8", array_u8, 1);
0164     KUNIT_EXPECT_NE(test, error, 0);
0165
0166     error = fwnode_property_read_u16(node, "prop-u16", &val_u16);
0167     KUNIT_EXPECT_EQ(test, error, 0);
0168     KUNIT_EXPECT_EQ(test, val_u16, 16);
0169
0170     error = fwnode_property_count_u16(node, "prop-u16");
0171     KUNIT_EXPECT_EQ(test, error, 10);
0172
0173     error = fwnode_property_read_u16_array(node, "prop-u16", array_u16, 1);
0174     KUNIT_EXPECT_EQ(test, error, 0);
0175     KUNIT_EXPECT_EQ(test, array_u16[0], 16);
0176
0177     error = fwnode_property_read_u16_array(node, "prop-u16", array_u16, 2);
0178     KUNIT_EXPECT_EQ(test, error, 0);
0179     KUNIT_EXPECT_EQ(test, array_u16[0], 16);
0180     KUNIT_EXPECT_EQ(test, array_u16[1], 17);
0181
0182     error = fwnode_property_read_u16_array(node, "prop-u16", array_u16, 17);
0183     KUNIT_EXPECT_NE(test, error, 0);
0184
0185     error = fwnode_property_read_u16(node, "no-prop-u16", &val_u16);
0186     KUNIT_EXPECT_NE(test, error, 0);
0187
0188     error = fwnode_property_read_u16_array(node, "no-prop-u16", array_u16, 1);
0189     KUNIT_EXPECT_NE(test, error, 0);
0190
0191     error = fwnode_property_read_u32(node, "prop-u32", &val_u32);
0192     KUNIT_EXPECT_EQ(test, error, 0);
0193     KUNIT_EXPECT_EQ(test, val_u32, 32);
0194
0195     error = fwnode_property_count_u32(node, "prop-u32");
0196     KUNIT_EXPECT_EQ(test, error, 10);
0197
0198     error = fwnode_property_read_u32_array(node, "prop-u32", array_u32, 1);
0199     KUNIT_EXPECT_EQ(test, error, 0);
0200     KUNIT_EXPECT_EQ(test, array_u32[0], 32);
0201
0202     error = fwnode_property_read_u32_array(node, "prop-u32", array_u32, 2);
0203     KUNIT_EXPECT_EQ(test, error, 0);
0204     KUNIT_EXPECT_EQ(test, array_u32[0], 32);
0205     KUNIT_EXPECT_EQ(test, array_u32[1], 33);
0206
0207     error = fwnode_property_read_u32_array(node, "prop-u32", array_u32, 17);
0208     KUNIT_EXPECT_NE(test, error, 0);
0209
0210     error = fwnode_property_read_u32(node, "no-prop-u32", &val_u32);
0211     KUNIT_EXPECT_NE(test, error, 0);
0212
0213     error = fwnode_property_read_u32_array(node, "no-prop-u32", array_u32, 1);
0214     KUNIT_EXPECT_NE(test, error, 0);
0215
0216     error = fwnode_property_read_u64(node, "prop-u64", &val_u64);
0217     KUNIT_EXPECT_EQ(test, error, 0);
0218     KUNIT_EXPECT_EQ(test, val_u64, 64);
0219
0220     error = fwnode_property_count_u64(node, "prop-u64");
0221     KUNIT_EXPECT_EQ(test, error, 10);
0222
0223     error = fwnode_property_read_u64_array(node, "prop-u64", array_u64, 1);
0224     KUNIT_EXPECT_EQ(test, error, 0);
0225     KUNIT_EXPECT_EQ(test, array_u64[0], 64);
0226
0227     error = fwnode_property_read_u64_array(node, "prop-u64", array_u64, 2);
0228     KUNIT_EXPECT_EQ(test, error, 0);
0229     KUNIT_EXPECT_EQ(test, array_u64[0], 64);
0230     KUNIT_EXPECT_EQ(test, array_u64[1], 65);
0231
0232     error = fwnode_property_read_u64_array(node, "prop-u64", array_u64, 17);
0233     KUNIT_EXPECT_NE(test, error, 0);
0234
0235     error = fwnode_property_read_u64(node, "no-prop-u64", &val_u64);
0236     KUNIT_EXPECT_NE(test, error, 0);
0237
0238     error = fwnode_property_read_u64_array(node, "no-prop-u64", array_u64, 1);
0239     KUNIT_EXPECT_NE(test, error, 0);
0240
0241     /* Count 64-bit values as 16-bit */
0242     error = fwnode_property_count_u16(node, "prop-u64");
0243     KUNIT_EXPECT_EQ(test, error, 40);
0244
0245     /* Other way around */
0246     error = fwnode_property_count_u64(node, "prop-u16");
0247     KUNIT_EXPECT_EQ(test, error, 2);
0248
0249     fwnode_remove_software_node(node);
0250 }
0251
0252 static void pe_test_strings(struct kunit *test)
0253 {
0254     static const char *strings[] = {
0255         "string-a",
0256         "string-b",
0257     };
0258
0259     static const struct property_entry entries[] = {
0260         PROPERTY_ENTRY_STRING("str", "single"),
0261         PROPERTY_ENTRY_STRING("empty", ""),
0262         PROPERTY_ENTRY_STRING_ARRAY("strs", strings),
0263         { }
0264     };
0265
0266     struct fwnode_handle *node;
0267     const char *str;
0268     const char *strs[10];
0269     int error;
0270
0271     node = fwnode_create_software_node(entries, NULL);
0272     KUNIT_ASSERT_NOT_ERR_OR_NULL(test, node);
0273
0274     error = fwnode_property_read_string(node, "str", &str);
0275     KUNIT_EXPECT_EQ(test, error, 0);
0276     KUNIT_EXPECT_STREQ(test, str, "single");
0277
0278     error = fwnode_property_string_array_count(node, "str");
0279     KUNIT_EXPECT_EQ(test, error, 1);
0280
0281     error = fwnode_property_read_string_array(node, "str", strs, 1);
0282     KUNIT_EXPECT_EQ(test, error, 1);
0283     KUNIT_EXPECT_STREQ(test, strs[0], "single");
0284
0285     /* asking for more data returns what we have */
0286     error = fwnode_property_read_string_array(node, "str", strs, 2);
0287     KUNIT_EXPECT_EQ(test, error, 1);
0288     KUNIT_EXPECT_STREQ(test, strs[0], "single");
0289
0290     error = fwnode_property_read_string(node, "no-str", &str);
0291     KUNIT_EXPECT_NE(test, error, 0);
0292
0293     error = fwnode_property_read_string_array(node, "no-str", strs, 1);
0294     KUNIT_EXPECT_LT(test, error, 0);
0295
0296     error = fwnode_property_read_string(node, "empty", &str);
0297     KUNIT_EXPECT_EQ(test, error, 0);
0298     KUNIT_EXPECT_STREQ(test, str, "");
0299
0300     error = fwnode_property_string_array_count(node, "strs");
0301     KUNIT_EXPECT_EQ(test, error, 2);
0302
0303     error = fwnode_property_read_string_array(node, "strs", strs, 3);
0304     KUNIT_EXPECT_EQ(test, error, 2);
0305     KUNIT_EXPECT_STREQ(test, strs[0], "string-a");
0306     KUNIT_EXPECT_STREQ(test, strs[1], "string-b");
0307
0308     error = fwnode_property_read_string_array(node, "strs", strs, 1);
0309     KUNIT_EXPECT_EQ(test, error, 1);
0310     KUNIT_EXPECT_STREQ(test, strs[0], "string-a");
0311
0312     /* NULL argument -> returns size */
0313     error = fwnode_property_read_string_array(node, "strs", NULL, 0);
0314     KUNIT_EXPECT_EQ(test, error, 2);
0315
0316     /* accessing array as single value */
0317     error = fwnode_property_read_string(node, "strs", &str);
0318     KUNIT_EXPECT_EQ(test, error, 0);
0319     KUNIT_EXPECT_STREQ(test, str, "string-a");
0320
0321     fwnode_remove_software_node(node);
0322 }
0323
0324 static void pe_test_bool(struct kunit *test)
0325 {
0326     static const struct property_entry entries[] = {
0327         PROPERTY_ENTRY_BOOL("prop"),
0328         { }
0329     };
0330
0331     struct fwnode_handle *node;
0332
0333     node = fwnode_create_software_node(entries, NULL);
0334     KUNIT_ASSERT_NOT_ERR_OR_NULL(test, node);
0335
0336     KUNIT_EXPECT_TRUE(test, fwnode_property_read_bool(node, "prop"));
0337     KUNIT_EXPECT_FALSE(test, fwnode_property_read_bool(node, "not-prop"));
0338
0339     fwnode_remove_software_node(node);
0340 }
0341
0342 /* Verifies that small U8 array is stored inline when property is copied */
0343 static void pe_test_move_inline_u8(struct kunit *test)
0344 {
0345     static const u8 u8_array_small[8] = { 1, 2, 3, 4 };
0346     static const u8 u8_array_big[128] = { 5, 6, 7, 8 };
0347     static const struct property_entry entries[] = {
0348         PROPERTY_ENTRY_U8_ARRAY("small", u8_array_small),
0349         PROPERTY_ENTRY_U8_ARRAY("big", u8_array_big),
0350         { }
0351     };
0352
0353     struct property_entry *copy;
0354     const u8 *data_ptr;
0355
0356     copy = property_entries_dup(entries);
0357     KUNIT_ASSERT_NOT_ERR_OR_NULL(test, copy);
0358
0359     KUNIT_EXPECT_TRUE(test, copy[0].is_inline);
0360     data_ptr = (u8 *)&copy[0].value;
0361     KUNIT_EXPECT_EQ(test, data_ptr[0], 1);
0362     KUNIT_EXPECT_EQ(test, data_ptr[1], 2);
0363
0364     KUNIT_EXPECT_FALSE(test, copy[1].is_inline);
0365     data_ptr = copy[1].pointer;
0366     KUNIT_EXPECT_EQ(test, data_ptr[0], 5);
0367     KUNIT_EXPECT_EQ(test, data_ptr[1], 6);
0368
0369     property_entries_free(copy);
0370 }
0371
0372 /* Verifies that single string array is stored inline when property is copied */
0373 static void pe_test_move_inline_str(struct kunit *test)
0374 {
0375     static char *str_array_small[] = { "a" };
0376     static char *str_array_big[] = { "b", "c", "d", "e" };
0377     static char *str_array_small_empty[] = { "" };
0378     static struct property_entry entries[] = {
0379         PROPERTY_ENTRY_STRING_ARRAY("small", str_array_small),
0380         PROPERTY_ENTRY_STRING_ARRAY("big", str_array_big),
0381         PROPERTY_ENTRY_STRING_ARRAY("small-empty", str_array_small_empty),
0382         { }
0383     };
0384
0385     struct property_entry *copy;
0386     const char * const *data_ptr;
0387
0388     copy = property_entries_dup(entries);
0389     KUNIT_ASSERT_NOT_ERR_OR_NULL(test, copy);
0390
0391     KUNIT_EXPECT_TRUE(test, copy[0].is_inline);
0392     KUNIT_EXPECT_STREQ(test, copy[0].value.str[0], "a");
0393
0394     KUNIT_EXPECT_FALSE(test, copy[1].is_inline);
0395     data_ptr = copy[1].pointer;
0396     KUNIT_EXPECT_STREQ(test, data_ptr[0], "b");
0397     KUNIT_EXPECT_STREQ(test, data_ptr[1], "c");
0398
0399     KUNIT_EXPECT_TRUE(test, copy[2].is_inline);
0400     KUNIT_EXPECT_STREQ(test, copy[2].value.str[0], "");
0401
0402     property_entries_free(copy);
0403 }
0404
0405 /* Handling of reference properties */
0406 static void pe_test_reference(struct kunit *test)
0407 {
0408     static const struct software_node nodes[] = {
0409         { .name = "1", },
0410         { .name = "2", },
0411         { }
0412     };
0413
0414     static const struct software_node_ref_args refs[] = {
0415         SOFTWARE_NODE_REFERENCE(&nodes[0]),
0416         SOFTWARE_NODE_REFERENCE(&nodes[1], 3, 4),
0417     };
0418
0419     const struct property_entry entries[] = {
0420         PROPERTY_ENTRY_REF("ref-1", &nodes[0]),
0421         PROPERTY_ENTRY_REF("ref-2", &nodes[1], 1, 2),
0422         PROPERTY_ENTRY_REF_ARRAY("ref-3", refs),
0423         { }
0424     };
0425
0426     struct fwnode_handle *node;
0427     struct fwnode_reference_args ref;
0428     int error;
0429
0430     error = software_node_register_nodes(nodes);
0431     KUNIT_ASSERT_EQ(test, error, 0);
0432
0433     node = fwnode_create_software_node(entries, NULL);
0434     KUNIT_ASSERT_NOT_ERR_OR_NULL(test, node);
0435
0436     error = fwnode_property_get_reference_args(node, "ref-1", NULL,
0437                            0, 0, &ref);
0438     KUNIT_ASSERT_EQ(test, error, 0);
0439     KUNIT_EXPECT_PTR_EQ(test, to_software_node(ref.fwnode), &nodes[0]);
0440     KUNIT_EXPECT_EQ(test, ref.nargs, 0U);
0441
0442     /* wrong index */
0443     error = fwnode_property_get_reference_args(node, "ref-1", NULL,
0444                            0, 1, &ref);
0445     KUNIT_EXPECT_NE(test, error, 0);
0446
0447     error = fwnode_property_get_reference_args(node, "ref-2", NULL,
0448                            1, 0, &ref);
0449     KUNIT_ASSERT_EQ(test, error, 0);
0450     KUNIT_EXPECT_PTR_EQ(test, to_software_node(ref.fwnode), &nodes[1]);
0451     KUNIT_EXPECT_EQ(test, ref.nargs, 1U);
0452     KUNIT_EXPECT_EQ(test, ref.args[0], 1LLU);
0453
0454     /* asking for more args, padded with zero data */
0455     error = fwnode_property_get_reference_args(node, "ref-2", NULL,
0456                            3, 0, &ref);
0457     KUNIT_ASSERT_EQ(test, error, 0);
0458     KUNIT_EXPECT_PTR_EQ(test, to_software_node(ref.fwnode), &nodes[1]);
0459     KUNIT_EXPECT_EQ(test, ref.nargs, 3U);
0460     KUNIT_EXPECT_EQ(test, ref.args[0], 1LLU);
0461     KUNIT_EXPECT_EQ(test, ref.args[1], 2LLU);
0462     KUNIT_EXPECT_EQ(test, ref.args[2], 0LLU);
0463
0464     /* wrong index */
0465     error = fwnode_property_get_reference_args(node, "ref-2", NULL,
0466                            2, 1, &ref);
0467     KUNIT_EXPECT_NE(test, error, 0);
0468
0469     /* array of references */
0470     error = fwnode_property_get_reference_args(node, "ref-3", NULL,
0471                            0, 0, &ref);
0472     KUNIT_ASSERT_EQ(test, error, 0);
0473     KUNIT_EXPECT_PTR_EQ(test, to_software_node(ref.fwnode), &nodes[0]);
0474     KUNIT_EXPECT_EQ(test, ref.nargs, 0U);
0475
0476     /* second reference in the array */
0477     error = fwnode_property_get_reference_args(node, "ref-3", NULL,
0478                            2, 1, &ref);
0479     KUNIT_ASSERT_EQ(test, error, 0);
0480     KUNIT_EXPECT_PTR_EQ(test, to_software_node(ref.fwnode), &nodes[1]);
0481     KUNIT_EXPECT_EQ(test, ref.nargs, 2U);
0482     KUNIT_EXPECT_EQ(test, ref.args[0], 3LLU);
0483     KUNIT_EXPECT_EQ(test, ref.args[1], 4LLU);
0484
0485     /* wrong index */
0486     error = fwnode_property_get_reference_args(node, "ref-1", NULL,
0487                            0, 2, &ref);
0488     KUNIT_EXPECT_NE(test, error, 0);
0489
0490     fwnode_remove_software_node(node);
0491     software_node_unregister_nodes(nodes);
0492 }
0493
0494 static struct kunit_case property_entry_test_cases[] = {
0495     KUNIT_CASE(pe_test_uints),
0496     KUNIT_CASE(pe_test_uint_arrays),
0497     KUNIT_CASE(pe_test_strings),
0498     KUNIT_CASE(pe_test_bool),
0499     KUNIT_CASE(pe_test_move_inline_u8),
0500     KUNIT_CASE(pe_test_move_inline_str),
0501     KUNIT_CASE(pe_test_reference),
0502     { }
0503 };
0504
0505 static struct kunit_suite property_entry_test_suite = {
0506     .name = "property-entry",
0507     .test_cases = property_entry_test_cases,
0508 };
0509
0510 kunit_test_suite(property_entry_test_suite);