refactor(test): split QOM tests into focused cases

Author: chenglong

tests/test_qom.c

@@ -1,5 +1,4 @@
 #include <assert.h>
-#include <stdio.h>
 #include <string.h>
 
 #include "miniqom/error.h"
@@ -21,7 +20,7 @@ typedef struct TestLifecycleObject
 static char lifecycle_events[16];
 static size_t lifecycle_event_count;
 
-static void lifecycle_events_rest(void)
+static void lifecycle_events_reset(void)
 {
     lifecycle_event_count = 0;
     lifecycle_events[0] = '\0';
@@ -114,171 +113,217 @@ static void test_lifecycle_register_types(void)
     type_register_static(&test_lifecycle_failing_child_info);
 }
 
-int main(void)
+static void test_type_queries(void)
 {
-    Error err;
-    Object *root;
-    Object *objects;
-    Object *mem0;
-    HostMemoryBackendMemfd *backend;
+    Object *obj = object_new(TYPE_MEMORY_BACKEND_MEMFD);
 
-    type_system_init();
-    host_memory_backend_register_types();
-    test_lifecycle_register_types();
-
-    error_clear(&err);
-    root = object_new("object");
-    objects = object_new("object");
-    mem0 = object_new(TYPE_MEMORY_BACKEND_MEMFD);
-
-    assert(object_is_instance_of(mem0, TYPE_MEMORY_BACKEND_MEMFD));
-    assert(object_is_instance_of(mem0, TYPE_MEMORY_BACKEND));
-    assert(object_is_instance_of(mem0, "object"));
-    assert(!strcmp(object_get_type_name(mem0),
+    assert(obj != NULL);
+    assert(object_is_instance_of(obj, TYPE_MEMORY_BACKEND_MEMFD));
+    assert(object_is_instance_of(obj, TYPE_MEMORY_BACKEND));
+    assert(object_is_instance_of(obj, "object"));
+    assert(!strcmp(object_get_type_name(obj),
                    TYPE_MEMORY_BACKEND_MEMFD));
 
-    assert(object_is_a(mem0, TYPE_MEMORY_BACKEND_MEMFD));
-    assert(object_is_a(mem0, TYPE_MEMORY_BACKEND));
-    assert(object_is_a(mem0, "object"));
-    assert(!object_is_a(mem0, "unknown-type"));
+    assert(object_is_a(obj, TYPE_MEMORY_BACKEND_MEMFD));
+    assert(object_is_a(obj, TYPE_MEMORY_BACKEND));
+    assert(object_is_a(obj, "object"));
+    assert(!object_is_a(obj, "unknown-type"));
     assert(object_get_type_name(NULL) == NULL);
     assert(!object_is_a(NULL, "object"));
 
+    object_free(obj);
+}
+
+static void test_memory_backend_defaults(void)
+{
+    HostMemoryBackendMemfd *backend;
+    Object *obj = object_new(TYPE_MEMORY_BACKEND_MEMFD);
+
+    assert(obj != NULL);
+
+    backend = (HostMemoryBackendMemfd *)obj;
+    assert(backend->seal);
+    assert(backend->parent_obj.share);
+
+    object_free(obj);
+}
+
+static void test_object_lifecycle(void)
+{
+    Error err;
+    Object *obj = object_new(TYPE_MEMORY_BACKEND_MEMFD);
+
+    assert(obj != NULL);
     error_clear(&err);
 
-    assert(!object_is_realized(mem0));
+    assert(!object_is_realized(obj));
 
-    assert(object_realize(mem0, &err));
-    assert(object_is_realized(mem0));
+    assert(object_realize(obj, &err));
+    assert(object_is_realized(obj));
 
-    assert(!object_realize(mem0, &err));
+    assert(!object_realize(obj, &err));
     assert(!strcmp(err.message, "object is already realized"));
-    assert(object_is_realized(mem0));
+    assert(object_is_realized(obj));
 
-    object_unrealize(mem0);
-    assert(!object_is_realized(mem0));
+    object_unrealize(obj);
+    assert(!object_is_realized(obj));
 
-    object_unrealize(mem0);
-    assert(!object_is_realized(mem0));
+    object_unrealize(obj);
+    assert(!object_is_realized(obj));
 
-    assert(object_realize(mem0, &err));
-    assert(object_is_realized(mem0));
+    assert(object_realize(obj, &err));
+    assert(object_is_realized(obj));
 
-    object_unrealize(mem0);
-    assert(!object_is_realized(mem0));
+    object_unrealize(obj);
+    assert(!object_is_realized(obj));
 
-    backend = (HostMemoryBackendMemfd *)mem0;
-    assert(backend->seal);
-    assert(backend->parent_obj.share);
+    object_free(obj);
+}
 
-    assert(object_add_child(root, "objects", objects, &err));
-    assert(object_add_child(objects, "mem0", mem0, &err));
-    assert(object_resolve_path(root, "/objects/mem0") == mem0);
+static void test_property_get(void)
+{
+    Error err;
+    PropertyValue value;
+    Object *obj = object_new(TYPE_MEMORY_BACKEND_MEMFD);
+
+    assert(obj != NULL);
+    error_clear(&err);
 
-    assert(!object_property_set_from_string(mem0, "swap-storage",
+    assert(!object_property_set_from_string(obj, "swap-storage",
                                             "file:///swap", &err));
     assert(!strcmp(err.message, "swap-storage requires mmoc=on"));
 
     error_clear(&err);
-    assert(object_property_set_from_string(mem0, "mmoc", "on", &err));
-    assert(object_property_set_from_string(mem0, "swap-storage",
+    assert(object_property_set_from_string(obj, "mmoc", "on", &err));
+    assert(object_property_set_from_string(obj, "swap-storage",
                                            "file:///swap", &err));
-    assert(object_property_set_from_string(mem0, "size", "2G", &err));
+    assert(object_property_set_from_string(obj, "size", "2G", &err));
 
-    assert(backend->parent_obj.size == 2ULL * 1024 * 1024 * 1024);
-    assert(!strcmp(backend->parent_obj.swap_storage, "file:///swap"));
+    assert(object_property_get(obj, "size", &value, &err));
+    assert(value.u64 == 2ULL * 1024 * 1024 * 1024);
 
-    // ====== Freeze properties ======
-    //
-    Object *property_object;
-    property_object = object_new(TYPE_MEMORY_BACKEND_MEMFD);
-    assert(property_object != NULL);
+    assert(object_property_get(obj, "mmoc", &value, &err));
+    assert(value.b);
 
-    PropertyValue property_value;
-    error_clear(&err);
+    assert(object_property_get(obj, "share", &value, &err));
+    assert(value.b);
 
-    assert(object_property_set_from_string(property_object,
-                                           "size",
-                                           "2G",
-                                           &err));
+    assert(object_property_get(obj, "swap-storage", &value, &err));
+    assert(!strcmp(value.str, "file:///swap"));
 
-    assert(object_realize(property_object, &err));
-    assert(object_is_realized(property_object));
+    error_clear(&err);
 
-    assert(!object_property_set_from_string(property_object,
-                                            "size", "4G",
-                                            &err));
+    assert(!object_property_get(obj, "unknown-property", &value, &err));
+    assert(!strcmp(err.message, "property not found"));
 
-    assert(!strcmp(err.message, "object is already realized"));
+    object_free(obj);
+}
 
-    assert(object_property_get(property_object,
-                               "size",
-                               &property_value,
-                               &err));
+static void test_property_freeze_after_realize(void)
+{
+    Error err;
+    PropertyValue value;
+    Object *obj = object_new(TYPE_MEMORY_BACKEND_MEMFD);
 
-    assert(property_value.u64 == 2ULL * 1024 * 1024 * 1024);
-    // ====== Test property ======
-    assert(object_property_get(mem0, "size",
-                               &property_value, &err));
-    assert(property_value.u64 == 2ULL * 1024 * 1024 * 1024);
+    assert(obj != NULL);
+    error_clear(&err);
 
-    assert(object_property_get(mem0, "mmoc",
-                               &property_value, &err));
-    assert(property_value.b);
+    assert(object_property_set_from_string(obj, "size", "2G", &err));
 
-    assert(object_property_get(mem0, "share",
-                               &property_value, &err));
-    assert(property_value.b);
+    assert(object_realize(obj, &err));
+    assert(object_is_realized(obj));
 
-    assert(object_property_get(mem0, "swap-storage",
-                               &property_value, &err));
-    assert(!strcmp(property_value.str, "file:///swap"));
+    assert(!object_property_set_from_string(obj, "size", "4G", &err));
+    assert(!strcmp(err.message, "object is already realized"));
 
-    error_clear(&err);
+    assert(object_property_get(obj, "size", &value, &err));
+    assert(value.u64 == 2ULL * 1024 * 1024 * 1024);
 
-    assert(!object_property_get(mem0, "unknown-property",
-                                &property_value, &err));
-    assert(!strcmp(err.message, "property not found"));
+    object_unrealize(obj);
+    assert(!object_is_realized(obj));
 
-    // ====== Test realize callbacks ======
-    error_clear(&err);
+    assert(object_property_set_from_string(obj, "size", "4G", &err));
+    assert(object_property_get(obj, "size", &value, &err));
+    assert(value.u64 == 4ULL * 1024 * 1024 * 1024);
+
+    object_free(obj);
+}
 
-    Object *lifecycle_object;
+static void test_inherited_lifecycle_callbacks(void)
+{
+    Error err;
+    Object *obj = object_new(TYPE_TEST_LIFECYCLE_CHILD);
 
-    lifecycle_object = object_new(TYPE_TEST_LIFECYCLE_CHILD);
-    assert(lifecycle_object != NULL);
+    assert(obj != NULL);
+    error_clear(&err);
 
-    lifecycle_events_rest();
+    lifecycle_events_reset();
 
-    assert(object_realize(lifecycle_object, &err));
-    assert(object_is_realized(lifecycle_object));
+    assert(object_realize(obj, &err));
+    assert(object_is_realized(obj));
     assert(!strcmp(lifecycle_events, "PC"));
 
-    lifecycle_events_rest();
+    lifecycle_events_reset();
 
-    object_unrealize(lifecycle_object);
-    assert(!object_is_realized(lifecycle_object));
+    object_unrealize(obj);
+    assert(!object_is_realized(obj));
     assert(!strcmp(lifecycle_events, "cp"));
 
-    object_free(lifecycle_object);
+    object_free(obj);
+}
 
-    // ===== Test realize failed ======
-    Object *failing_object;
+static void test_realize_failure_rollback(void)
+{
+    Error err;
+    Object *obj = object_new(TYPE_TEST_LIFECYCLE_FAILING_CHILD);
 
-    failing_object = object_new(TYPE_TEST_LIFECYCLE_FAILING_CHILD);
-    assert(failing_object != NULL);
+    assert(obj != NULL);
 
-    lifecycle_events_rest();
+    lifecycle_events_reset();
     error_clear(&err);
 
-    assert(!object_realize(failing_object, &err));
+    assert(!object_realize(obj, &err));
     assert(!strcmp(err.message, "child realize failed"));
-    assert(!object_is_realized(failing_object));
+    assert(!object_is_realized(obj));
     assert(!strcmp(lifecycle_events, "PFp"));
 
-    object_free(failing_object);
+    object_free(obj);
+}
+
+static void test_object_tree(void)
+{
+    Error err;
+    Object *root = object_new("object");
+    Object *objects = object_new("object");
+    Object *mem0 = object_new(TYPE_MEMORY_BACKEND_MEMFD);
+
+    assert(root != NULL);
+    assert(objects != NULL);
+    assert(mem0 != NULL);
+
+    error_clear(&err);
+
+    assert(object_add_child(root, "objects", objects, &err));
+    assert(object_add_child(objects, "mem0", mem0, &err));
+    assert(object_resolve_path(root, "/objects/mem0") == mem0);
 
-    // ======= Release test resources ======
     object_free(root);
+}
+
+int main(void)
+{
+    type_system_init();
+    host_memory_backend_register_types();
+    test_lifecycle_register_types();
+
+    test_type_queries();
+    test_memory_backend_defaults();
+    test_object_lifecycle();
+    test_property_get();
+    test_property_freeze_after_realize();
+    test_inherited_lifecycle_callbacks();
+    test_realize_failure_rollback();
+    test_object_tree();
+
     return 0;
 }