From e7371b16a37277174fafffd9af19434de4aa14cc Mon Sep 17 00:00:00 2001 From: Steve Karg Date: Mon, 15 Dec 2025 14:35:08 -0600 Subject: [PATCH] Extended load-control object unit test validation code coverage. --- src/bacnet/basic/object/lc.c | 55 ++++++- src/bacnet/basic/object/lc.h | 11 +- test/bacnet/basic/object/lc/src/main.c | 202 +++++++++++++++++++++---- 3 files changed, 228 insertions(+), 40 deletions(-) diff --git a/src/bacnet/basic/object/lc.c b/src/bacnet/basic/object/lc.c index a386688b..8a520abb 100644 --- a/src/bacnet/basic/object/lc.c +++ b/src/bacnet/basic/object/lc.c @@ -31,7 +31,9 @@ /* note: load control objects are required to support LEVEL */ /* minimum interval the load control state machine should process */ +#ifndef LOAD_CONTROL_TASK_INTERVAL_MS #define LOAD_CONTROL_TASK_INTERVAL_MS 1000UL +#endif struct object_data { /* indicates the current load shedding state of the object */ @@ -88,6 +90,7 @@ struct object_data { Manipulated_Object_Relinquish; load_control_manipulated_object_read_callback Manipulated_Object_Read; /* state machine task time tracking per object */ + uint32_t Update_Interval; uint32_t Task_Milliseconds; void *Context; const char *Object_Name; @@ -682,6 +685,46 @@ void Load_Control_State_Machine( return; } +/** + * @brief This property, of type Unsigned, indicates the interval + * in milliseconds at which the state machine updates the output. + * @param object_instance [in] BACnet object instance number + * @return the update-interval for a specific object instance + */ +uint32_t Load_Control_Update_Interval(uint32_t object_instance) +{ + uint32_t value = 0; + struct object_data *pObject; + + pObject = Keylist_Data(Object_List, object_instance); + if (pObject) { + value = pObject->Update_Interval; + } + + return value; +} + +/** + * @brief This property, of type Unsigned, sets the interval + * in milliseconds at which the state machine updates the output. + * @param object_instance [in] BACnet object instance number + * @param value [in] the update-interval for a specific object instance + * @return true if the update-interval for a specific object instance was set + */ +bool Load_Control_Update_Interval_Set(uint32_t object_instance, uint32_t value) +{ + bool status = false; + struct object_data *pObject; + + pObject = Keylist_Data(Object_List, object_instance); + if (pObject) { + pObject->Update_Interval = value; + status = true; + } + + return status; +} + /** * @brief Load Control State Machine Handler * @param object_instance - object-instance number of the object @@ -696,7 +739,7 @@ void Load_Control_Timer(uint32_t object_instance, uint16_t milliseconds) pObject = Object_Instance_Data(object_instance); if (pObject) { pObject->Task_Milliseconds += milliseconds; - if (pObject->Task_Milliseconds >= LOAD_CONTROL_TASK_INTERVAL_MS) { + if (pObject->Task_Milliseconds >= pObject->Update_Interval) { pObject->Task_Milliseconds = 0; datetime_local(&bdatetime.date, &bdatetime.time, NULL, NULL); index = Keylist_Index(Object_List, object_instance); @@ -1753,11 +1796,11 @@ bool Load_Control_Expected_Shed_Level_Set( } /** - * @brief For a given object instance-number, gets the expected shed level + * @brief For a given object instance-number, gets the actual shed level * property * @param object_instance - object-instance number of the object * @param value - holds the value to be retrieved - * @return the expected shed level of this object instance. + * @return the actual shed level of this object instance. */ bool Load_Control_Actual_Shed_Level( uint32_t object_instance, BACNET_SHED_LEVEL *value) @@ -1774,11 +1817,11 @@ bool Load_Control_Actual_Shed_Level( } /** - * @brief For a given object instance-number, sets the expected shed level + * @brief For a given object instance-number, sets the actual shed level * property * @param object_instance - object-instance number of the object * @param value - holds the value to be set - * @return true if expected shed level was set + * @return true if actual shed level was set */ bool Load_Control_Actual_Shed_Level_Set( uint32_t object_instance, BACNET_SHED_LEVEL *value) @@ -2095,6 +2138,8 @@ uint32_t Load_Control_Create(uint32_t object_instance) pObject->Manipulated_Object_Property = PROP_PRESENT_VALUE; /* some state machine variables */ pObject->Previous_Value = BACNET_SHED_INACTIVE; + pObject->Update_Interval = LOAD_CONTROL_TASK_INTERVAL_MS; + pObject->Task_Milliseconds = 0; /* add to list */ index = Keylist_Data_Add(Object_List, object_instance, pObject); if (index < 0) { diff --git a/src/bacnet/basic/object/lc.h b/src/bacnet/basic/object/lc.h index 442f4d02..b36ca4bd 100644 --- a/src/bacnet/basic/object/lc.h +++ b/src/bacnet/basic/object/lc.h @@ -202,15 +202,20 @@ BACNET_STACK_EXPORT void Load_Control_Manipulated_Object_Read_Callback_Set( uint32_t object_instance, load_control_manipulated_object_read_callback cb); -BACNET_STACK_EXPORT -void Load_Control_Timer(uint32_t object_instance, uint16_t milliseconds); - BACNET_STACK_EXPORT int Load_Control_Read_Property(BACNET_READ_PROPERTY_DATA *rpdata); BACNET_STACK_EXPORT bool Load_Control_Write_Property(BACNET_WRITE_PROPERTY_DATA *wp_data); +BACNET_STACK_EXPORT +uint32_t Load_Control_Update_Interval(uint32_t object_instance); +BACNET_STACK_EXPORT +bool Load_Control_Update_Interval_Set(uint32_t object_instance, uint32_t value); + +BACNET_STACK_EXPORT +void Load_Control_Timer(uint32_t object_instance, uint16_t milliseconds); + /* functions used for unit testing */ BACNET_STACK_EXPORT void Load_Control_State_Machine( diff --git a/test/bacnet/basic/object/lc/src/main.c b/test/bacnet/basic/object/lc/src/main.c index 730482da..66926bcf 100644 --- a/test/bacnet/basic/object/lc/src/main.c +++ b/test/bacnet/basic/object/lc/src/main.c @@ -24,6 +24,18 @@ * @{ */ +/** + * @brief compare two floating point values to 3 decimal places + * + * @param x1 - first comparison value + * @param x2 - second comparison value + * @return true if the value is the same to 3 decimal points + */ +static bool is_float_equal(float x1, float x2) +{ + return fabs(x1 - x2) < 0.001; +} + /** * @brief Test */ @@ -390,10 +402,10 @@ static void testLoadControlStateMachine(void) float level = 0; unsigned count = 0; BACNET_DATE_TIME bdatetime = { 0 }; - uint32_t object_index = 0; uint32_t object_instance = 1234; BACNET_OBJECT_PROPERTY_REFERENCE object_property_reference; bool status; + uint32_t update_interval; test_setup(object_instance); status = Load_Control_Valid_Instance(object_instance); @@ -409,9 +421,13 @@ static void testLoadControlStateMachine(void) zassert_equal( object_property_reference.property_identifier, test_object_property_reference.property_identifier, NULL); + update_interval = Load_Control_Update_Interval(object_instance); + zassert_true(update_interval > 0, NULL); + status = Load_Control_Update_Interval_Set(object_instance, 0); + zassert_true(status, NULL); /* validate the state does not change - without any triggers */ for (j = 0; j < 20; j++) { - Load_Control_State_Machine(object_index, &bdatetime); + Load_Control_Timer(object_instance, 1); count = Load_Control_Count(); zassert_equal(count, 1, NULL); zassert_equal( @@ -423,11 +439,11 @@ static void testLoadControlStateMachine(void) Load_Control_WriteProperty_Enable(object_instance, true); Load_Control_WriteProperty_Shed_Duration(object_instance, 60); Load_Control_WriteProperty_Start_Time_Wildcards(object_instance); - Load_Control_State_Machine(object_index, &bdatetime); + Load_Control_Timer(object_instance, 1); zassert_equal( Load_Control_Present_Value(object_instance), BACNET_SHED_REQUEST_PENDING, NULL); - Load_Control_State_Machine(object_index, &bdatetime); + Load_Control_Timer(object_instance, 1); zassert_equal( Load_Control_Present_Value(object_instance), BACNET_SHED_INACTIVE, NULL); @@ -437,16 +453,19 @@ static void testLoadControlStateMachine(void) test_setup(object_instance); status = Load_Control_Valid_Instance(object_instance); zassert_true(status, NULL); + status = Load_Control_Update_Interval_Set(object_instance, 0); + zassert_true(status, NULL); Load_Control_WriteProperty_Request_Shed_Level(object_instance, 0); Load_Control_WriteProperty_Start_Time( object_instance, 2007, 2, 27, 15, 0, 0, 0); Load_Control_WriteProperty_Shed_Duration(object_instance, 5); datetime_set_values(&bdatetime, 2007, 2, 27, 15, 0, 0, 0); - Load_Control_State_Machine(object_index, &bdatetime); + datetime_timesync(&bdatetime.date, &bdatetime.time, false); + Load_Control_Timer(object_instance, 1); zassert_equal( Load_Control_Present_Value(object_instance), BACNET_SHED_REQUEST_PENDING, NULL); - Load_Control_State_Machine(object_index, &bdatetime); + Load_Control_Timer(object_instance, 1); zassert_equal( Load_Control_Present_Value(object_instance), BACNET_SHED_INACTIVE, NULL); @@ -456,17 +475,20 @@ static void testLoadControlStateMachine(void) test_setup(object_instance); status = Load_Control_Valid_Instance(object_instance); zassert_true(status, NULL); + status = Load_Control_Update_Interval_Set(object_instance, 0); + zassert_true(status, NULL); Load_Control_WriteProperty_Enable(object_instance, true); Load_Control_WriteProperty_Request_Shed_Level(object_instance, 1); Load_Control_WriteProperty_Shed_Duration(object_instance, 5); Load_Control_WriteProperty_Start_Time( object_instance, 2007, 2, 27, 15, 0, 0, 0); datetime_set_values(&bdatetime, 2007, 2, 28, 15, 0, 0, 0); - Load_Control_State_Machine(object_index, &bdatetime); + datetime_timesync(&bdatetime.date, &bdatetime.time, false); + Load_Control_Timer(object_instance, 1); zassert_equal( Load_Control_Present_Value(object_instance), BACNET_SHED_REQUEST_PENDING, NULL); - Load_Control_State_Machine(object_index, &bdatetime); + Load_Control_Timer(object_instance, 1); zassert_equal( Load_Control_Present_Value(object_instance), BACNET_SHED_INACTIVE, NULL); @@ -476,46 +498,50 @@ static void testLoadControlStateMachine(void) test_setup(object_instance); status = Load_Control_Valid_Instance(object_instance); zassert_true(status, NULL); + status = Load_Control_Update_Interval_Set(object_instance, 0); + zassert_true(status, NULL); Load_Control_WriteProperty_Enable(object_instance, true); Load_Control_WriteProperty_Request_Shed_Level(object_instance, 1); Load_Control_WriteProperty_Shed_Duration(object_instance, 5); Load_Control_WriteProperty_Start_Time( object_instance, 2007, 2, 27, 15, 0, 0, 0); datetime_set_values(&bdatetime, 2007, 2, 27, 5, 0, 0, 0); - Load_Control_State_Machine(object_index, &bdatetime); + datetime_timesync(&bdatetime.date, &bdatetime.time, false); + Load_Control_Timer(object_instance, 1); zassert_equal( Load_Control_Present_Value(object_instance), BACNET_SHED_REQUEST_PENDING, NULL); - Load_Control_State_Machine(object_index, &bdatetime); + Load_Control_Timer(object_instance, 1); zassert_equal( Load_Control_Present_Value(object_instance), BACNET_SHED_REQUEST_PENDING, NULL); Load_Control_WriteProperty_Request_Shed_Level(object_instance, 2); - Load_Control_State_Machine(object_index, &bdatetime); + Load_Control_Timer(object_instance, 1); zassert_equal( Load_Control_Present_Value(object_instance), BACNET_SHED_REQUEST_PENDING, NULL); Load_Control_WriteProperty_Shed_Duration(object_instance, 6); - Load_Control_State_Machine(object_index, &bdatetime); + Load_Control_Timer(object_instance, 1); zassert_equal( Load_Control_Present_Value(object_instance), BACNET_SHED_REQUEST_PENDING, NULL); Load_Control_WriteProperty_Duty_Window(object_instance, 60); - Load_Control_State_Machine(object_index, &bdatetime); + Load_Control_Timer(object_instance, 1); zassert_equal( Load_Control_Present_Value(object_instance), BACNET_SHED_REQUEST_PENDING, NULL); Load_Control_WriteProperty_Start_Time( object_instance, 2007, 2, 27, 15, 0, 0, 1); - Load_Control_State_Machine(object_index, &bdatetime); + datetime_timesync(&bdatetime.date, &bdatetime.time, false); + Load_Control_Timer(object_instance, 1); zassert_equal( Load_Control_Present_Value(object_instance), BACNET_SHED_REQUEST_PENDING, NULL); - Load_Control_State_Machine(object_index, &bdatetime); + Load_Control_Timer(object_instance, 1); zassert_equal( Load_Control_Present_Value(object_instance), BACNET_SHED_REQUEST_PENDING, NULL); - Load_Control_State_Machine(object_index, &bdatetime); + Load_Control_Timer(object_instance, 1); zassert_equal( Load_Control_Present_Value(object_instance), BACNET_SHED_REQUEST_PENDING, NULL); @@ -525,34 +551,39 @@ static void testLoadControlStateMachine(void) test_setup(object_instance); status = Load_Control_Valid_Instance(object_instance); zassert_true(status, NULL); + status = Load_Control_Update_Interval_Set(object_instance, 0); + zassert_true(status, NULL); Load_Control_WriteProperty_Enable(object_instance, true); Load_Control_WriteProperty_Request_Shed_Level(object_instance, 1); Load_Control_WriteProperty_Shed_Duration(object_instance, 120); Load_Control_WriteProperty_Start_Time( object_instance, 2007, 2, 27, 15, 0, 0, 0); datetime_set_values(&bdatetime, 2007, 2, 27, 5, 0, 0, 0); - Load_Control_State_Machine(object_index, &bdatetime); + datetime_timesync(&bdatetime.date, &bdatetime.time, false); + Load_Control_Timer(object_instance, 1); zassert_equal( Load_Control_Present_Value(object_instance), BACNET_SHED_REQUEST_PENDING, NULL); - Load_Control_State_Machine(object_index, &bdatetime); + Load_Control_Timer(object_instance, 1); zassert_equal( Load_Control_Present_Value(object_instance), BACNET_SHED_REQUEST_PENDING, NULL); /* set to lowest value so we cannot meet the shed level */ - datetime_set_values(&bdatetime, 2007, 2, 27, 16, 0, 0, 0); Test_Present_Value_Priority_Set(0.0f, 16); - Load_Control_State_Machine(object_index, &bdatetime); + datetime_set_values(&bdatetime, 2007, 2, 27, 16, 0, 0, 0); + datetime_timesync(&bdatetime.date, &bdatetime.time, false); + Load_Control_Timer(object_instance, 1); zassert_equal( Load_Control_Present_Value(object_instance), BACNET_SHED_NON_COMPLIANT, NULL); - Load_Control_State_Machine(object_index, &bdatetime); + Load_Control_Timer(object_instance, 1); zassert_equal( Load_Control_Present_Value(object_instance), BACNET_SHED_NON_COMPLIANT, NULL); /* FinishedUnsuccessfulShed */ datetime_set_values(&bdatetime, 2007, 2, 27, 23, 0, 0, 0); - Load_Control_State_Machine(object_index, &bdatetime); + datetime_timesync(&bdatetime.date, &bdatetime.time, false); + Load_Control_Timer(object_instance, 1); zassert_equal( Load_Control_Present_Value(object_instance), BACNET_SHED_INACTIVE, NULL); @@ -562,51 +593,57 @@ static void testLoadControlStateMachine(void) test_setup(object_instance); status = Load_Control_Valid_Instance(object_instance); zassert_true(status, NULL); + status = Load_Control_Update_Interval_Set(object_instance, 0); + zassert_true(status, NULL); Load_Control_WriteProperty_Enable(object_instance, true); Load_Control_WriteProperty_Request_Shed_Level(object_instance, 1); Load_Control_WriteProperty_Shed_Duration(object_instance, 120); Load_Control_WriteProperty_Start_Time( object_instance, 2007, 2, 27, 15, 0, 0, 0); datetime_set_values(&bdatetime, 2007, 2, 27, 5, 0, 0, 0); - Load_Control_State_Machine(object_index, &bdatetime); + datetime_timesync(&bdatetime.date, &bdatetime.time, false); + Load_Control_Timer(object_instance, 1); zassert_equal( Load_Control_Present_Value(object_instance), BACNET_SHED_REQUEST_PENDING, NULL); - Load_Control_State_Machine(object_index, &bdatetime); + Load_Control_Timer(object_instance, 1); zassert_equal( Load_Control_Present_Value(object_instance), BACNET_SHED_REQUEST_PENDING, NULL); /* set to lowest value so we cannot meet the shed level */ - datetime_set_values(&bdatetime, 2007, 2, 27, 16, 0, 0, 0); Test_Present_Value_Priority_Set(0.0f, 16); - Load_Control_State_Machine(object_index, &bdatetime); + datetime_set_values(&bdatetime, 2007, 2, 27, 16, 0, 0, 0); + datetime_timesync(&bdatetime.date, &bdatetime.time, false); + Load_Control_Timer(object_instance, 1); zassert_equal( Load_Control_Present_Value(object_instance), BACNET_SHED_NON_COMPLIANT, NULL); - Load_Control_State_Machine(object_index, &bdatetime); + Load_Control_Timer(object_instance, 1); zassert_equal( Load_Control_Present_Value(object_instance), BACNET_SHED_NON_COMPLIANT, NULL); /* FinishedUnsuccessfulShed */ Load_Control_WriteProperty_Start_Time( object_instance, 2007, 2, 27, 16, 0, 0, 0); - Load_Control_State_Machine(object_index, &bdatetime); + Load_Control_Timer(object_instance, 1); zassert_equal( Load_Control_Present_Value(object_instance), BACNET_SHED_REQUEST_PENDING, NULL); - Load_Control_State_Machine(object_index, &bdatetime); + Load_Control_Timer(object_instance, 1); zassert_equal( Load_Control_Present_Value(object_instance), BACNET_SHED_REQUEST_PENDING, NULL); datetime_set_values(&bdatetime, 2007, 2, 27, 16, 0, 1, 0); - Load_Control_State_Machine(object_index, &bdatetime); + datetime_timesync(&bdatetime.date, &bdatetime.time, false); + Load_Control_Timer(object_instance, 1); zassert_equal( Load_Control_Present_Value(object_instance), BACNET_SHED_NON_COMPLIANT, NULL); /* CanNowComplyWithShed */ Test_Present_Value_Priority_Set(100.0f, 16); datetime_set_values(&bdatetime, 2007, 2, 27, 16, 0, 2, 0); - Load_Control_State_Machine(object_index, &bdatetime); + datetime_timesync(&bdatetime.date, &bdatetime.time, false); + Load_Control_Timer(object_instance, 1); zassert_equal( Load_Control_Present_Value(object_instance), BACNET_SHED_COMPLIANT, NULL); @@ -618,7 +655,8 @@ static void testLoadControlStateMachine(void) Load_Control_Priority_For_Writing(object_instance), priority, NULL); /* FinishedSuccessfulShed */ datetime_set_values(&bdatetime, 2007, 2, 27, 23, 0, 0, 0); - Load_Control_State_Machine(object_index, &bdatetime); + datetime_timesync(&bdatetime.date, &bdatetime.time, false); + Load_Control_State_Machine_Handler(); zassert_equal( Load_Control_Present_Value(object_instance), BACNET_SHED_INACTIVE, NULL); @@ -640,6 +678,12 @@ static void test_Load_Control_Read_Write_Property(void) uint32_t object_instance = 123; unsigned index; bool status = false; + struct shed_level_data shed_level_entry = { 0 }; + BACNET_SHED_LEVEL shed_level = { 0 }; + BACNET_DATE_TIME bdatetime = { 0 }; + uint32_t duration = 0; + bool enable = false; + float wattage = 0.0f; const int32_t skip_fail_property_list[] = { -1 }; test_setup(object_instance); @@ -655,6 +699,100 @@ static void test_Load_Control_Read_Write_Property(void) skip_fail_property_list); bacnet_object_name_ascii_test( object_instance, Load_Control_Name_Set, Load_Control_Name_ASCII); + /* specific property API validation - shed level */ + status = + Load_Control_Shed_Level_Array(object_instance, 1, &shed_level_entry); + zassert_true(status, NULL); + status = Load_Control_Shed_Level_Array_Set( + object_instance, 1, &shed_level_entry); + zassert_true(status, NULL); + status = Load_Control_Shed_Level_Array_Set(4194303, 1, &shed_level_entry); + zassert_false(status, NULL); + status = Load_Control_Shed_Level_Array_Set( + object_instance, 0, &shed_level_entry); + zassert_false(status, NULL); + status = + Load_Control_Shed_Level_Array(object_instance, 0, &shed_level_entry); + zassert_false(status, NULL); + status = Load_Control_Shed_Level_Array(4194303, 1, &shed_level_entry); + zassert_false(status, NULL); + /* specific property API validation - requested shed level */ + status = Load_Control_Requested_Shed_Level(object_instance, &shed_level); + zassert_true(status, NULL); + status = + Load_Control_Requested_Shed_Level_Set(object_instance, &shed_level); + zassert_true(status, NULL); + status = Load_Control_Requested_Shed_Level_Set(4194303, &shed_level); + zassert_false(status, NULL); + status = Load_Control_Requested_Shed_Level(4194303, &shed_level); + zassert_false(status, NULL); + /* specific property API validation - expected shed level */ + status = Load_Control_Expected_Shed_Level(object_instance, &shed_level); + zassert_true(status, NULL); + status = Load_Control_Expected_Shed_Level_Set(object_instance, &shed_level); + zassert_true(status, NULL); + status = Load_Control_Expected_Shed_Level_Set(4194303, &shed_level); + zassert_false(status, NULL); + status = Load_Control_Expected_Shed_Level(4194303, &shed_level); + zassert_false(status, NULL); + /* specific property API validation - actual shed level */ + status = Load_Control_Actual_Shed_Level(object_instance, &shed_level); + zassert_true(status, NULL); + status = Load_Control_Actual_Shed_Level_Set(object_instance, &shed_level); + zassert_true(status, NULL); + status = Load_Control_Actual_Shed_Level_Set(4194303, &shed_level); + zassert_false(status, NULL); + status = Load_Control_Actual_Shed_Level(4194303, &shed_level); + zassert_false(status, NULL); + /* specific property API validation - start time */ + status = Load_Control_Start_Time(object_instance, &bdatetime); + zassert_true(status, NULL); + status = Load_Control_Start_Time_Set(object_instance, &bdatetime); + zassert_true(status, NULL); + status = Load_Control_Start_Time_Set(4194303, &bdatetime); + zassert_false(status, NULL); + status = Load_Control_Start_Time(4194303, &bdatetime); + zassert_false(status, NULL); + /* specific property API validation - shed duration */ + status = Load_Control_Shed_Duration_Set(object_instance, 60); + zassert_true(status, NULL); + duration = Load_Control_Shed_Duration(object_instance); + zassert_equal(duration, 60, NULL); + status = Load_Control_Shed_Duration_Set(4194303, 60); + zassert_false(status, NULL); + duration = Load_Control_Shed_Duration(4194303); + zassert_true(duration == 0, NULL); + /* specific property API validation - duty window */ + status = Load_Control_Duty_Window_Set(object_instance, 60); + zassert_true(status, NULL); + duration = Load_Control_Duty_Window(object_instance); + zassert_equal(duration, 60, NULL); + status = Load_Control_Duty_Window_Set(4194303, 60); + zassert_false(status, NULL); + duration = Load_Control_Duty_Window(4194303); + zassert_true(duration == 0, NULL); + /* specific property API validation - full duty baseline */ + status = Load_Control_Full_Duty_Baseline_Set(object_instance, 60.0f); + zassert_true(status, NULL); + wattage = Load_Control_Full_Duty_Baseline(object_instance); + zassert_true(is_float_equal(wattage, 60.0f), NULL); + status = Load_Control_Full_Duty_Baseline_Set(4194303, 60.0f); + zassert_false(status, NULL); + wattage = Load_Control_Full_Duty_Baseline(4194303); + zassert_true(is_float_equal(wattage, 0.0f), NULL); + /* specific property API validation - enable */ + status = Load_Control_Enable_Set(object_instance, true); + zassert_true(status, NULL); + enable = Load_Control_Enable(object_instance); + zassert_true(enable, NULL); + status = Load_Control_Enable_Set(4194303, true); + zassert_false(status, NULL); + enable = Load_Control_Enable(4194303); + zassert_false(enable, NULL); + /* specific property API validation - context */ + Load_Control_Context_Set( + object_instance, Load_Control_Context_Get(object_instance)); + test_teardown(object_instance); }