Extended load-control object unit test validation code coverage.

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) {

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(

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);
 }